@carto/ps-react-ui 4.24.0 → 4.26.0

package/src/widgets-v2/scatterplot/download.test.ts

@@ -61,6 +61,15 @@ describe('createScatterplotDownloadConfig', () => {
     )
   })
 
+  it('CSV writes x/y of object points (colour is not exported)', async () => {
+    const items = createScatterplotDownloadConfig({
+      filename: 's',
+      getData: () => [[{ x: 1, y: 10, color: '#f00' }, [2, 20]]],
+    })
+    await items.find((i) => i.id === 'csv')!.resolve({ id: null })
+    expect(csvText).toBe('series,x,y\nseries_1,1,10\nseries_1,2,20')
+  })
+
   it('CSV honours supplied seriesNames', async () => {
     const items = createScatterplotDownloadConfig({
       filename: 's',

package/src/widgets-v2/scatterplot/download.ts

@@ -4,7 +4,8 @@ import {
   type DownloadContext,
   type DownloadItem,
 } from '../actions/download'
-import type { ScatterplotWidgetData } from './types'
+import { getScatterplotXY } from './points'
+import type { ScatterplotItem, ScatterplotWidgetData } from './types'
 
 /**
  * Download menu items for the Scatterplot widget. Always includes a CSV
@@ -14,7 +15,7 @@ import type { ScatterplotWidgetData } from './types'
  */
 export function createScatterplotDownloadConfig(args: {
   filename: string
-  getData: (ctx: DownloadContext) => ScatterplotWidgetData
+  getData: (ctx: DownloadContext) => ScatterplotWidgetData<ScatterplotItem>
   seriesNames?: readonly string[]
   getCaptureEl?: (ctx: DownloadContext) => HTMLElement | null
   pngPixelRatio?: number
@@ -39,7 +40,8 @@ export function createScatterplotDownloadConfig(args: {
         const rows: unknown[][] = [['series', 'x', 'y']]
         for (const [i, series] of data.entries()) {
           const seriesName = args.seriesNames?.[i] ?? `series_${i + 1}`
-          for (const [x, y] of series) {
+          for (const point of series) {
+            const [x, y] = getScatterplotXY(point)
             rows.push([seriesName, x, y])
           }
         }

package/src/widgets-v2/scatterplot/index.ts

@@ -5,8 +5,11 @@ export {
   toRelativeScatterplotData,
   filterScatterplotByLockedPoints,
 } from './transforms'
+export { getScatterplotXY } from './points'
 export type {
   ScatterplotDatum,
+  ScatterplotPoint,
+  ScatterplotItem,
   ScatterplotWidgetData,
   ScatterplotOptionsInput,
   ScatterplotOptionFactoryInput,

package/src/widgets-v2/scatterplot/options.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect } from 'vitest'
+import * as echarts from 'echarts'
 import { createTheme, type Theme } from '@mui/material'
 import { createScatterplotOptionFactory, scatterplotOptions } from './options'
 
@@ -409,3 +410,80 @@ describe('createScatterplotOptionFactory', () => {
     expect(insideOnly.grid.right).toBe(baseline.grid.right)
   })
 })
+
+describe('createScatterplotOptionFactory — per-item colour', () => {
+  interface Out {
+    dataset: { source: number[][] }[]
+    series: { itemStyle: { color: (p: unknown) => string } }[]
+    xAxis: { min: number; max: number }
+    yAxis: { min: number; max: number }
+  }
+  const dim = (c: string) => echarts.color.modifyAlpha(c, 0.15)
+  const data = [
+    [{ x: 1, y: 2, color: '#00ff00' }, [3, 4] as const, { x: -5, y: 60 }],
+  ]
+
+  it('flattens object points to [x, y] rows and bounds them', () => {
+    const merge = createScatterplotOptionFactory({ theme })
+    const out = merge({}, data) as Out
+    expect(out.dataset[0]!.source).toEqual([
+      [1, 2],
+      [3, 4],
+      [-5, 60],
+    ])
+    expect(out.xAxis.min).toBeLessThanOrEqual(-5)
+    expect(out.xAxis.max).toBeGreaterThanOrEqual(3)
+    expect(out.yAxis.max).toBeGreaterThanOrEqual(60)
+  })
+
+  it('keeps tuple-only series as the dataset source', () => {
+    const merge = createScatterplotOptionFactory({ theme })
+    const series = [[1, 2] as const, [3, 4] as const]
+    const out = merge({}, [series]) as Out
+    expect(out.dataset[0]!.source).toBe(series)
+  })
+
+  it('point colour wins over the series colour; template next; dims', () => {
+    const merge = createScatterplotOptionFactory({
+      theme,
+      series: [{ name: 'S', color: '#0000ff' }],
+      selection: ['0:0', '0:1'],
+    })
+    const out = merge(
+      { series: [{ type: 'scatter', itemStyle: { color: '#123456' } }] },
+      data,
+    ) as Out
+    const colorFn = out.series[0]!.itemStyle.color
+    expect(colorFn({ dataIndex: 0, color: '#0000ff' })).toBe('#00ff00')
+    expect(colorFn({ dataIndex: 1, color: '#0000ff' })).toBe('#123456')
+    expect(colorFn({ dataIndex: 2, color: '#0000ff' })).toBe(dim('#123456'))
+  })
+
+  it('calls a function template itemStyle.color via optionsOverride', () => {
+    const factory = createScatterplotOptionFactory({
+      theme,
+      optionsOverride: {
+        series: [
+          {
+            type: 'scatter',
+            itemStyle: {
+              color: (p: { dataIndex: number }) => `#c${p.dataIndex}`,
+            },
+          },
+        ],
+      },
+    })
+    const out = factory(factory(undefined, undefined), [[[1, 2]]]) as Out
+    expect(out.series[0]!.itemStyle.color({ dataIndex: 0, color: '#x' })).toBe(
+      '#c0',
+    )
+  })
+
+  it('keeps the series / palette colour for plain tuples', () => {
+    const merge = createScatterplotOptionFactory({ theme })
+    const out = merge({}, [[[1, 2]]]) as Out
+    expect(
+      out.series[0]!.itemStyle.color({ dataIndex: 0, color: '#abc' }),
+    ).toBe('#abc')
+  })
+})

package/src/widgets-v2/scatterplot/options.ts

@@ -12,10 +12,13 @@ import {
 import { ZOOM_LAYOUT } from '../actions/zoom-toggle'
 import type { OptionFactory } from '../echart'
 import { mergeOptions, resolveThemeColor } from '../utils'
+import { createItemColorResolver } from '../utils/item-color'
+import { getScatterplotXY } from './points'
 import type {
   ScatterplotEChartsOption,
   ScatterplotOptionFactoryInput,
   ScatterplotOptionsInput,
+  ScatterplotItem,
   ScatterplotWidgetData,
 } from './types'
 
@@ -156,7 +159,9 @@ export function createScatterplotOptionFactory(
         : structural
     }
 
-    const seriesArr = Array.isArray(data) ? (data as ScatterplotWidgetData) : []
+    const seriesArr = Array.isArray(data)
+      ? (data as ScatterplotWidgetData<ScatterplotItem>)
+      : []
     if (seriesArr.length === 0) {
       return { ...option, dataset: [], series: [] }
     }
@@ -198,15 +203,26 @@ export function createScatterplotOptionFactory(
     // Keeping the key always-present means a plain setOption merge swaps
     // the callback in place, no `replaceMerge` and no entry-animation
     // flash on selection on/off.
-    const makeDimColor =
-      (seriesIdx: number) => (params: CallbackDataParams) => {
-        const base = params.color as string
+    //
+    // The base colour is the point's own `color` (object points), else the
+    // template's `itemStyle.color`, else the series colour / palette.
+    const seriesTemplates = Array.isArray(option.series) ? option.series : []
+    const makeDimColor = (seriesIdx: number, datums: readonly unknown[]) => {
+      const baseColor = createItemColorResolver({
+        theme,
+        datums,
+        template: seriesTemplates[seriesIdx] ?? seriesTemplates[0],
+        fallback: (params) => params.color as string,
+      })
+      return (params: CallbackDataParams) => {
+        const base = baseColor(params)
         if (!selectionSet) return base
         const key = `${seriesIdx}:${params.dataIndex}`
         return selectionSet.has(key)
           ? base
           : echarts.color.modifyAlpha(base, 0.15)
       }
+    }
 
     // Zoom slider layout: when ZoomToggle has installed `dataZoom`,
     // reserve grid space and lift any x-slider above the legend (if
@@ -232,9 +248,15 @@ export function createScatterplotOptionFactory(
     return {
       ...option,
       // ECharts dataset.source wants a mutable [number, number][] shape; we
-      // hold readonly tuples internally, so cast at the boundary.
-      dataset: seriesArr.map((s) => ({ source: s as unknown as number[][] })),
-      series: seriesArr.map((_, i) => {
+      // hold readonly tuples internally, so cast at the boundary. Object
+      // points are flattened to `[x, y]` so the positional encode and the
+      // tooltip keep reading tuples.
+      dataset: seriesArr.map((s) => ({
+        source: (s.every(Array.isArray)
+          ? s
+          : s.map(getScatterplotXY)) as unknown as number[][],
+      })),
+      series: seriesArr.map((s, i) => {
         const overrideColor = resolveThemeColor(theme, series?.[i]?.color)
         return {
           type: 'scatter' as const,
@@ -243,7 +265,7 @@ export function createScatterplotOptionFactory(
           encode: { x: 0, y: 1 },
           symbolSize,
           emphasis: { focus: 'series' },
-          itemStyle: { color: makeDimColor(i) },
+          itemStyle: { color: makeDimColor(i, s) },
           ...(overrideColor ? { color: overrideColor } : {}),
         }
       }),
@@ -386,7 +408,9 @@ function buildScatterTooltipFormatter(
   })
 }
 
-function computeScatterBounds(seriesArr: ScatterplotWidgetData): {
+function computeScatterBounds(
+  seriesArr: ScatterplotWidgetData<ScatterplotItem>,
+): {
   niceMinX: number
   niceMaxX: number
   niceMinY: number
@@ -398,8 +422,8 @@ function computeScatterBounds(seriesArr: ScatterplotWidgetData): {
   let maxY = -Infinity
   for (const series of seriesArr) {
     for (const point of series) {
-      const x = point?.[0]
-      const y = point?.[1]
+      if (point == null) continue
+      const [x, y] = getScatterplotXY(point)
       if (typeof x === 'number' && Number.isFinite(x)) {
         if (x < minX) minX = x
         if (x > maxX) maxX = x

package/src/widgets-v2/scatterplot/points.ts

@@ -0,0 +1,35 @@
+import type { ScatterplotItem } from './types'
+
+/** `[x, y]` of a {@link ScatterplotItem}, whichever form it takes. */
+export function getScatterplotXY(
+  point: ScatterplotItem,
+): readonly [number, number] {
+  return isTuple(point) ? point : [point.x, point.y]
+}
+
+/** Whether `v` is a valid {@link ScatterplotItem} with finite coordinates. */
+export function isScatterplotDatum(v: unknown): v is ScatterplotItem {
+  if (Array.isArray(v)) {
+    return v.length === 2 && isFiniteNumber(v[0]) && isFiniteNumber(v[1])
+  }
+  if (v == null || typeof v !== 'object') return false
+  const { x, y } = v as { x?: unknown; y?: unknown }
+  return isFiniteNumber(x) && isFiniteNumber(y)
+}
+
+/** Same point with new coordinates; keeps the object form (and `color`). */
+export function withScatterplotXY(
+  point: ScatterplotItem,
+  x: number,
+  y: number,
+): ScatterplotItem {
+  return isTuple(point) ? [x, y] : { ...point, x, y }
+}
+
+function isTuple(point: ScatterplotItem): point is readonly [number, number] {
+  return Array.isArray(point)
+}
+
+function isFiniteNumber(v: unknown): v is number {
+  return typeof v === 'number' && Number.isFinite(v)
+}

package/src/widgets-v2/scatterplot/transforms.test.ts

@@ -99,6 +99,25 @@ describe('toRelativeScatterplotData', () => {
   })
 })
 
+describe('toRelativeScatterplotData (object points)', () => {
+  it('relativizes y of object points, keeping x and colour', () => {
+    expect(
+      toRelativeScatterplotData([[{ x: 1, y: 5, color: '#f00' }, [2, 15]]]),
+    ).toEqual([[{ x: 1, y: 25, color: '#f00' }, [2, 75]]])
+  })
+})
+
+describe('filterScatterplotByLockedPoints (object points)', () => {
+  it('keeps locked object points as they are', () => {
+    expect(
+      filterScatterplotByLockedPoints(
+        [[{ x: 1, y: 2, color: '#f00' }, { x: 3, y: 4 }, [5, 6]]],
+        ['0:0', '0:2'],
+      ),
+    ).toEqual([[{ x: 1, y: 2, color: '#f00' }, [5, 6]]])
+  })
+})
+
 describe('filterScatterplotByLockedPoints', () => {
   const DATA = [
     [

package/src/widgets-v2/scatterplot/transforms.ts

@@ -1,6 +1,14 @@
+import {
+  getScatterplotXY,
+  isScatterplotDatum,
+  withScatterplotXY,
+} from './points'
+import type { ScatterplotItem } from './types'
+
 /**
  * Scatterplot-specific `RelativeData` transform. Scatter data is
- * `[number, number][]` — each series is a list of `[x, y]` tuples.
+ * `ScatterplotItem[][]` — each series is a list of `[x, y]` tuples or
+ * `{ x, y, color? }` points (whose shape is kept).
  * Relative is a values-axis concept, so this rewrites `y` to its
  * share of the series's total `y` (0–100) and leaves `x` raw — x is
  * coordinate space, not part of the cohort total.
@@ -11,34 +19,31 @@
  * y values produce sane signed shares-of-magnitude. A series whose
  * total y-magnitude is zero (all-zero or empty input) is returned
  * unchanged so a stalled or empty data set doesn't show misleading 0%
- * values. Inputs whose shape isn't `[number, number][]` fall through
+ * values. Inputs whose shape isn't `ScatterplotItem[]` fall through
  * untouched.
  */
 export const toRelativeScatterplotData = (input: unknown): unknown => {
   if (!Array.isArray(input)) return input
   return input.map((series: unknown): unknown => {
-    if (!isXyTupleArray(series)) return series
-    const total = series.reduce((acc, [, y]) => acc + Math.abs(y), 0)
+    if (!isPointArray(series)) return series
+    const total = series.reduce(
+      (acc, p) => acc + Math.abs(getScatterplotXY(p)[1]),
+      0,
+    )
     if (total <= 0) return series
-    return series.map(([x, y]) => [x, (y / total) * 100] as [number, number])
+    return series.map((p) => {
+      const [x, y] = getScatterplotXY(p)
+      return withScatterplotXY(p, x, (y / total) * 100)
+    })
   })
 }
 
-function isXyTupleArray(v: unknown): v is [number, number][] {
-  if (!Array.isArray(v)) return false
-  return v.every(
-    (item) =>
-      Array.isArray(item) &&
-      item.length === 2 &&
-      typeof item[0] === 'number' &&
-      Number.isFinite(item[0]) &&
-      typeof item[1] === 'number' &&
-      Number.isFinite(item[1]),
-  )
+function isPointArray(v: unknown): v is ScatterplotItem[] {
+  return Array.isArray(v) && v.every(isScatterplotDatum)
 }
 
 /**
- * `LockSelection` filter for Scatterplot. Data is `[number, number][][]` —
+ * `LockSelection` filter for Scatterplot. Data is `ScatterplotItem[][]` —
  * points have no `name`, so selection (and locking) is keyed on a synthetic
  * `${seriesIndex}:${dataIndex}` string (same format `useChartSelection`'s
  * `keyFromClick`/`keysFromBrush` produce for this widget). Unlike Histogram,
@@ -53,7 +58,7 @@ export function filterScatterplotByLockedPoints(
   if (!Array.isArray(input)) return input
   const locked = new Set<string>(lockedItems.map(String))
   return input.map((series: unknown, seriesIndex: number): unknown => {
-    if (!isXyTupleArray(series)) return series
+    if (!isPointArray(series)) return series
     return series.filter((_, dataIndex) =>
       locked.has(`${seriesIndex}:${dataIndex}`),
     )

package/src/widgets-v2/scatterplot/types.ts

@@ -5,8 +5,31 @@ import type { WidgetSeries } from '../types'
 /** A single point — `[x, y]` tuple. */
 export type ScatterplotDatum = readonly [number, number]
 
-/** Scatterplot widget data — array of series, each a list of `[x, y]` tuples. */
-export type ScatterplotWidgetData = readonly (readonly ScatterplotDatum[])[]
+/**
+ * Object form of a point, to give it its own colour. `color` (CSS colour or
+ * theme palette path such as `'primary.main'`) wins over the template's
+ * `itemStyle.color` and the series colour; selection dimming still applies.
+ */
+export interface ScatterplotPoint {
+  x: number
+  y: number
+  color?: string
+}
+
+/** Any accepted point: an `[x, y]` tuple or a {@link ScatterplotPoint}. */
+export type ScatterplotItem = ScatterplotDatum | ScatterplotPoint
+
+/**
+ * Scatterplot widget data — array of series, each a list of points.
+ *
+ * Defaults to `[x, y]` tuples so existing code that destructures points
+ * keeps type-checking; use `ScatterplotWidgetData<ScatterplotItem>` to also
+ * accept `{ x, y, color? }` points. Every scatterplot API (option factory,
+ * transforms, download) accepts both forms.
+ */
+export type ScatterplotWidgetData<
+  P extends ScatterplotItem = ScatterplotDatum,
+> = readonly (readonly P[])[]
 
 /** Inputs to the structural-only {@link scatterplotOptions} builder. */
 export interface ScatterplotOptionsInput {

package/src/widgets-v2/timeseries/options.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect } from 'vitest'
+import * as echarts from 'echarts'
 import { createTheme, type Theme } from '@mui/material'
 import { createTimeseriesOptionFactory, timeseriesOptions } from './options'
 
@@ -397,3 +398,67 @@ describe('createTimeseriesOptionFactory', () => {
     expect(out.grid.bottom).toBe(96)
   })
 })
+
+describe('createTimeseriesOptionFactory — per-item colour', () => {
+  interface Out {
+    series: {
+      showSymbol: boolean
+      itemStyle: { color: (p: unknown) => string }
+    }[]
+  }
+  const data = [
+    [
+      { name: 1, value: 1, color: '#00ff00' },
+      { name: 2, value: 2 },
+    ],
+  ]
+  const p = (dataIndex: number, name: number) => ({
+    dataIndex,
+    color: '#0000ff',
+    value: { name },
+  })
+  const dim = (c: string) => echarts.color.modifyAlpha(c, 0.15)
+
+  it('datum colour wins over the series colour; template next', () => {
+    const merge = createTimeseriesOptionFactory({
+      theme,
+      series: [{ name: 'S', color: '#0000ff' }],
+    })
+    const out = merge(
+      { series: [{ type: 'line', itemStyle: { color: '#123456' } }] },
+      data,
+    ) as Out
+    const colorFn = out.series[0]!.itemStyle.color
+    expect(colorFn(p(0, 1))).toBe('#00ff00')
+    expect(colorFn(p(1, 2))).toBe('#123456')
+  })
+
+  it('calls a function template itemStyle.color', () => {
+    const factory = createTimeseriesOptionFactory({
+      theme,
+      optionsOverride: {
+        series: [{ type: 'line', itemStyle: { color: () => '#ff0000' } }],
+      },
+    })
+    const out = factory(factory(undefined, undefined), [
+      [{ name: 1, value: 1 }],
+    ]) as Out
+    expect(out.series[0]!.itemStyle.color(p(0, 1))).toBe('#ff0000')
+  })
+
+  it('dims item colours outside the selection', () => {
+    const merge = createTimeseriesOptionFactory({ theme, selection: [2] })
+    const out = merge({}, data) as Out
+    const colorFn = out.series[0]!.itemStyle.color
+    expect(colorFn(p(0, 1))).toBe(dim('#00ff00'))
+    expect(colorFn(p(1, 2))).toBe('#0000ff')
+  })
+
+  it('shows symbols when a point has its own colour, not otherwise', () => {
+    const merge = createTimeseriesOptionFactory({ theme })
+    expect((merge({}, data) as Out).series[0]!.showSymbol).toBe(true)
+    const plain = merge({}, [[{ name: 1, value: 1 }]]) as Out
+    expect(plain.series[0]!.showSymbol).toBe(false)
+    expect(plain.series[0]!.itemStyle.color(p(0, 1))).toBe('#0000ff')
+  })
+})

package/src/widgets-v2/timeseries/options.ts

@@ -12,6 +12,7 @@ import {
 import { ZOOM_LAYOUT } from '../actions/zoom-toggle'
 import type { OptionFactory } from '../echart'
 import { mergeOptions, resolveThemeColor } from '../utils'
+import { createItemColorResolver } from '../utils/item-color'
 import { positionDataZoomForLegend } from '../utils/data-zoom-layout'
 import type {
   TimeseriesEChartsOption,
@@ -237,24 +238,39 @@ export function createTimeseriesOptionFactory(
     // and points would stay dimmed forever after an external clear.
     // Always emitting lets normal merge swap the callback in place, no
     // `replaceMerge` and no entry-animation flash on selection on/off.
-    const dimItemStyle = {
-      color: (params: CallbackDataParams) => {
-        const datum = params.value as
-          | { name?: Date | number | string }
-          | undefined
-        const raw = datum?.name
-        const base = params.color as string
-        if (!selectionSet || raw == null) return base
-        return selectionSet.has(normalizeName(raw))
-          ? base
-          : echarts.color.modifyAlpha(base, 0.15)
-      },
+    //
+    // The base colour is the point's own `color`, else the template's
+    // `itemStyle.color`, else the series colour / palette (`params.color`).
+    const makeDimItemStyle = (datums: readonly object[], template: unknown) => {
+      const baseColor = createItemColorResolver({
+        theme,
+        datums,
+        template,
+        fallback: (params) => params.color as string,
+      })
+      return {
+        color: (params: CallbackDataParams) => {
+          const datum = params.value as
+            { name?: Date | number | string } | undefined
+          const raw = datum?.name
+          const base = baseColor(params)
+          if (!selectionSet || raw == null) return base
+          return selectionSet.has(normalizeName(raw))
+            ? base
+            : echarts.color.modifyAlpha(base, 0.15)
+        },
+      }
     }
+    // Per-point colours only show on markers, so surface them whenever a
+    // point carries its own `color` (same reason as the selection case).
+    const hasDatumColor = seriesArr.some((s) =>
+      s.some((d) => typeof d?.color === 'string' && d.color !== ''),
+    )
 
     return {
       ...option,
       dataset: seriesArr.map((s) => ({ source: s as readonly object[] })),
-      series: seriesArr.map((_, i) => {
+      series: seriesArr.map((s, i) => {
         const template =
           (seriesTemplates[i] as object | undefined) ??
           (broadcastTemplate as object)
@@ -272,10 +288,10 @@ export function createTimeseriesOptionFactory(
           // When a selection is active, surface markers so the per-point
           // color callback has something to dim — a continuous line would
           // hide the visual selection feedback.
-          showSymbol: selectionSet != null,
+          showSymbol: selectionSet != null || hasDatumColor,
           ...(area ? { areaStyle: {} } : {}),
           emphasis: { focus: 'series' },
-          itemStyle: dimItemStyle,
+          itemStyle: makeDimItemStyle(s, template),
           ...(overrideColor
             ? { color: overrideColor, lineStyle: { color: overrideColor } }
             : {}),
@@ -327,8 +343,7 @@ function buildTimeseriesTooltipFormatter(
 ) {
   return createTooltipFormatter((item) => {
     const row = item.value as
-      | { name?: Date | number | string; value?: number }
-      | undefined
+      { name?: Date | number | string; value?: number } | undefined
     const raw = row?.value
     const formattedValue =
       typeof raw === 'number' && formatter ? formatter(raw) : (raw ?? '')

package/src/widgets-v2/timeseries/types.ts

@@ -10,6 +10,12 @@ import type { WidgetSeries } from '../types'
 export interface TimeseriesDatum {
   name: Date | number | string
   value: number
+  /**
+   * Optional colour for this item (CSS colour or theme palette path such as
+   * `'primary.main'`). Wins over the template's `itemStyle.color` and the
+   * series colour; selection dimming still applies on top.
+   */
+  color?: string
 }
 
 /** Timeseries widget data — one array of points per series. */

package/src/widgets-v2/utils/item-color.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi } from 'vitest'
+import { createTheme } from '@mui/material'
+import type { CallbackDataParams } from 'echarts/types/dist/shared'
+import { createItemColorResolver } from './item-color'
+
+const theme = createTheme({ palette: { primary: { main: '#1976d2' } } })
+const params = (dataIndex: number) =>
+  ({ dataIndex, color: '#fallback' }) as unknown as CallbackDataParams
+const fallback = (p: CallbackDataParams) => p.color as string
+
+describe('createItemColorResolver', () => {
+  it('uses the datum colour first', () => {
+    const resolve = createItemColorResolver({
+      theme,
+      datums: [{ color: '#00ff00' }],
+      template: { itemStyle: { color: '#123456' } },
+      fallback,
+    })
+    expect(resolve(params(0))).toBe('#00ff00')
+  })
+
+  it('uses a string template itemStyle.color when the datum has none', () => {
+    const resolve = createItemColorResolver({
+      theme,
+      datums: [{}, 3],
+      template: { itemStyle: { color: '#123456' } },
+      fallback,
+    })
+    expect(resolve(params(0))).toBe('#123456')
+    expect(resolve(params(1))).toBe('#123456')
+  })
+
+  it('calls a function template itemStyle.color with the ECharts params', () => {
+    const color = vi.fn(() => '#abcdef')
+    const resolve = createItemColorResolver({
+      theme,
+      datums: [{}],
+      template: { itemStyle: { color } },
+      fallback,
+    })
+    const p = params(0)
+    expect(resolve(p)).toBe('#abcdef')
+    expect(color).toHaveBeenCalledWith(p)
+  })
+
+  it('falls back when neither datum nor template give a colour', () => {
+    const resolve = createItemColorResolver({
+      theme,
+      datums: [{ value: 1 }],
+      template: { itemStyle: { color: () => undefined } },
+      fallback,
+    })
+    expect(resolve(params(0))).toBe('#fallback')
+    expect(resolve(params(5))).toBe('#fallback')
+    const noTemplate = createItemColorResolver({
+      theme,
+      datums: [],
+      template: undefined,
+      fallback,
+    })
+    expect(noTemplate(params(0))).toBe('#fallback')
+  })
+
+  it('resolves theme palette paths on datum and template colours', () => {
+    const resolve = createItemColorResolver({
+      theme,
+      datums: [{ color: 'primary.main' }, {}],
+      template: { itemStyle: { color: () => 'primary.main' } },
+      fallback,
+    })
+    expect(resolve(params(0))).toBe('#1976d2')
+    expect(resolve(params(1))).toBe('#1976d2')
+  })
+})