@carto/ps-react-ui 5.3.0 → 5.5.0

package/src/widgets-v2/category/category.test.tsx

@@ -238,6 +238,73 @@ describe('<Category> bridge', () => {
       expect(fills[0]!.style.width).toBe('25%')
     })
 
+    it('keeps the zero centred when a transform hides every negative row', () => {
+      render(
+        <Provider
+          id='cat-bridge-auto-neg'
+          data={[
+            [
+              { name: 'A', value: 1 },
+              { name: 'B', value: -1 },
+            ],
+          ]}
+        >
+          <Category />
+        </Provider>,
+      )
+      act(() => {
+        getWidgetStore('cat-bridge-auto-neg').setState({
+          data: [[{ name: 'A', value: 1 }]],
+        })
+      })
+      const fills = getBarFills()
+      expect(fills).toHaveLength(1)
+      expect(fills[0]!.style.left).toBe('50%')
+      expect(fills[0]!.style.width).toBe('50%')
+    })
+
+    it.each([
+      [
+        'positive-only',
+        [50, 25],
+        [
+          ['0%', '50%'],
+          ['0%', '25%'],
+        ],
+      ],
+      [
+        'negative-only',
+        [-50, -25],
+        [
+          ['50%', '50%'],
+          ['75%', '25%'],
+        ],
+      ],
+      [
+        'mixed',
+        [50, -25],
+        [
+          ['50%', '25%'],
+          ['37.5%', '12.5%'],
+        ],
+      ],
+    ])(
+      'applies ±100 overrides only on the side %s data reaches',
+      (_, values, expected) => {
+        render(
+          <Provider
+            id={`cat-bridge-side-${values.join('')}`}
+            data={[values.map((value, i) => ({ name: `R${i}`, value }))]}
+          >
+            <Category maxOverride={100} minOverride={-100} />
+          </Provider>,
+        )
+        expect(getBarFills().map((f) => [f.style.left, f.style.width])).toEqual(
+          expected,
+        )
+      },
+    )
+
     it('consumer-supplied maxOverride wins over the rawData auto-fill', () => {
       render(
         <Provider id='cat-bridge-auto-3' data={PEAK_DATA}>

package/src/widgets-v2/category/category.tsx

@@ -42,13 +42,19 @@ interface CategoryWidgetState extends WidgetState {
 
 const NO_HIDDEN: ReadonlySet<number> = new Set()
 
-function maxFromCategoryData(d: CategoryWidgetData | undefined): number {
-  if (!d) return 0
-  let m = 0
-  for (const series of d) {
-    for (const item of series) if (item.value > m) m = item.value
+/** `[min, max]` of every value, each clamped to include zero. */
+function extentFromCategoryData(
+  d: CategoryWidgetData | undefined,
+): [min: number, max: number] {
+  let min = 0
+  let max = 0
+  for (const series of d ?? []) {
+    for (const item of series) {
+      if (item.value < min) min = item.value
+      if (item.value > max) max = item.value
+    }
   }
-  return m
+  return [min, max]
 }
 
 export interface CategoryProps {
@@ -84,6 +90,12 @@ export interface CategoryProps {
    * regardless of the data.
    */
   maxOverride?: number
+  /**
+   * Bottom of the bar scale for negative values, the mirror of
+   * `maxOverride`. Auto-filled from `rawData` the same way, so the zero
+   * does not move when the Searcher hides every negative row.
+   */
+  minOverride?: number
   /**
    * Visual density of the bar primitive. `'small'` (default) keeps the
    * historical 4px-tall pill; `'medium'` switches to a 12px-tall track
@@ -113,23 +125,27 @@ export function Category({
   labels,
   onShowAll,
   maxOverride,
+  minOverride,
   size,
   stacked,
 }: CategoryProps) {
   const id = useWidgetId()
   const slice = useWidgetShallow(id, categorySelector)
-  // Auto-fill `maxOverride` from `rawData` so bar widths stay coherent
-  // across data transforms (e.g., the Searcher filtering rows in/out).
-  // Consumer's explicit value always wins; we only fill when omitted
-  // AND `rawData` has at least one positive value (CategoryUI's
-  // `maxOverride > 0` guard would reject 0 anyway, but skipping is
-  // cleaner — it lets the live fallback path handle the empty case).
-  const naturalMax = useMemo(
-    () => maxFromCategoryData(slice.rawData),
+  // Auto-fill both ends of the scale from `rawData` so bar widths and the
+  // zero stay coherent across data transforms (e.g., the Searcher filtering
+  // rows in/out). Consumer's explicit value wins, but each end only applies
+  // when `rawData` reaches past zero on that side: a relative-data wiring can
+  // then pass `100` / `-100` unconditionally and positive-only data keeps its
+  // zero at the left edge, negative-only at the right. With no data on a side
+  // we pass nothing and CategoryUI falls back to the live `data`.
+  const [naturalMin, naturalMax] = useMemo(
+    () => extentFromCategoryData(slice.rawData),
     [slice.rawData],
   )
   const effectiveMaxOverride =
-    maxOverride ?? (naturalMax > 0 ? naturalMax : undefined)
+    naturalMax > 0 ? (maxOverride ?? naturalMax) : undefined
+  const effectiveMinOverride =
+    naturalMin < 0 ? (minOverride ?? naturalMin) : undefined
 
   const seriesKey = JSON.stringify(series?.map((s) => s.name) ?? [])
   const stored = useWidget<
@@ -156,6 +172,7 @@ export function Category({
       labels={labels}
       onShowAll={onShowAll}
       maxOverride={effectiveMaxOverride}
+      minOverride={effectiveMinOverride}
       size={size}
       stacked={stacked}
       hiddenSeries={hiddenSeries}

package/src/widgets-v2/category/components/category-bar-stacked.test.tsx

@@ -118,4 +118,22 @@ describe('<CategoryBarStacked>', () => {
     const track = container.querySelector('[data-size]')
     expect(track!.getAttribute('data-size')).toBe('medium')
   })
+
+  it('diverges from zeroPct: positives stack rightwards, negatives leftwards', () => {
+    const { container } = render(
+      <CategoryBarStacked
+        values={[20, -10, 30, -20]}
+        colors={['a', 'b', 'c', 'd']}
+        maxValue={100}
+        zeroPct={50}
+      />,
+    )
+    const segs = getSegments(container)
+    expect(segs.map((s) => [s.style.left, s.style.width])).toEqual([
+      ['50%', '20%'],
+      ['40%', '10%'],
+      ['70%', '30%'],
+      ['20%', '20%'],
+    ])
+  })
 })

package/src/widgets-v2/category/components/category-bar-stacked.tsx

@@ -1,6 +1,7 @@
 import { Box } from '@mui/material'
 import type { CategorySize } from '../types'
 import { styles } from '../style'
+import { ZeroTickWrap } from './category-bar'
 
 export interface CategoryBarStackedProps {
   /** One value per series. Zero values render no segment (visually + in the DOM). */
@@ -13,6 +14,13 @@ export interface CategoryBarStackedProps {
    * so cross-row comparison is preserved.
    */
   maxValue: number
+  /**
+   * Where the zero sits, as a percentage of the track. `0` (default) is the
+   * positive-only layout. Positive segments stack rightwards from it and
+   * negative ones leftwards, both scaled by `maxValue` against the full
+   * track width.
+   */
+  zeroPct?: number
   /** Visual density. Forwarded to the track styling; segments inherit height. */
   size?: CategorySize
 }
@@ -33,41 +41,46 @@ export function CategoryBarStacked({
   values,
   colors,
   maxValue,
+  zeroPct = 0,
   size = 'small',
 }: CategoryBarStackedProps) {
-  // Cumulative offsets pre-computed up front so the render map function
-  // stays pure (no mutable closure variable — keeps the React Compiler
-  // immutability check happy).
-  const offsets: number[] = []
+  // Left edges pre-computed up front so the render map function stays pure
+  // (no mutable closure variable — keeps the React Compiler immutability
+  // check happy). Each sign keeps its own running sum away from the zero.
+  const lefts: number[] = []
   {
-    let acc = 0
+    let pos = 0
+    let neg = 0
     for (const v of values) {
-      offsets.push(acc)
-      acc += v
+      if (v < 0) neg -= v
+      lefts.push(v < 0 ? -neg : pos)
+      if (v > 0) pos += v
     }
   }
   return (
-    <Box sx={styles.bar[size]} data-size={size}>
-      {values.map((v, i) => {
-        if (v <= 0) return null
-        const leftPct = maxValue > 0 ? (offsets[i]! / maxValue) * 100 : 0
-        const pct = maxValue > 0 ? (v / maxValue) * 100 : 0
-        return (
-          <Box
-            // Segments are keyed by per-series colour (the only stable
-            // distinguishing field on this side) plus the segment index for
-            // when callers reuse palette colours across series.
-            key={`seg-${colors[i] ?? 'none'}-${i}`}
-            sx={styles.stackedSegment[size]}
-            style={{
-              left: `${leftPct}%`,
-              width: `${pct}%`,
-              backgroundColor: colors[i] ?? '',
-            }}
-            data-bar-fill='true'
-          />
-        )
-      })}
-    </Box>
+    <ZeroTickWrap zeroPct={zeroPct > 0 && zeroPct < 100 ? zeroPct : undefined}>
+      <Box sx={styles.bar[size]} data-size={size}>
+        {values.map((v, i) => {
+          if (v === 0 || maxValue <= 0) return null
+          const leftPct = zeroPct + (lefts[i]! / maxValue) * 100
+          const pct = (Math.abs(v) / maxValue) * 100
+          return (
+            <Box
+              // Segments are keyed by per-series colour (the only stable
+              // distinguishing field on this side) plus the segment index for
+              // when callers reuse palette colours across series.
+              key={`seg-${colors[i] ?? 'none'}-${i}`}
+              sx={styles.stackedSegment[size]}
+              style={{
+                left: `${leftPct}%`,
+                width: `${pct}%`,
+                backgroundColor: colors[i] ?? '',
+              }}
+              data-bar-fill='true'
+            />
+          )
+        })}
+      </Box>
+    </ZeroTickWrap>
   )
 }

package/src/widgets-v2/category/components/category-bar.test.tsx

@@ -61,4 +61,70 @@ describe('<CategoryBar>', () => {
     expect(track).toBeTruthy()
     expect(track!.getAttribute('data-size')).toBe('medium')
   })
+
+  describe('signed domain (minValue < 0)', () => {
+    it('grows a positive value rightwards from the zero', () => {
+      const { container } = render(
+        <CategoryBar
+          value={0.5}
+          minValue={-1}
+          maxValue={1}
+          color='rgb(0, 0, 0)'
+        />,
+      )
+      const fill = getFill(container)!
+      expect(fill.style.left).toBe('50%')
+      expect(fill.style.width).toBe('25%')
+    })
+
+    it('grows a negative value leftwards from the zero, in the same color', () => {
+      const { container } = render(
+        <CategoryBar
+          value={-0.5}
+          minValue={-1}
+          maxValue={1}
+          color='rgb(0, 200, 0)'
+        />,
+      )
+      const fill = getFill(container)!
+      expect(fill.style.left).toBe('25%')
+      expect(fill.style.width).toBe('25%')
+      expect(fill.style.backgroundColor).toBe('rgb(0, 200, 0)')
+    })
+
+    it('squares the end that grows out of the zero', () => {
+      const { container: pos } = render(
+        <CategoryBar value={1} minValue={-1} maxValue={1} color='red' />,
+      )
+      const { container: neg } = render(
+        <CategoryBar value={-1} minValue={-1} maxValue={1} color='red' />,
+      )
+      expect(getFill(pos)!.style.borderTopLeftRadius).toBe('0px')
+      expect(getFill(pos)!.style.borderTopRightRadius).toBe('')
+      expect(getFill(neg)!.style.borderTopRightRadius).toBe('0px')
+      expect(getFill(neg)!.style.borderTopLeftRadius).toBe('')
+    })
+
+    it('puts the zero tick before the track so the bar paints over it', () => {
+      const { container } = render(
+        <CategoryBar value={1} minValue={-1} maxValue={1} color='red' />,
+      )
+      const tick = container.querySelector('[data-zero-tick="true"]')!
+      expect(tick.nextElementSibling!.getAttribute('data-size')).toBe('small')
+    })
+
+    it('hangs from the right edge when the domain is negative-only', () => {
+      const { container } = render(
+        <CategoryBar
+          value={-1}
+          minValue={-4}
+          maxValue={0}
+          color='rgb(0, 0, 0)'
+        />,
+      )
+      const fill = getFill(container)!
+      expect(fill.style.left).toBe('75%')
+      expect(fill.style.width).toBe('25%')
+    })
+  })
 })

package/src/widgets-v2/category/components/category-bar.tsx

@@ -1,3 +1,4 @@
+import type { ReactNode } from 'react'
 import { Box } from '@mui/material'
 import type { CategorySize } from '../types'
 import { styles } from '../style'
@@ -5,8 +6,15 @@ import { styles } from '../style'
 export interface CategoryBarProps {
   /** Numeric value driving the fill width. */
   value: number
-  /** Denominator for the percentage fill. `0` → empty bar (no division by zero). */
+  /** Upper end of the domain. `maxValue === minValue` → empty bar (no division by zero). */
   maxValue: number
+  /**
+   * Lower end of the domain. `0` (default) keeps the positive-only bar
+   * anchored at the left edge; a negative value moves the zero to
+   * `-minValue / (maxValue - minValue)` and bars grow from there in either
+   * direction, keeping the fill `color` whatever the sign.
+   */
+  minValue?: number
   /** Fill color. Honors any CSS color or MUI theme token. */
   color: string
   /**
@@ -16,6 +24,11 @@ export interface CategoryBarProps {
    * size-invariant.
    */
   size?: CategorySize
+  /**
+   * Draw the zero tick when the domain is signed. `false` when the parent
+   * draws its own zero line (multi-series rows span it across every bar).
+   */
+  zeroTick?: boolean
 }
 
 /**
@@ -27,23 +40,66 @@ export interface CategoryBarProps {
 export function CategoryBar({
   value,
   maxValue,
+  minValue = 0,
   color,
   size = 'small',
+  zeroTick = true,
 }: CategoryBarProps) {
-  const pct = maxValue > 0 ? (value / maxValue) * 100 : 0
+  const range = maxValue - minValue
+  const leftPct =
+    range > 0 ? ((Math.min(0, value) - minValue) / range) * 100 : 0
+  const pct = range > 0 ? (Math.abs(value) / range) * 100 : 0
+  const hasZeroTick = zeroTick && minValue < 0 && maxValue > 0
   // Width + color rendered as inline `style` (not `sx`) to avoid
   // generating a new emotion class for every distinct value/color pair
   // — also makes the rendered DOM testable without computed-style math.
   return (
-    <Box sx={styles.bar[size]} data-size={size}>
+    <ZeroTickWrap zeroPct={hasZeroTick ? (-minValue / range) * 100 : undefined}>
+      <Box sx={styles.bar[size]} data-size={size}>
+        <Box
+          sx={styles.barFill[size]}
+          style={{
+            left: `${leftPct}%`,
+            width: `${pct}%`,
+            backgroundColor: color,
+            // The end that grows out of the zero is square; only the far
+            // end keeps the rounded corners.
+            ...(value < 0
+              ? { borderTopRightRadius: 0, borderBottomRightRadius: 0 }
+              : { borderTopLeftRadius: 0, borderBottomLeftRadius: 0 }),
+          }}
+          // Tag the fill so an ancestor row's `:hover` selector can target
+          // it (`&:hover [data-bar-fill]`) — the brightening affordance now
+          // fires from anywhere in the row, not only the bar track.
+          data-bar-fill='true'
+        />
+      </Box>
+    </ZeroTickWrap>
+  )
+}
+
+/**
+ * Wraps a bar track and, when `zeroPct` is set, marks the zero with a tick
+ * that overhangs the track. Positive-only, negative-only and all-zero bars
+ * pass `undefined` and get no tick.
+ */
+export function ZeroTickWrap({
+  zeroPct,
+  children,
+}: {
+  zeroPct: number | undefined
+  children: ReactNode
+}) {
+  if (zeroPct === undefined) return children
+  return (
+    <Box sx={styles.barWrap}>
       <Box
-        sx={styles.barFill[size]}
-        style={{ width: `${pct}%`, backgroundColor: color }}
-        // Tag the fill so an ancestor row's `:hover` selector can target
-        // it (`&:hover [data-bar-fill]`) — the brightening affordance now
-        // fires from anywhere in the row, not only the bar track.
-        data-bar-fill='true'
+        aria-hidden
+        data-zero-tick='true'
+        sx={styles.zeroTick}
+        style={{ left: `${zeroPct}%` }}
       />
+      {children}
     </Box>
   )
 }

package/src/widgets-v2/category/components/category-row-multi.tsx

@@ -15,6 +15,8 @@ export interface CategoryRowMultiProps {
   colors: readonly string[]
   /** Shared max across all series + rows (or `maxOverride`). */
   maxValue: number
+  /** Lower end of the shared domain (`0` for positive-only data). */
+  minValue?: number
   formatter: (n: number) => string
   selected: boolean
   onToggle: (name: CategoryKey) => void
@@ -40,11 +42,13 @@ export function CategoryRowMulti({
   values,
   colors,
   maxValue,
+  minValue,
   formatter,
   selected,
   onToggle,
   size,
 }: CategoryRowMultiProps) {
+  const min = minValue ?? 0
   const handleKey = (e: KeyboardEvent<HTMLDivElement>): void => {
     if (e.key === 'Enter' || e.key === ' ') {
       e.preventDefault()
@@ -63,6 +67,21 @@ export function CategoryRowMulti({
       <Typography variant='body2' sx={styles.multiName}>
         {displayName ?? name}
       </Typography>
+      {min < 0 && maxValue > 0 && (
+        <Box
+          aria-hidden
+          sx={styles.multiZeroArea}
+          // Row 1 is the label; the bars fill the next `values.length` rows.
+          // Placed before the bars so their tracks paint over the line.
+          style={{ gridRow: `2 / span ${values.length}` }}
+        >
+          <Box
+            data-zero-tick='true'
+            sx={styles.zeroTick}
+            style={{ left: `${(-min / (maxValue - min)) * 100}%` }}
+          />
+        </Box>
+      )}
       {values.map((v, i) => (
         // Multi-bar rows iterate per series — the bar belongs to series `i`,
         // and the row is keyed on the parent's `name`, so a composite of
@@ -72,8 +91,10 @@ export function CategoryRowMulti({
             <CategoryBar
               value={v}
               maxValue={maxValue}
+              minValue={minValue}
               color={colors[i] ?? ''}
               size={size}
+              zeroTick={false}
             />
           </Box>
           <Typography variant='body2' sx={styles.value}>

package/src/widgets-v2/category/components/category-row-single.tsx

@@ -11,6 +11,8 @@ export interface CategoryRowSingleProps {
   displayName?: string | number
   value: number
   maxValue: number
+  /** Lower end of the shared domain (`0` for positive-only data). */
+  minValue?: number
   color: string
   formatter: (n: number) => string
   selected: boolean
@@ -36,6 +38,7 @@ export function CategoryRowSingle({
   displayName,
   value,
   maxValue,
+  minValue,
   color,
   formatter,
   selected,
@@ -68,6 +71,7 @@ export function CategoryRowSingle({
       <CategoryBar
         value={value}
         maxValue={maxValue}
+        minValue={minValue}
         color={color}
         size={size}
       />

package/src/widgets-v2/category/components/category-row-stacked.tsx

@@ -25,6 +25,11 @@ export interface CategoryRowStackedProps {
   onToggle: (name: CategoryKey) => void
   /** Bar visual density. Forwarded to the inner {@link CategoryBarStacked}. */
   size?: CategorySize
+  /**
+   * Where the list's zero sits (% of the track), shared by every row so the
+   * zero lines up: `0` positive-only, `50` signed, `100` negative-only.
+   */
+  zeroPct?: number
 }
 
 /**
@@ -40,6 +45,10 @@ export interface CategoryRowStackedProps {
  * total relative to other rows. The total numeric value is still shown in
  * the header so the per-row magnitude isn't lost.
  *
+ * Signed data diverges from `zeroPct`: positives stack rightwards and
+ * negatives leftwards, and whichever side is longer reaches its edge of the
+ * track. The header total is the signed sum.
+ *
  * Visual selection / dim signal lives entirely in the segment colors
  * (`colors` prop) — every series in a dimmed row receives
  * `theme.palette.action.disabled`. The bar visually collapses to a single
@@ -56,6 +65,7 @@ export function CategoryRowStacked({
   selected,
   onToggle,
   size,
+  zeroPct = 0,
 }: CategoryRowStackedProps) {
   const handleKey = (e: KeyboardEvent<HTMLDivElement>): void => {
     if (e.key === 'Enter' || e.key === ' ') {
@@ -64,6 +74,18 @@ export function CategoryRowStacked({
     }
   }
   const total = values.reduce((a, b) => a + b, 0)
+  let pos = 0
+  let neg = 0
+  for (const v of values) {
+    if (v > 0) pos += v
+    else neg -= v
+  }
+  // Magnitude that would fill the whole track, picked so the longer side
+  // just reaches its edge: `pos` spans `100 - zeroPct`, `neg` spans `zeroPct`.
+  const scale = Math.max(
+    zeroPct < 100 ? (pos * 100) / (100 - zeroPct) : 0,
+    zeroPct > 0 ? (neg * 100) / zeroPct : 0,
+  )
   return (
     <Box
       role='button'
@@ -84,7 +106,8 @@ export function CategoryRowStacked({
       <CategoryBarStacked
         values={values}
         colors={colors}
-        maxValue={total}
+        maxValue={scale}
+        zeroPct={zeroPct}
         size={size}
       />
       <Box sx={styles.stackedBreakdown}>