@carto/ps-react-ui 6.1.1 → 6.3.0

package/src/widgets/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/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,23 +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)
@@ -271,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 } }
             : {}),

package/src/widgets/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/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')
+  })
+})

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

@@ -0,0 +1,55 @@
+import type { Theme } from '@mui/material'
+import type { CallbackDataParams } from 'echarts/types/dist/shared'
+import { resolveThemeColor } from './resolve-theme-color'
+
+/** ECharts `itemStyle.color` callback, as emitted by the chart widgets. */
+export type ItemColorCallback = (params: CallbackDataParams) => string
+
+/**
+ * Builds the callback that resolves the **base** colour of every item of one
+ * series, before any selection dimming. Priority:
+ *
+ *   1. the datum's own `color` (`datums[params.dataIndex].color`);
+ *   2. the consumer's `template.itemStyle.color` (from `optionsOverride`):
+ *      a string is used as is, a function is called with the ECharts params;
+ *   3. `fallback` — the widget's default (series colour / palette).
+ *
+ * The datum is looked up by `params.dataIndex` in the widget's own data
+ * rather than read off `params.data`, so it works whatever the dataset row
+ * shape is (object rows, `[label, count]` tuples, `[x, y]` tuples).
+ *
+ * Datum and template colours go through {@link resolveThemeColor}, same as
+ * per-series colours, so palette paths such as `'primary.main'` work.
+ */
+export function createItemColorResolver({
+  theme,
+  datums,
+  template,
+  fallback,
+}: {
+  theme: Theme
+  datums: readonly unknown[]
+  template: unknown
+  fallback: ItemColorCallback
+}): ItemColorCallback {
+  const templateColor = (template as { itemStyle?: { color?: unknown } })
+    ?.itemStyle?.color
+  return (params) => {
+    const datumColor = readColor(datums[params.dataIndex])
+    if (datumColor) return resolveThemeColor(theme, datumColor)!
+    const custom =
+      typeof templateColor === 'function'
+        ? (templateColor as (p: CallbackDataParams) => unknown)(params)
+        : templateColor
+    if (typeof custom === 'string' && custom !== '') {
+      return resolveThemeColor(theme, custom)!
+    }
+    return fallback(params)
+  }
+}
+
+function readColor(datum: unknown): string | undefined {
+  if (datum == null || typeof datum !== 'object') return undefined
+  const color = (datum as { color?: unknown }).color
+  return typeof color === 'string' && color !== '' ? color : undefined
+}