@carto/ps-react-ui 4.16.0 → 4.17.1

package/dist/types/legend/stores/types.d.ts

@@ -198,6 +198,14 @@ export interface LegendLayer {
 export interface LegendGroup {
     id: string;
     label: string;
+    /**
+     * Optional header icon. Rendered only when provided — no icon shows by
+     * default. A same-type element with shallow-equal props is treated as
+     * unchanged across re-syncs even when re-created inline (e.g.
+     * `icon={<MyIcon />}`); a deeply nested custom node should be memoized if
+     * you want to avoid unnecessary syncs.
+     */
+    icon?: ReactNode;
     collapsed: boolean;
     /**
      * @internal Collapsed state snapshotted when the group was hidden via

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carto/ps-react-ui",
-  "version": "4.16.0",
+  "version": "4.17.1",
   "description": "CARTO's Professional Service React Material library",
   "type": "module",
   "devDependencies": {
@@ -17,8 +17,8 @@
     "react-dom": "19.2.4",
     "react-markdown": "10.1.0",
     "zustand": "5.0.12",
-    "@carto/ps-common-types": "1.0.0",
-    "@carto/ps-utils": "2.1.0"
+    "@carto/ps-utils": "2.1.0",
+    "@carto/ps-common-types": "1.0.0"
   },
   "peerDependencies": {
     "@carto/meridian-ds": "^2.0.0",

package/src/legend/components/legend-group/legend-group.test.tsx

@@ -125,6 +125,31 @@ describe('<LegendGroup> composition', () => {
     fireEvent.click(header)
     expect(getLegendStore('g-hide').getState().groups.g1!.collapsed).toBe(false)
   })
+
+  it('renders no icon when the group has no icon configured', () => {
+    renderGroup('g-icon-none')
+    expect(screen.queryByTestId('LayersOutlinedIcon')).toBeNull()
+    expect(screen.queryByTestId('my-icon')).toBeNull()
+  })
+
+  it('renders the custom icon when provided', () => {
+    render(
+      <LegendProvider
+        id='g-icon-custom'
+        layers={layers}
+        groups={[
+          {
+            id: 'g1',
+            label: 'Demographics',
+            icon: <span data-testid='my-icon' />,
+          },
+        ]}
+      >
+        <LegendGroup groupId='g1' />
+      </LegendProvider>,
+    )
+    expect(screen.getByTestId('my-icon')).toBeTruthy()
+  })
 })
 
 describe('<LegendGroupMenu> + built-in items', () => {

package/src/legend/components/legend-group/legend-group.tsx

@@ -1,9 +1,6 @@
 import type { ReactNode } from 'react'
 import { Box, Collapse, Typography } from '@mui/material'
-import {
-  LayersOutlined as GroupIcon,
-  ExpandMore as ExpandMoreIcon,
-} from '@mui/icons-material'
+import { ExpandMore as ExpandMoreIcon } from '@mui/icons-material'
 import { SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable'
 import { SmartTooltip } from '../../../components/smart-tooltip/smart-tooltip'
 import {
@@ -76,9 +73,9 @@ export function LegendGroup({ groupId, children }: LegendGroupProps) {
             onClick={toggle}
             onKeyDown={accordionKeyDown(toggle)}
           >
-            <Box sx={styles.groupIcon}>
-              <GroupIcon fontSize='small' />
-            </Box>
+            {group.icon != null && (
+              <Box sx={styles.groupIcon}>{group.icon}</Box>
+            )}
 
             <SmartTooltip title={group.label} dependencies={[group.label]}>
               {({ ref }) => (

package/src/legend/components/legend-opacity/styles.ts

@@ -24,7 +24,7 @@ export const styles = {
   },
   // Wide enough for "100 %" — the value must never ellipsize.
   input: {
-    width: 68,
+    width: 72,
     flexShrink: 0,
     '& input': {
       textAlign: 'right',

package/src/legend/components/legend-sortable/legend-sortable.tsx

@@ -14,7 +14,6 @@ import {
 } from '@dnd-kit/core'
 import { SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable'
 import { Box, Typography } from '@mui/material'
-import { LayersOutlined as GroupIcon } from '@mui/icons-material'
 import {
   getLegendStore,
   selectLayersByGroup,
@@ -172,15 +171,16 @@ function OverlayCard({ activeId }: { activeId: string }) {
         : s.layers[parsed.id]?.name
       : undefined,
   )
+  const groupIcon = useLegendStore(id, (s) =>
+    parsed?.kind === 'group' ? s.groups[parsed.id]?.icon : undefined,
+  )
 
   if (!parsed || label === undefined) return null
 
   return (
     <Box sx={styles.overlay}>
-      {parsed.kind === 'group' && (
-        <Box sx={styles.overlayIcon}>
-          <GroupIcon fontSize='small' />
-        </Box>
+      {parsed.kind === 'group' && groupIcon != null && (
+        <Box sx={styles.overlayIcon}>{groupIcon}</Box>
       )}
       <Typography
         variant='button'

package/src/legend/stores/legend-store-registry.ts

@@ -1,3 +1,4 @@
+import { isValidElement } from 'react'
 import { useStore, type StoreApi } from 'zustand'
 import { createStore } from 'zustand/vanilla'
 import { devtools } from 'zustand/middleware'
@@ -161,11 +162,30 @@ function mergeSections(
   return sameAsPrev ? prev : merged
 }
 
-/** Shallow equality over the union of both objects' keys (`Object.is` per value). */
+/**
+ * Same-type, same-key React elements with shallow-equal props count as
+ * equal, so a ReactNode field (e.g. `LegendGroup.icon`) re-created inline on
+ * every render (`icon={<MyIcon />}`) doesn't look "changed" on every sync. A
+ * different `key` is treated as a real change, same as a different type.
+ */
+function reactElementEqual(a: unknown, b: unknown): boolean {
+  if (!isValidElement(a) || !isValidElement(b)) return false
+  if (a.type !== b.type || a.key !== b.key) return false
+  return shallowEqualEntity(
+    a.props as Record<string, unknown>,
+    b.props as Record<string, unknown>,
+  )
+}
+
+/**
+ * Shallow equality over the union of both objects' keys — `Object.is` per
+ * value, except React elements, which fall back to {@link reactElementEqual}.
+ */
 function shallowEqualEntity<T extends object>(a: T, b: T): boolean {
   const keys = new Set([...Object.keys(a), ...Object.keys(b)]) as Set<keyof T>
   for (const key of keys) {
-    if (!Object.is(a[key], b[key])) return false
+    if (Object.is(a[key], b[key])) continue
+    if (!reactElementEqual(a[key], b[key])) return false
   }
   return true
 }

package/src/legend/stores/legend-store.test.ts

@@ -1,3 +1,4 @@
+import { createElement } from 'react'
 import { afterEach, describe, expect, it } from 'vitest'
 import {
   createLegendStore,
@@ -324,6 +325,57 @@ describe('legend store', () => {
     expect(store.getState().groups.g1!.collapsed).toBe(true) // persisted
   })
 
+  it('_sync treats a re-created group icon of the same type/props as unchanged', () => {
+    const store = createLegendStore('s', {
+      layers,
+      groups: [
+        { id: 'g1', label: 'One', icon: createElement('span', null, 'icon') },
+      ],
+    })
+    const before = store.getState().groups
+
+    // New element instance each call (as a consumer re-rendering inline
+    // would produce), but same type and shallow-equal props.
+    store
+      .getState()
+      ._sync(layers, [
+        { id: 'g1', label: 'One', icon: createElement('span', null, 'icon') },
+      ])
+
+    expect(store.getState().groups).toBe(before) // no sync at all
+  })
+
+  it('_sync detects a real icon change (different type/props)', () => {
+    const store = createLegendStore('s', {
+      layers,
+      groups: [
+        { id: 'g1', label: 'One', icon: createElement('span', null, 'icon') },
+      ],
+    })
+
+    const newIcon = createElement('div', null, 'icon')
+    store.getState()._sync(layers, [{ id: 'g1', label: 'One', icon: newIcon }])
+
+    expect(store.getState().groups.g1!.icon).toBe(newIcon)
+  })
+
+  it('_sync detects a same-type/same-props icon with a different key as changed', () => {
+    const store = createLegendStore('s', {
+      groups: [
+        {
+          id: 'g1',
+          label: 'One',
+          icon: createElement('span', { key: 'a' }, 'icon'),
+        },
+      ],
+    })
+
+    const newIcon = createElement('span', { key: 'b' }, 'icon')
+    store.getState()._sync([], [{ id: 'g1', label: 'One', icon: newIcon }])
+
+    expect(store.getState().groups.g1!.icon).toBe(newIcon)
+  })
+
   it('_sync preserves the collapse snapshot of a hidden layer', () => {
     const store = createLegendStore('s', { layers })
     store.getState().setCollapsed('a', true) // manual collapse

package/src/legend/stores/types.ts

@@ -242,6 +242,14 @@ export interface LegendLayer {
 export interface LegendGroup {
   id: string
   label: string
+  /**
+   * Optional header icon. Rendered only when provided — no icon shows by
+   * default. A same-type element with shallow-equal props is treated as
+   * unchanged across re-syncs even when re-created inline (e.g.
+   * `icon={<MyIcon />}`); a deeply nested custom node should be memoized if
+   * you want to avoid unnecessary syncs.
+   */
+  icon?: ReactNode
   collapsed: boolean
   /**
    * @internal Collapsed state snapshotted when the group was hidden via

package/dist/legend-store-registry-CVYzhR1-.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"legend-store-registry-CVYzhR1-.js","sources":["../src/legend/stores/legend-context.ts","../src/legend/stores/selectors.ts","../src/legend/stores/legend-store-registry.ts"],"sourcesContent":["import { createContext, useContext } from 'react'\n\n/** @experimental This API is new and may change in a future release. */\nexport const LegendContext = createContext<string | null>(null)\n\n/** @experimental This API is new and may change in a future release. */\nexport function useLegendId(): string {\n  const id = useContext(LegendContext)\n  if (id == null) {\n    throw new Error(\n      'useLegendId() must be called inside <Legend.Provider>. ' +\n        'If you are calling from outside the Provider tree, use the hooks ' +\n        '(useLegendStore, useLegendShallow) directly with an explicit id.',\n    )\n  }\n  return id\n}\n","import type { LegendGroup, LegendLayer, LegendState } from './types'\n\nconst byOrder = <T extends { order: number }>(a: T, b: T): number =>\n  a.order - b.order\n\n/**\n * Groups sorted by `order`.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectOrderedGroups(state: LegendState): LegendGroup[] {\n  return Object.values(state.groups).sort(byOrder)\n}\n\n/**\n * Layers belonging to `groupId` (pass `undefined` for ungrouped, top-level\n * layers), sorted by `order`.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectLayersByGroup(\n  state: LegendState,\n  groupId: string | undefined,\n): LegendLayer[] {\n  return Object.values(state.layers)\n    .filter((l) => l.groupId === groupId)\n    .sort(byOrder)\n}\n\n/**\n * All layers sorted by `order`, regardless of group.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectOrderedLayers(state: LegendState): LegendLayer[] {\n  return Object.values(state.layers).sort(byOrder)\n}\n\n/**\n * `true` when every group is collapsed (`false` with no groups) — drives the\n * \"Collapse all groups\" / \"Expand all groups\" menu label flip.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectAllGroupsCollapsed(state: LegendState): boolean {\n  const groups = Object.values(state.groups)\n  return groups.length > 0 && groups.every((g) => g.collapsed)\n}\n\n/**\n * Whether the legend has groups — gates panel-level group actions.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectHasGroups(state: LegendState): boolean {\n  return Object.keys(state.groups).length > 0\n}\n\n/**\n * Visible layers grouped for the enabled-layers menu.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectVisibleLayersGrouped(\n  state: LegendState,\n): { group?: LegendGroup; layers: LegendLayer[] }[] {\n  const visible = (groupId: string | undefined) =>\n    selectLayersByGroup(state, groupId).filter((l) => l.visible)\n  const sections: { group?: LegendGroup; layers: LegendLayer[] }[] = []\n  for (const group of selectOrderedGroups(state)) {\n    const layers = visible(group.id)\n    if (layers.length > 0) sections.push({ group, layers })\n  }\n  const ungrouped = visible(undefined)\n  if (ungrouped.length > 0) sections.push({ layers: ungrouped })\n  return sections\n}\n\n/**\n * Whether a layer has any collapsible body — something the row's `Collapse`\n * can actually fold. A layer with no variables, sections, or helper note\n * renders an empty body, so there is nothing to collapse. Gates the row's\n * title-area collapse affordance (chevron + click).\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectLayerCollapsible(\n  state: LegendState,\n  layerId: string,\n): boolean {\n  const layer = state.layers[layerId]\n  if (!layer) return false\n  return (\n    layer.variables.length > 0 ||\n    (layer.sections?.length ?? 0) > 0 ||\n    // Truthiness matches the render condition — an empty-string note renders\n    // no footer, so it must not enable the collapse affordance.\n    Boolean(layer.helperText)\n  )\n}\n\n/**\n * Tri-state visibility — derived for groups from their member layers, and the\n * state contract of a controlled `Legend.VisibilityToggle` for any custom\n * element kind.\n */\nexport type LegendVisibility = 'visible' | 'hidden' | 'mixed'\n\n/**\n * Tri-state group visibility: `'visible'` when every member layer is visible\n * (also for empty groups), `'hidden'` when none is, `'mixed'` otherwise.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectGroupVisibility(\n  state: LegendState,\n  groupId: string,\n): LegendVisibility {\n  let anyVisible = false\n  let anyHidden = false\n  for (const layer of selectLayersByGroup(state, groupId)) {\n    if (layer.visible) anyVisible = true\n    else anyHidden = true\n  }\n  if (anyVisible && anyHidden) return 'mixed'\n  return anyHidden ? 'hidden' : 'visible'\n}\n","import { useStore, type StoreApi } from 'zustand'\nimport { createStore } from 'zustand/vanilla'\nimport { devtools } from 'zustand/middleware'\nimport { useShallow } from 'zustand/react/shallow'\nimport type {\n  LegendConfigSection,\n  LegendGroup,\n  LegendGroupInput,\n  LegendInit,\n  LegendLayer,\n  LegendLayerInput,\n  LegendState,\n  LegendStoreApi,\n} from './types'\nimport { selectLayersByGroup, selectOrderedGroups } from './selectors'\n\n// Per-panel legend store registry. One store per `<Legend.Provider id>`.\n// Mirrors the widgets-v2 registry pattern (keyed Map + refcounted mounts),\n// without the chart-pipeline machinery.\nconst legendStores = new Map<string, LegendStoreApi>()\nconst legendMountCounts = new Map<string, number>()\nconst warnedDuplicates = new Set<string>()\n\nconst isDev = (): boolean => {\n  try {\n    return Boolean(\n      (import.meta as unknown as { env?: { DEV?: boolean } }).env?.DEV,\n    )\n  } catch {\n    return false\n  }\n}\n\nconst clamp01 = (n: number): number => Math.min(1, Math.max(0, n))\n\n// ─── Pure state helpers ─────────────────────────────────────────────────────\n\n/**\n * Visibility↔collapse coupling. Hiding snapshots the current collapsed state\n * and collapses; showing restores the snapshot (manual choices persist) and\n * defaults to expanded. Idempotent: returns `null` when `visible` is already\n * the requested value, so a double-hide can't overwrite the real snapshot.\n */\nfunction visibilityPatch(\n  entity: {\n    visible: boolean\n    collapsed: boolean\n    collapsedBeforeHide?: boolean\n  },\n  visible: boolean,\n): {\n  visible: boolean\n  collapsed: boolean\n  collapsedBeforeHide: boolean | undefined\n} | null {\n  if (entity.visible === visible) return null\n  return visible\n    ? // Showing: restore the pre-hide collapsed state (default expand).\n      {\n        visible,\n        collapsed: entity.collapsedBeforeHide ?? false,\n        collapsedBeforeHide: undefined,\n      }\n    : // Hiding: snapshot, then collapse.\n      {\n        visible,\n        collapsed: true,\n        collapsedBeforeHide: entity.collapsed,\n      }\n}\n\n/**\n * Manual collapse. While hidden, the snapshot follows the manual choice so\n * the next show keeps it.\n */\nfunction collapsePatch(\n  entity: { visible: boolean },\n  collapsed: boolean,\n): { collapsed: boolean; collapsedBeforeHide?: boolean } {\n  return entity.visible\n    ? { collapsed }\n    : { collapsed, collapsedBeforeHide: collapsed }\n}\n\n/**\n * Reorder one entity within its **ordered** bucket: splice it out, insert at\n * the clamped index, and return the dense `order` rewrites (only the entries\n * whose order actually changes). `null` when the position doesn't change or\n * the id isn't in the bucket. Powers `moveLayer` / `moveGroup`.\n */\nfunction movePatch<T extends { id: string; order: number }>(\n  bucket: T[],\n  id: string,\n  toIndex: number,\n): Map<string, number> | null {\n  const fromIndex = bucket.findIndex((e) => e.id === id)\n  if (fromIndex === -1) return null\n  const clamped = Math.max(0, Math.min(bucket.length - 1, toIndex))\n  if (clamped === fromIndex) return null\n  const next = [...bucket]\n  const [moved] = next.splice(fromIndex, 1)\n  next.splice(clamped, 0, moved!)\n  const orders = new Map<string, number>()\n  next.forEach((entity, index) => {\n    if (entity.order !== index) orders.set(entity.id, index)\n  })\n  return orders.size > 0 ? orders : null\n}\n\nfunction updateLayer(\n  state: LegendState,\n  id: string,\n  patch: Partial<LegendLayer>,\n): Partial<LegendState> {\n  const layer = state.layers[id]\n  if (!layer) return {}\n  return { layers: { ...state.layers, [id]: { ...layer, ...patch } } }\n}\n\nfunction updateGroup(\n  state: LegendState,\n  id: string,\n  patch: Partial<LegendGroup>,\n): Partial<LegendState> {\n  const group = state.groups[id]\n  if (!group) return {}\n  return { groups: { ...state.groups, [id]: { ...group, ...patch } } }\n}\n\n/**\n * Merge incoming config-select sections while preserving the user's picked\n * `active` for any section id that still exists and whose pick is still among\n * the new `options` (the structure — ids, titles, options, order — always\n * follows the props). Returns the previous array when the merge lands on the\n * same content, so unchanged syncs keep entity identity (bail-out).\n */\nfunction mergeSections(\n  prev: LegendConfigSection[] | undefined,\n  next: LegendConfigSection[] | undefined,\n): LegendConfigSection[] | undefined {\n  if (!next || !prev || prev === next) return next\n  const merged = next.map((section) => {\n    const prevSection = prev.find((p) => p.id === section.id)\n    return prevSection &&\n      prevSection.active !== section.active &&\n      section.options.includes(prevSection.active)\n      ? { ...section, active: prevSection.active }\n      : section\n  })\n  const sameAsPrev =\n    prev.length === merged.length &&\n    merged.every((m, i) => {\n      const p = prev[i]!\n      return (\n        p.id === m.id &&\n        p.title === m.title &&\n        p.options === m.options &&\n        p.active === m.active\n      )\n    })\n  return sameAsPrev ? prev : merged\n}\n\n/** Shallow equality over the union of both objects' keys (`Object.is` per value). */\nfunction shallowEqualEntity<T extends object>(a: T, b: T): boolean {\n  const keys = new Set([...Object.keys(a), ...Object.keys(b)]) as Set<keyof T>\n  for (const key of keys) {\n    if (!Object.is(a[key], b[key])) return false\n  }\n  return true\n}\n\n/**\n * Reassign `order` to dense indexes `0..n-1` within each sibling bucket,\n * sorted by current order with ties broken by input position. This is the\n * only boundary where external (possibly duplicated) orders enter, so the\n * stored orders stay dense and unique within each bucket.\n */\nfunction normalizeOrders<T extends { order: number }>(\n  entries: { merged: T; index: number }[],\n  bucketOf: (e: T) => string | undefined,\n): void {\n  const buckets = new Map<string | undefined, { merged: T; index: number }[]>()\n  for (const entry of entries) {\n    const key = bucketOf(entry.merged)\n    const bucket = buckets.get(key)\n    if (bucket) bucket.push(entry)\n    else buckets.set(key, [entry])\n  }\n  for (const bucket of buckets.values()) {\n    bucket\n      .sort((a, b) => a.merged.order - b.merged.order || a.index - b.index)\n      .forEach((entry, i) => {\n        entry.merged.order = i\n      })\n  }\n}\n\n/**\n * Seed/merge one layer: static fields follow the input; interactive state\n * (`visible`/`opacity`/`collapsed`/`order`/`collapsedBeforeHide` + section\n * actives) sticks to the store entry when present. Shared by `_sync` (per\n * entry) and the imperative `setLegendLayer`.\n */\nfunction mergeLayerEntity(\n  prev: LegendLayer | undefined,\n  input: LegendLayerInput,\n  fallbackOrder: number,\n): LegendLayer {\n  return {\n    ...input,\n    visible: prev?.visible ?? input.visible ?? true,\n    opacity: prev?.opacity ?? input.opacity ?? 1,\n    collapsed: prev?.collapsed ?? input.collapsed ?? false,\n    collapsedBeforeHide: prev?.collapsedBeforeHide,\n    sections: mergeSections(prev?.sections, input.sections),\n    order: prev?.order ?? input.order ?? fallbackOrder,\n  } as LegendLayer\n}\n\n/** Group counterpart of {@link mergeLayerEntity}. */\nfunction mergeGroupEntity(\n  prev: LegendGroup | undefined,\n  input: LegendGroupInput,\n  fallbackOrder: number,\n): LegendGroup {\n  return {\n    ...input,\n    collapsed: prev?.collapsed ?? input.collapsed ?? false,\n    collapsedBeforeHide: prev?.collapsedBeforeHide,\n    order: prev?.order ?? input.order ?? fallbackOrder,\n  } as LegendGroup\n}\n\n/**\n * Merge incoming definitions while preserving interactive state of known\n * entities: static fields (name, subtitle, variables, attributes, …) follow\n * the props; `visible`/`opacity`/`collapsed`/`order` stick to what's in the\n * store. New entities are seeded; vanished ones are dropped. Sibling orders\n * are normalized to dense indexes.\n *\n * Unchanged entities keep their previous object identity (`variables`\n * compared by reference), and when nothing changed at all the sync is a\n * no-op (`{}`), so stable consumer props never produce a state update.\n */\nfunction syncState(\n  state: LegendState,\n  layerInputs: LegendLayerInput[],\n  groupInputs: LegendGroupInput[],\n): Partial<LegendState> {\n  const layerEntries = layerInputs.map((input, index) => ({\n    index,\n    merged: mergeLayerEntity(state.layers[input.id], input, index),\n  }))\n  normalizeOrders(layerEntries, (l) => l.groupId)\n\n  const groupEntries = groupInputs.map((input, index) => ({\n    index,\n    merged: mergeGroupEntity(state.groups[input.id], input, index),\n  }))\n  normalizeOrders(groupEntries, () => undefined)\n\n  // Reference preservation: reuse the previous entity object when nothing\n  // about it changed, so subscribers see stable identities.\n  let layersChanged = layerEntries.length !== Object.keys(state.layers).length\n  const layers: Record<string, LegendLayer> = {}\n  for (const { merged } of layerEntries) {\n    const prev = state.layers[merged.id]\n    if (prev && shallowEqualEntity(prev, merged)) {\n      layers[merged.id] = prev\n    } else {\n      layers[merged.id] = merged\n      layersChanged = true\n    }\n  }\n\n  let groupsChanged = groupEntries.length !== Object.keys(state.groups).length\n  const groups: Record<string, LegendGroup> = {}\n  for (const { merged } of groupEntries) {\n    const prev = state.groups[merged.id]\n    if (prev && shallowEqualEntity(prev, merged)) {\n      groups[merged.id] = prev\n    } else {\n      groups[merged.id] = merged\n      groupsChanged = true\n    }\n  }\n\n  if (!layersChanged && !groupsChanged) return {}\n  return {\n    layers: layersChanged ? layers : state.layers,\n    groups: groupsChanged ? groups : state.groups,\n  }\n}\n\n/**\n * Rebuild a layer/group record from a candidate map, normalizing dense order\n * per bucket and preserving the previous object identity for entries that are\n * unchanged. Returns `null` when nothing changed (so callers can bail with\n * `{}`).\n */\nfunction rebuildRecord<\n  T extends { id: string; order: number; groupId?: string },\n>(\n  prev: Record<string, T>,\n  next: Record<string, T>,\n  bucketOf: (e: T) => string | undefined,\n): Record<string, T> | null {\n  const entries = Object.values(next).map((e, index) => ({\n    index,\n    merged: { ...e },\n  }))\n  normalizeOrders(entries, bucketOf)\n  let changed = entries.length !== Object.keys(prev).length\n  const out: Record<string, T> = {}\n  for (const { merged } of entries) {\n    const before = prev[merged.id]\n    if (before && shallowEqualEntity(before, merged)) {\n      out[merged.id] = before\n    } else {\n      out[merged.id] = merged\n      changed = true\n    }\n  }\n  return changed ? out : null\n}\n\n/** Add or update a single layer (imperative `setLegendLayer`). */\nfunction upsertLayerState(\n  state: LegendState,\n  input: LegendLayerInput,\n): Partial<LegendState> {\n  const siblingCount = Object.values(state.layers).filter(\n    (l) => l.groupId === input.groupId && l.id !== input.id,\n  ).length\n  const merged = mergeLayerEntity(state.layers[input.id], input, siblingCount)\n  const layers = rebuildRecord(\n    state.layers,\n    { ...state.layers, [input.id]: merged },\n    (l) => l.groupId,\n  )\n  return layers ? { layers } : {}\n}\n\n/** Remove a single layer, re-densifying its sibling orders. */\nfunction removeLayerState(\n  state: LegendState,\n  id: string,\n): Partial<LegendState> {\n  if (!state.layers[id]) return {}\n  const next = { ...state.layers }\n  delete next[id]\n  const layers = rebuildRecord(state.layers, next, (l) => l.groupId)\n  return layers ? { layers } : {}\n}\n\n/** Add or update a single group (imperative `setLegendGroup`). */\nfunction upsertGroupState(\n  state: LegendState,\n  input: LegendGroupInput,\n): Partial<LegendState> {\n  const count = Object.values(state.groups).filter(\n    (g) => g.id !== input.id,\n  ).length\n  const merged = mergeGroupEntity(state.groups[input.id], input, count)\n  const groups = rebuildRecord(\n    state.groups,\n    { ...state.groups, [input.id]: merged },\n    () => undefined,\n  )\n  return groups ? { groups } : {}\n}\n\n/**\n * Remove a group; its member layers are un-grouped (`groupId` cleared) so they\n * survive as ungrouped rows. Re-densifies both group and layer orders.\n */\nfunction removeGroupState(\n  state: LegendState,\n  id: string,\n): Partial<LegendState> {\n  if (!state.groups[id]) return {}\n  const nextGroups = { ...state.groups }\n  delete nextGroups[id]\n  const groups = rebuildRecord(state.groups, nextGroups, () => undefined)\n\n  const members = Object.values(state.layers).filter((l) => l.groupId === id)\n  if (members.length === 0) return groups ? { groups } : {}\n\n  const nextLayers = { ...state.layers }\n  for (const member of members) {\n    nextLayers[member.id] = { ...member, groupId: undefined }\n  }\n  const layers = rebuildRecord(state.layers, nextLayers, (l) => l.groupId)\n  return {\n    ...(groups ? { groups } : {}),\n    ...(layers ? { layers } : {}),\n  }\n}\n\n// ─── Store factory ────────────────────────────────────────────────────────────\n\n/**\n * @internal — used by Provider; not part of the public API.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function createLegendStore(\n  id: string,\n  init: LegendInit = {},\n): LegendStoreApi {\n  // Seed through the same merge/normalize path as `_sync`, so a later sync\n  // with identical input is a guaranteed no-op (stable identities).\n  const seeded = syncState(\n    { layers: {}, groups: {} } as LegendState,\n    init.layers ?? [],\n    init.groups ?? [],\n  )\n\n  return createStore<LegendState>()(\n    devtools(\n      (set) => ({\n        layers: seeded.layers ?? {},\n        groups: seeded.groups ?? {},\n\n        setVisibility: (lid, visible) =>\n          set(\n            (s) => {\n              const layer = s.layers[lid]\n              const patch = layer && visibilityPatch(layer, visible)\n              return patch ? updateLayer(s, lid, patch) : {}\n            },\n            false,\n            'setVisibility',\n          ),\n        setOpacity: (lid, opacity) =>\n          set(\n            (s) => updateLayer(s, lid, { opacity: clamp01(opacity) }),\n            false,\n            'setOpacity',\n          ),\n        setCollapsed: (lid, collapsed) =>\n          set(\n            (s) => {\n              const layer = s.layers[lid]\n              return layer\n                ? updateLayer(s, lid, collapsePatch(layer, collapsed))\n                : {}\n            },\n            false,\n            'setCollapsed',\n          ),\n        setSectionValue: (lid, sectionId, value) =>\n          set(\n            (s) => {\n              const layer = s.layers[lid]\n              const section = layer?.sections?.find((x) => x.id === sectionId)\n              if (\n                !layer?.sections ||\n                !section ||\n                section.active === value ||\n                !section.options.includes(value)\n              ) {\n                return {}\n              }\n              const sections = layer.sections.map((x) =>\n                x.id === sectionId ? { ...x, active: value } : x,\n              )\n              return updateLayer(s, lid, { sections })\n            },\n            false,\n            'setSectionValue',\n          ),\n\n        moveLayer: (lid, toIndex) =>\n          set(\n            (s) => {\n              const layer = s.layers[lid]\n              if (!layer) return {}\n              const bucket = selectLayersByGroup(s, layer.groupId)\n              const orders = movePatch(bucket, lid, toIndex)\n              if (!orders) return {}\n              const layers = { ...s.layers }\n              for (const [id, order] of orders) {\n                layers[id] = { ...layers[id]!, order }\n              }\n              return { layers }\n            },\n            false,\n            'moveLayer',\n          ),\n\n        setGroupVisibility: (gid, visible) =>\n          set(\n            (s) => {\n              const group = s.groups[gid]\n              if (!group) return {}\n              const members = Object.values(s.layers).filter(\n                (l) => l.groupId === gid,\n              )\n              const anyVisible = members.some((l) => l.visible)\n              // Idempotence on the derived state: hide needs a visible member,\n              // show needs a fully-hidden group (mixed acts in both directions\n              // except show-from-mixed still shows the hidden remainder).\n              if (members.length === 0 || (!visible && !anyVisible)) return {}\n\n              // Cascade: each member runs the standard visibility↔collapse\n              // coupling, so per-layer collapse snapshots survive a group\n              // hide/show; members already at the target are untouched.\n              const layers = { ...s.layers }\n              let layersChanged = false\n              for (const member of members) {\n                const patch = visibilityPatch(member, visible)\n                if (patch) {\n                  layers[member.id] = { ...member, ...patch }\n                  layersChanged = true\n                }\n              }\n              if (!layersChanged) return {}\n\n              // Group-level collapse coupling, only on real derived\n              // transitions: any-visible→hidden snapshots + collapses;\n              // hidden→visible restores the snapshot.\n              let groupPatch: Partial<LegendGroup> | null = null\n              if (!visible && anyVisible) {\n                groupPatch = {\n                  collapsed: true,\n                  collapsedBeforeHide: group.collapsed,\n                }\n              } else if (visible && !anyVisible) {\n                groupPatch = {\n                  collapsed: group.collapsedBeforeHide ?? false,\n                  collapsedBeforeHide: undefined,\n                }\n              }\n              return {\n                layers,\n                ...(groupPatch\n                  ? {\n                      groups: {\n                        ...s.groups,\n                        [gid]: { ...group, ...groupPatch },\n                      },\n                    }\n                  : {}),\n              }\n            },\n            false,\n            'setGroupVisibility',\n          ),\n        setGroupCollapsed: (gid, collapsed) =>\n          set(\n            (s) => {\n              const group = s.groups[gid]\n              if (!group) return {}\n              // Group visibility is derived from members; while the group is\n              // hidden the snapshot follows the manual choice (layer parity).\n              const members = Object.values(s.layers).filter(\n                (l) => l.groupId === gid,\n              )\n              const hidden =\n                members.length > 0 && members.every((l) => !l.visible)\n              return updateGroup(\n                s,\n                gid,\n                hidden\n                  ? { collapsed, collapsedBeforeHide: collapsed }\n                  : { collapsed },\n              )\n            },\n            false,\n            'setGroupCollapsed',\n          ),\n\n        moveGroup: (gid, toIndex) =>\n          set(\n            (s) => {\n              if (!s.groups[gid]) return {}\n              const orders = movePatch(selectOrderedGroups(s), gid, toIndex)\n              if (!orders) return {}\n              const groups = { ...s.groups }\n              for (const [id, order] of orders) {\n                groups[id] = { ...groups[id]!, order }\n              }\n              return { groups }\n            },\n            false,\n            'moveGroup',\n          ),\n\n        setLegendLayer: (input) =>\n          set((s) => upsertLayerState(s, input), false, 'setLegendLayer'),\n        removeLegendLayer: (lid) =>\n          set((s) => removeLayerState(s, lid), false, 'removeLegendLayer'),\n        setLegendGroup: (input) =>\n          set((s) => upsertGroupState(s, input), false, 'setLegendGroup'),\n        removeLegendGroup: (gid) =>\n          set((s) => removeGroupState(s, gid), false, 'removeLegendGroup'),\n\n        _sync: (layerInputs, groupInputs) =>\n          set((s) => syncState(s, layerInputs, groupInputs), false, '_sync'),\n      }),\n      { name: `legend-${id}`, enabled: isDev() },\n    ),\n  )\n}\n\n// ─── Registry ───────────────────────────────────────────────────────────────\n\n/** @experimental This API is new and may change in a future release. */\nexport function getLegendStore(id: string): LegendStoreApi {\n  const store = legendStores.get(id)\n  if (!store) throw new Error(`[legend] Legend store \"${id}\" not found.`)\n  return store\n}\n\n/** @experimental This API is new and may change in a future release. */\nexport function hasLegendStore(id: string): boolean {\n  return legendStores.has(id)\n}\n\n/** @experimental This API is new and may change in a future release. */\nexport function deleteLegendStore(id: string): void {\n  legendStores.delete(id)\n}\n\n/** @experimental This API is new and may change in a future release. */\nexport function clearAllLegendStores(): void {\n  legendStores.clear()\n  legendMountCounts.clear()\n  warnedDuplicates.clear()\n}\n\n/**\n * @internal — used by Provider's lazy init so children can resolve the store first render.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function setLegendStoreEntry(id: string, store: LegendStoreApi): void {\n  legendStores.set(id, store)\n}\n\n/**\n * @internal — registers a Provider mount and warns on duplicate ids in dev.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function registerLegendStore(id: string, store: LegendStoreApi): void {\n  legendStores.set(id, store)\n  const count = (legendMountCounts.get(id) ?? 0) + 1\n  legendMountCounts.set(id, count)\n  if (count > 1 && isDev() && !warnedDuplicates.has(id)) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `[legend] Duplicate <Legend.Provider id=\"${id}\"> detected. ` +\n        `Multiple providers sharing an id will race on prop sync. ` +\n        `Use unique ids per legend panel.`,\n    )\n    warnedDuplicates.add(id)\n  }\n}\n\n/**\n * @internal — Provider unmount counterpart; removes the entry on last unmount.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function unregisterLegendStore(\n  id: string,\n  options: { keepAlive: boolean },\n): void {\n  const count = (legendMountCounts.get(id) ?? 1) - 1\n  if (count <= 0) {\n    legendMountCounts.delete(id)\n    if (!options.keepAlive) legendStores.delete(id)\n  } else {\n    legendMountCounts.set(id, count)\n  }\n}\n\n// ─── Hooks ────────────────────────────────────────────────────────────────────\n\n/** @experimental This API is new and may change in a future release. */\nexport function useLegendStore<T>(\n  id: string,\n  selector: (state: LegendState) => T,\n): T {\n  const store = getLegendStore(id) as unknown as StoreApi<LegendState>\n  return useStore(store, selector)\n}\n\n/** @experimental This API is new and may change in a future release. */\nexport function useLegendShallow<T>(\n  id: string,\n  selector: (state: LegendState) => T,\n): T {\n  const store = getLegendStore(id) as unknown as StoreApi<LegendState>\n  return useStore(store, useShallow(selector))\n}\n"],"names":["LegendContext","createContext","useLegendId","id","useContext","Error","byOrder","a","b","order","selectOrderedGroups","state","Object","values","groups","sort","selectLayersByGroup","groupId","layers","filter","l","selectOrderedLayers","selectAllGroupsCollapsed","length","every","g","collapsed","selectHasGroups","keys","selectVisibleLayersGrouped","visible","sections","group","push","ungrouped","undefined","selectLayerCollapsible","layerId","layer","variables","Boolean","helperText","selectGroupVisibility","anyVisible","anyHidden","legendStores","Map","legendMountCounts","warnedDuplicates","Set","isDev","import","clamp01","n","Math","min","max","visibilityPatch","entity","collapsedBeforeHide","collapsePatch","movePatch","bucket","toIndex","fromIndex","findIndex","e","clamped","next","moved","splice","orders","forEach","index","set","size","updateLayer","patch","updateGroup","mergeSections","prev","merged","map","section","prevSection","find","p","active","options","includes","m","i","title","shallowEqualEntity","key","is","normalizeOrders","entries","bucketOf","buckets","entry","get","mergeLayerEntity","input","fallbackOrder","opacity","mergeGroupEntity","syncState","layerInputs","groupInputs","layerEntries","groupEntries","layersChanged","groupsChanged","rebuildRecord","changed","out","before","upsertLayerState","siblingCount","removeLayerState","upsertGroupState","count","removeGroupState","nextGroups","members","nextLayers","member","createLegendStore","init","seeded","createStore","devtools","setVisibility","lid","s","setOpacity","setCollapsed","setSectionValue","sectionId","value","x","moveLayer","setGroupVisibility","gid","some","groupPatch","setGroupCollapsed","hidden","moveGroup","setLegendLayer","removeLegendLayer","setLegendGroup","removeLegendGroup","_sync","name","enabled","getLegendStore","store","hasLegendStore","has","deleteLegendStore","delete","clearAllLegendStores","clear","setLegendStoreEntry","registerLegendStore","console","warn","add","unregisterLegendStore","keepAlive","useLegendStore","selector","$","_c","t0","useStore","useLegendShallow","useShallow"],"mappings":"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"}