basalt-ui 1.16.0 → 1.18.0

package/src/charts/series.ts

@@ -66,6 +66,11 @@ export type SeriesStyle = {
    * that lies is the thing the derived-legend rule exists to prevent). The TOOLTIP ROW swatch and
    * the CROSSHAIR DOT deliberately do NOT honor it: those are 12px value-readout chips where a
    * sub-1 opacity reads as a rendering bug, not as data.
+   *
+   * Applies to STROKES only, so it silently no-ops on a `mark: 'bar'`/`'area'` series — a bar
+   * swatch has no stroke to dim. Dim those with `fillOpacity` instead. This bites the
+   * zone/reference-legend idiom in particular (`mark: 'bar'`, `getValue: () => null`), where
+   * reaching for `strokeOpacity` looks right and does nothing.
    */
   strokeOpacity?: number
   /** Which y-axis this series is measured against. Default 'left'. `'right'` is what makes a
@@ -96,8 +101,9 @@ export type ChartSeries<T> = SeriesStyle & {
    * alongside the value so a row can read fields beyond the plotted number (e.g. `97.5 kg (92.5 ×
    * 3)`). */
   formatValue?: (v: number, d: T) => string
-  /** PR star / status dot. Return null for no marker at that point. */
-  getMarker?: (d: T) => { color?: string; r?: number } | null
+  /** PR star / status dot. Return null for no marker at that point. `ring` defaults true (today's
+   * punched-out stroke, unchanged); `false` omits the stroke entirely. `fillOpacity` defaults 1. */
+  getMarker?: (d: T) => { color?: string; r?: number; fillOpacity?: number; ring?: boolean } | null
 }
 
 /** A single derived tooltip row, ready for `TooltipRow`. */

package/src/charts/utils/domain.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test'
-import { padAutoLower } from './domain'
+import { padAutoLower, padAutoUpper } from './domain'
 
 describe('padAutoLower', () => {
   test('stays at 0 for the default zero-baseline case (never goes negative)', () => {
@@ -22,3 +22,33 @@ describe('padAutoLower', () => {
     }
   })
 })
+
+describe('padAutoUpper', () => {
+  test('stays at 0 (never pushed positive)', () => {
+    expect(padAutoUpper(0, 1.1)).toBe(0)
+  })
+
+  test('pads UP above a positive candidate', () => {
+    expect(padAutoUpper(78, 1.1)).toBeCloseTo(85.8, 5)
+  })
+
+  test('pads further up (toward and past zero) for a negative candidate', () => {
+    expect(padAutoUpper(-5, 1.1)).toBeCloseTo(-4.5454, 3)
+  })
+
+  test('upper never lands below the candidate it was derived from', () => {
+    for (const candidate of [-10, -0.5, 0, 0.5, 10, 78]) {
+      expect(padAutoUpper(candidate, 1.1)).toBeGreaterThanOrEqual(candidate)
+    }
+  })
+
+  test('the autoMaxFloor case: dataMax 3.2, pad 1.1, floor 6 -> 6.6', () => {
+    expect(padAutoUpper(Math.max(3.2, 6), 1.1)).toBeCloseTo(6.6, 5)
+  })
+
+  test('is the exact mirror of padAutoLower — same magnitude, opposite direction', () => {
+    for (const candidate of [-10, -0.5, 0.5, 10, 78]) {
+      expect(padAutoUpper(candidate, 1.1)).toBeCloseTo(-padAutoLower(-candidate, 1.1), 5)
+    }
+  })
+})

package/src/charts/utils/domain.ts

@@ -20,3 +20,22 @@ export function padAutoLower(candidate: number, pad: number): number {
   if (candidate === 0) return 0
   return candidate > 0 ? candidate / pad : candidate * pad
 }
+
+/**
+ * Auto y-domain upper-bound padding — the exact mirror of {@link padAutoLower}, sharing its
+ * sign-safety: pad AWAY from zero (`upper >= candidate`), never toward it. `candidate` is the
+ * caller's `Math.max(dataMax, floor)` — the `autoMaxFloor` clamp has already been applied, so
+ * padding runs AFTER the floor, not before it. Applying the floor post-pad (the pre-existing bug)
+ * lands a floored axis top exactly on the floor value with zero headroom — a target line pinned to
+ * that floor then sits glued to the plot edge instead of getting the same breathing room every
+ * other bound gets.
+ *
+ *  - `candidate === 0` stays exactly 0 — never pushed positive.
+ *  - `candidate > 0` multiplies by `pad`, moving the ceiling further UP (away from zero).
+ *  - `candidate < 0` divides by `pad`, moving the ceiling UP toward (and past) zero — the mirror of
+ *    `padAutoLower`'s `candidate > 0` branch.
+ */
+export function padAutoUpper(candidate: number, pad: number): number {
+  if (candidate === 0) return 0
+  return candidate > 0 ? candidate * pad : candidate / pad
+}