@chipmobilesdk/rn-chart 0.2.0 → 0.2.1

package/src/geometry/timeSeries.ts

@@ -1,168 +1,168 @@
-/**
- * Time-series geometry: one stroked path per series over an instant domain.
- *
- * Gaps are the interesting part. A non-known value contributes `null` to the
- * point list, `linePath` lifts the pen there, and the line simply does not
- * exist across the gap (FR-012).
- *
- * PURE. No React, no SVG.
- */
-import type { ChartDatasource, Series } from '../contract/datasource';
-import { isKnown, isWithheld } from '../contract/value';
-import type { HitRegion } from './hitTest';
-import { insetForAxes, plotBottom, plotRight } from './layout';
-import { horizontalMarkers, markerDomainValues } from './markers';
-import { linePath, type MaybePt } from './path';
-import { domainFrom, linearScale, timeScale, widenDegenerateDomain } from './scale';
-import { niceTickValues, thinTicks, type Tick } from './ticks';
-import type { GeometryInput, MarkPath, ResolvedGeometry } from './types';
-
-export interface TimeSeriesOptions {
-	/** Window supplied by the app. Users cannot draw one (pan/zoom out of scope). */
-	readonly range?: { readonly from: number; readonly to: number };
-}
-
-function visiblePoints<M>(series: Series<M>, range?: TimeSeriesOptions['range']) {
-	const points = [...series.points]
-		.filter(p => p.position.kind === 'instant')
-		// Out-of-order input must still produce a correct axis.
-		.sort((a, b) => {
-			const at = a.position.kind === 'instant' ? a.position.at : 0;
-			const bt = b.position.kind === 'instant' ? b.position.at : 0;
-			return at - bt;
-		});
-
-	if (!range) {
-		return points;
-	}
-	return points.filter(p => {
-		const at = p.position.kind === 'instant' ? p.position.at : 0;
-		return at >= range.from && at <= range.to;
-	});
-}
-
-export function buildTimeSeriesGeometry<M>(
-	datasource: ChartDatasource<M>,
-	input: GeometryInput,
-	options: TimeSeriesOptions = {},
-): ResolvedGeometry {
-	const instants: number[] = [];
-	const values: number[] = [];
-	let excluded = 0;
-
-	for (const series of datasource.series) {
-		for (const point of visiblePoints(series, options.range)) {
-			if (point.position.kind === 'instant') {
-				instants.push(point.position.at);
-			}
-			if (isKnown(point.value)) {
-				values.push(point.value.value);
-			} else {
-				excluded += 1;
-			}
-		}
-	}
-
-	if (instants.length === 0) {
-		return {
-			plot: input.plot,
-			paths: [],
-			markers: [],
-			labels: [],
-			xTicks: [],
-			yTicks: [],
-			hitRegions: [],
-			incomplete: excluded > 0,
-		};
-	}
-
-	// Tick labels depend only on the domains, so the plot can make room for
-	// them before anything is projected.
-	// Widened here, as the scales would, so the ticks label the axes actually drawn.
-	const xDomain = widenDegenerateDomain(domainFrom(instants));
-	const yDomain = widenDegenerateDomain(
-		domainFrom([...values, ...markerDomainValues(datasource.markers)], { padFraction: 0.1 }),
-	);
-	const xTickValues = niceTickValues(xDomain, 4);
-	const yTickValues = niceTickValues(yDomain, 4);
-	const plot = insetForAxes(input.plot, {
-		xLabels: xTickValues.map(input.formatInstant),
-		yLabels: yTickValues.map(input.formatValue),
-		fontSize: input.fontSize,
-	});
-
-	const x = timeScale(xDomain, { min: plot.x, max: plotRight(plot) });
-	const y = linearScale(yDomain, { min: plotBottom(plot), max: plot.y });
-
-	const paths: MarkPath[] = [];
-	const hitRegions: HitRegion[] = [];
-
-	for (const series of datasource.series) {
-		if (series.hidden) {
-			continue;
-		}
-
-		const pts: MaybePt[] = [];
-
-		for (const point of visiblePoints(series, options.range)) {
-			const at = point.position.kind === 'instant' ? point.position.at : 0;
-			const px = x.project(at);
-
-			if (!isKnown(point.value)) {
-				// The gap. No coordinate is produced, so no segment can span it.
-				pts.push(null);
-				continue;
-			}
-
-			const py = y.project(point.value.value);
-			pts.push({ x: px, y: py });
-
-			hitRegions.push({
-				seriesId: series.id,
-				pointId: point.id,
-				x: px,
-				y: py,
-				// Withheld values are never selectable, so a callback can never
-				// carry one (FR-053).
-				selectable: !isWithheld(point.value),
-			});
-		}
-
-		const d = linePath(pts);
-		if (d.length > 0) {
-			paths.push({
-				key: `line-${series.id}`,
-				seriesId: series.id,
-				d,
-				color: input.seriesColors[series.id],
-				pattern: series.pattern ?? 'solid',
-				filled: false,
-			});
-		}
-	}
-
-	const xTicks: Tick[] = xTickValues.map(v => ({
-		value: v,
-		position: x.project(v),
-		label: input.formatInstant(v),
-	}));
-
-	const yTicks: Tick[] = yTickValues.map(v => ({
-		value: v,
-		position: y.project(v),
-		label: input.formatValue(v),
-	}));
-
-	const markers = horizontalMarkers(datasource.markers, plot, y.project);
-
-	return {
-		plot,
-		paths,
-		markers: markers.lines,
-		labels: markers.labels,
-		xTicks: thinTicks(xTicks, input.fontSize, plot.width),
-		yTicks,
-		hitRegions,
-		incomplete: excluded > 0,
-	};
-}
+/**
+ * Time-series geometry: one stroked path per series over an instant domain.
+ *
+ * Gaps are the interesting part. A non-known value contributes `null` to the
+ * point list, `linePath` lifts the pen there, and the line simply does not
+ * exist across the gap (FR-012).
+ *
+ * PURE. No React, no SVG.
+ */
+import type { ChartDatasource, Series } from '../contract/datasource';
+import { isKnown, isWithheld } from '../contract/value';
+import type { HitRegion } from './hitTest';
+import { insetForAxes, plotBottom, plotRight } from './layout';
+import { horizontalMarkers, markerDomainValues } from './markers';
+import { linePath, type MaybePt } from './path';
+import { domainFrom, linearScale, timeScale, widenDegenerateDomain } from './scale';
+import { niceTickValues, thinTicks, type Tick } from './ticks';
+import type { GeometryInput, MarkPath, ResolvedGeometry } from './types';
+
+export interface TimeSeriesOptions {
+	/** Window supplied by the app. Users cannot draw one (pan/zoom out of scope). */
+	readonly range?: { readonly from: number; readonly to: number };
+}
+
+function visiblePoints<M>(series: Series<M>, range?: TimeSeriesOptions['range']) {
+	const points = [...series.points]
+		.filter(p => p.position.kind === 'instant')
+		// Out-of-order input must still produce a correct axis.
+		.sort((a, b) => {
+			const at = a.position.kind === 'instant' ? a.position.at : 0;
+			const bt = b.position.kind === 'instant' ? b.position.at : 0;
+			return at - bt;
+		});
+
+	if (!range) {
+		return points;
+	}
+	return points.filter(p => {
+		const at = p.position.kind === 'instant' ? p.position.at : 0;
+		return at >= range.from && at <= range.to;
+	});
+}
+
+export function buildTimeSeriesGeometry<M>(
+	datasource: ChartDatasource<M>,
+	input: GeometryInput,
+	options: TimeSeriesOptions = {},
+): ResolvedGeometry {
+	const instants: number[] = [];
+	const values: number[] = [];
+	let excluded = 0;
+
+	for (const series of datasource.series) {
+		for (const point of visiblePoints(series, options.range)) {
+			if (point.position.kind === 'instant') {
+				instants.push(point.position.at);
+			}
+			if (isKnown(point.value)) {
+				values.push(point.value.value);
+			} else {
+				excluded += 1;
+			}
+		}
+	}
+
+	if (instants.length === 0) {
+		return {
+			plot: input.plot,
+			paths: [],
+			markers: [],
+			labels: [],
+			xTicks: [],
+			yTicks: [],
+			hitRegions: [],
+			incomplete: excluded > 0,
+		};
+	}
+
+	// Tick labels depend only on the domains, so the plot can make room for
+	// them before anything is projected.
+	// Widened here, as the scales would, so the ticks label the axes actually drawn.
+	const xDomain = widenDegenerateDomain(domainFrom(instants));
+	const yDomain = widenDegenerateDomain(
+		domainFrom([...values, ...markerDomainValues(datasource.markers)], { padFraction: 0.1 }),
+	);
+	const xTickValues = niceTickValues(xDomain, 4);
+	const yTickValues = niceTickValues(yDomain, 4);
+	const plot = insetForAxes(input.plot, {
+		xLabels: xTickValues.map(input.formatInstant),
+		yLabels: yTickValues.map(input.formatValue),
+		fontSize: input.fontSize,
+	});
+
+	const x = timeScale(xDomain, { min: plot.x, max: plotRight(plot) });
+	const y = linearScale(yDomain, { min: plotBottom(plot), max: plot.y });
+
+	const paths: MarkPath[] = [];
+	const hitRegions: HitRegion[] = [];
+
+	for (const series of datasource.series) {
+		if (series.hidden) {
+			continue;
+		}
+
+		const pts: MaybePt[] = [];
+
+		for (const point of visiblePoints(series, options.range)) {
+			const at = point.position.kind === 'instant' ? point.position.at : 0;
+			const px = x.project(at);
+
+			if (!isKnown(point.value)) {
+				// The gap. No coordinate is produced, so no segment can span it.
+				pts.push(null);
+				continue;
+			}
+
+			const py = y.project(point.value.value);
+			pts.push({ x: px, y: py });
+
+			hitRegions.push({
+				seriesId: series.id,
+				pointId: point.id,
+				x: px,
+				y: py,
+				// Withheld values are never selectable, so a callback can never
+				// carry one (FR-053).
+				selectable: !isWithheld(point.value),
+			});
+		}
+
+		const d = linePath(pts);
+		if (d.length > 0) {
+			paths.push({
+				key: `line-${series.id}`,
+				seriesId: series.id,
+				d,
+				color: input.seriesColors[series.id],
+				pattern: series.pattern ?? 'solid',
+				filled: false,
+			});
+		}
+	}
+
+	const xTicks: Tick[] = xTickValues.map(v => ({
+		value: v,
+		position: x.project(v),
+		label: input.formatInstant(v),
+	}));
+
+	const yTicks: Tick[] = yTickValues.map(v => ({
+		value: v,
+		position: y.project(v),
+		label: input.formatValue(v),
+	}));
+
+	const markers = horizontalMarkers(datasource.markers, plot, y.project);
+
+	return {
+		plot,
+		paths,
+		markers: markers.lines,
+		labels: markers.labels,
+		xTicks: thinTicks(xTicks, input.fontSize, plot.width),
+		yTicks,
+		hitRegions,
+		incomplete: excluded > 0,
+	};
+}

package/src/geometry/types.ts

@@ -1,94 +1,94 @@
-/**
- * The single memoized artefact each chart produces.
- *
- * `ResolvedGeometry` is keyed on datasource identity, plot rectangle, theme
- * identity, and formatter identity — and deliberately **not** on selection.
- * Highlighting a point must repaint the highlight, not recompute every scale
- * and path string (research.md R3, FR-073).
- *
- * PURE. No React, no SVG.
- */
-import type { SeriesPattern } from '../contract/datasource';
-import type { NonValueTexture } from '../contract/theme';
-import type { HitRegion } from './hitTest';
-import type { PlotRect } from './layout';
-import type { Tick } from './ticks';
-
-/** One drawable group. Element count scales with these, never with points. */
-export interface MarkPath {
-	readonly key: string;
-	readonly seriesId: string;
-	readonly d: string;
-	readonly color: string;
-	readonly pattern: SeriesPattern;
-	/** Filled shapes (bars, arcs, cells) versus stroked ones (lines). */
-	readonly filled: boolean;
-	/** Set on marks standing in for a non-value class: texture, not hue. */
-	readonly texture?: NonValueTexture;
-	readonly opacity?: number;
-}
-
-/** A target, baseline, or threshold drawn across the plot. */
-export interface MarkerLine {
-	readonly id: string;
-	readonly d: string;
-	readonly label?: string;
-	readonly kind: 'target' | 'baseline' | 'threshold';
-}
-
-/** Text the chart draws itself, such as progress values or segment labels. */
-export interface GeometryLabel {
-	readonly key: string;
-	readonly text: string;
-	readonly x: number;
-	readonly y: number;
-	readonly anchor: 'start' | 'middle' | 'end';
-	readonly muted?: boolean;
-}
-
-export interface ResolvedGeometry {
-	readonly plot: PlotRect;
-	readonly paths: readonly MarkPath[];
-	readonly markers: readonly MarkerLine[];
-	readonly labels: readonly GeometryLabel[];
-	readonly xTicks: readonly Tick[];
-	readonly yTicks: readonly Tick[];
-	readonly hitRegions: readonly HitRegion[];
-	/**
-	 * True when something was excluded from a total or proportion, so the chart
-	 * can say so rather than presenting a partial figure as whole (FR-013).
-	 */
-	readonly incomplete: boolean;
-}
-
-export const EMPTY_GEOMETRY: ResolvedGeometry = {
-	plot: { x: 0, y: 0, width: 0, height: 0 },
-	paths: [],
-	markers: [],
-	labels: [],
-	xTicks: [],
-	yTicks: [],
-	hitRegions: [],
-	incomplete: false,
-};
-
-/** Inputs every family geometry builder needs. */
-export interface GeometryInput {
-	readonly plot: PlotRect;
-	readonly fontSize: number;
-	/** Resolved per series, so geometry never reaches into the theme itself. */
-	readonly seriesColors: Readonly<Record<string, string>>;
-	/**
-	 * Distribution segment colours keyed by `segmentKey(seriesId, pointId)`.
-	 * Only resolved for the distribution family. Point colours used to share
-	 * `seriesColors`, so a point id equal to a series id overwrote that series.
-	 */
-	readonly segmentColors?: Readonly<Record<string, string>>;
-	readonly nonValueTextures: Readonly<
-		Record<'unknown' | 'notApplicable' | 'withheld', NonValueTexture>
-	>;
-	readonly heatmapRamp: readonly string[];
-	readonly formatValue: (value: number) => string;
-	readonly formatCategory: (raw: string) => string;
-	readonly formatInstant: (at: number) => string;
-}
+/**
+ * The single memoized artefact each chart produces.
+ *
+ * `ResolvedGeometry` is keyed on datasource identity, plot rectangle, theme
+ * identity, and formatter identity — and deliberately **not** on selection.
+ * Highlighting a point must repaint the highlight, not recompute every scale
+ * and path string (research.md R3, FR-073).
+ *
+ * PURE. No React, no SVG.
+ */
+import type { SeriesPattern } from '../contract/datasource';
+import type { NonValueTexture } from '../contract/theme';
+import type { HitRegion } from './hitTest';
+import type { PlotRect } from './layout';
+import type { Tick } from './ticks';
+
+/** One drawable group. Element count scales with these, never with points. */
+export interface MarkPath {
+	readonly key: string;
+	readonly seriesId: string;
+	readonly d: string;
+	readonly color: string;
+	readonly pattern: SeriesPattern;
+	/** Filled shapes (bars, arcs, cells) versus stroked ones (lines). */
+	readonly filled: boolean;
+	/** Set on marks standing in for a non-value class: texture, not hue. */
+	readonly texture?: NonValueTexture;
+	readonly opacity?: number;
+}
+
+/** A target, baseline, or threshold drawn across the plot. */
+export interface MarkerLine {
+	readonly id: string;
+	readonly d: string;
+	readonly label?: string;
+	readonly kind: 'target' | 'baseline' | 'threshold';
+}
+
+/** Text the chart draws itself, such as progress values or segment labels. */
+export interface GeometryLabel {
+	readonly key: string;
+	readonly text: string;
+	readonly x: number;
+	readonly y: number;
+	readonly anchor: 'start' | 'middle' | 'end';
+	readonly muted?: boolean;
+}
+
+export interface ResolvedGeometry {
+	readonly plot: PlotRect;
+	readonly paths: readonly MarkPath[];
+	readonly markers: readonly MarkerLine[];
+	readonly labels: readonly GeometryLabel[];
+	readonly xTicks: readonly Tick[];
+	readonly yTicks: readonly Tick[];
+	readonly hitRegions: readonly HitRegion[];
+	/**
+	 * True when something was excluded from a total or proportion, so the chart
+	 * can say so rather than presenting a partial figure as whole (FR-013).
+	 */
+	readonly incomplete: boolean;
+}
+
+export const EMPTY_GEOMETRY: ResolvedGeometry = {
+	plot: { x: 0, y: 0, width: 0, height: 0 },
+	paths: [],
+	markers: [],
+	labels: [],
+	xTicks: [],
+	yTicks: [],
+	hitRegions: [],
+	incomplete: false,
+};
+
+/** Inputs every family geometry builder needs. */
+export interface GeometryInput {
+	readonly plot: PlotRect;
+	readonly fontSize: number;
+	/** Resolved per series, so geometry never reaches into the theme itself. */
+	readonly seriesColors: Readonly<Record<string, string>>;
+	/**
+	 * Distribution segment colours keyed by `segmentKey(seriesId, pointId)`.
+	 * Only resolved for the distribution family. Point colours used to share
+	 * `seriesColors`, so a point id equal to a series id overwrote that series.
+	 */
+	readonly segmentColors?: Readonly<Record<string, string>>;
+	readonly nonValueTextures: Readonly<
+		Record<'unknown' | 'notApplicable' | 'withheld', NonValueTexture>
+	>;
+	readonly heatmapRamp: readonly string[];
+	readonly formatValue: (value: number) => string;
+	readonly formatCategory: (raw: string) => string;
+	readonly formatInstant: (at: number) => string;
+}