@carto/ps-react-ui 4.17.2 → 4.18.0

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

@@ -0,0 +1,26 @@
+/**
+ * `LockSelection` filter for Table. Data is a FLAT `TableRow[]` (unlike every
+ * other widget's `X[][]` series shape) and row identity comes from
+ * `row[keyColumn]` (default `'id'`), not `name` — so `filterByLockedItems`
+ * doesn't apply here (its outer `.map` treats each row as a "series", and a
+ * plain row object isn't an array, so it would silently pass everything
+ * through unfiltered). Falls back to the row's index when the identity
+ * column is nullish, mirroring `TableUI`'s own `resolveRowId`.
+ *
+ * `keyColumn` isn't part of `LockSelection`'s generic `filterFn` signature —
+ * close over it: `filterFn={(data, locked) => filterTableByLockedRows(data, locked, keyColumn)}`.
+ */
+export function filterTableByLockedRows(
+  input: unknown,
+  lockedItems: readonly (string | number)[],
+  keyColumn = 'id',
+): unknown {
+  if (lockedItems.length === 0) return input
+  if (!Array.isArray(input)) return input
+  const locked = new Set<string | number>(lockedItems)
+  return input.filter((row: unknown, index: number): boolean => {
+    if (row == null || typeof row !== 'object') return false
+    const id = (row as Record<string, unknown>)[keyColumn] ?? index
+    return (typeof id === 'string' || typeof id === 'number') && locked.has(id)
+  })
+}

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

@@ -1,6 +1,7 @@
 export { timeseriesOptions, createTimeseriesOptionFactory } from './options'
 export { TimeseriesSkeleton } from './skeleton'
 export { createTimeseriesDownloadConfig } from './download'
+export { filterTimeseriesByLockedItems } from './transforms'
 export type {
   TimeseriesDatum,
   TimeseriesWidgetData,

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

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest'
+import { filterTimeseriesByLockedItems } from './transforms'
+
+describe('filterTimeseriesByLockedItems', () => {
+  it('returns input unchanged when locked set is empty', () => {
+    const data = [[{ name: 1000, value: 10 }]]
+    expect(filterTimeseriesByLockedItems(data, [])).toBe(data)
+  })
+
+  it('keeps only items whose (numeric) name is in the locked set', () => {
+    const out = filterTimeseriesByLockedItems(
+      [
+        [
+          { name: 1000, value: 10 },
+          { name: 2000, value: 20 },
+        ],
+      ],
+      [2000],
+    )
+    expect(out).toEqual([[{ name: 2000, value: 20 }]])
+  })
+
+  it('normalizes Date names to ms-since-epoch before comparing', () => {
+    const d1 = new Date('2024-01-01T00:00:00.000Z')
+    const d2 = new Date('2024-01-02T00:00:00.000Z')
+    const out = filterTimeseriesByLockedItems(
+      [
+        [
+          { name: d1, value: 10 },
+          { name: d2, value: 20 },
+        ],
+      ],
+      [d2.getTime()],
+    )
+    expect(out).toEqual([[{ name: d2, value: 20 }]])
+  })
+
+  it('handles string names', () => {
+    const out = filterTimeseriesByLockedItems(
+      [[{ name: '2024-01-01', value: 10 }]],
+      ['2024-01-01'],
+    )
+    expect(out).toEqual([[{ name: '2024-01-01', value: 10 }]])
+  })
+
+  it('returns input unchanged when input is not array-shaped', () => {
+    expect(filterTimeseriesByLockedItems('nope', [1])).toBe('nope')
+  })
+})

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

@@ -0,0 +1,31 @@
+/**
+ * `LockSelection` filter for Timeseries. Data is `{name, value}[][]` like
+ * Bar/Pie/Category, but `name` may arrive as `Date | number | string` (the
+ * time axis stores a `Date`). `lockedItems` is snapshotted from `selection`,
+ * whose keys are already normalized to `Date → ms` (see `options.ts`'s
+ * `normalizeName`) — so a raw `Date` name must be normalized the same way
+ * before the membership check, or every point would compare a `Date` object
+ * against a `number` and silently fail to match, filtering everything out.
+ */
+export function filterTimeseriesByLockedItems(
+  input: unknown,
+  lockedItems: readonly (string | number)[],
+): unknown {
+  if (lockedItems.length === 0) return input
+  if (!Array.isArray(input)) return input
+  const locked = new Set<string | number>(lockedItems)
+  return input.map((series: unknown): unknown => {
+    if (!Array.isArray(series)) return series
+    return series.filter((item: unknown) => {
+      if (item == null || typeof item !== 'object' || !('name' in item)) {
+        return false
+      }
+      const raw = (item as { name: unknown }).name
+      const name = raw instanceof Date ? raw.getTime() : raw
+      return (
+        (typeof name === 'string' || typeof name === 'number') &&
+        locked.has(name)
+      )
+    })
+  })
+}