@carto/ps-react-ui 4.17.1 → 4.17.3

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

@@ -1,20 +1,29 @@
 import type { SxProps, Theme } from '@mui/material'
+import { LEGEND_GROUP_HEADER_HEIGHT } from '../legend-group/styles'
 
 export const styles = {
-  // Absolute handle — no flex slot; sticky header is the containing block.
+  // Absolute handle, flush against the header's top-left corner — no flex
+  // slot; sticky header is the containing block.
   handleSlot: {
     position: 'absolute',
     zIndex: 1,
     display: 'flex',
     alignItems: 'center',
     justifyContent: 'center',
-    height: 24,
+    left: 0,
+    top: 0,
   },
+  // Both headers center their title on the same 24px band from the header's
+  // top edge (group: 48px header, `alignItems:'center'`; row: 12px top
+  // padding + 24px `titleLine`, `alignItems:'flex-start'`) — so `height:48`
+  // centers the icon on the title in both cases, even though the row's own
+  // header is only 32px tall (a 32px-tall slot would center at 16px, 8px
+  // short of the title).
   handleSlotLayer: {
-    right: 2,
+    height: LEGEND_GROUP_HEADER_HEIGHT,
   },
   handleSlotGroup: {
-    right: 2,
+    height: LEGEND_GROUP_HEADER_HEIGHT,
   },
   handle: {
     padding: '2px',

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

@@ -238,15 +238,21 @@ function mergeLayerEntity(
   } as LegendLayer
 }
 
-/** Group counterpart of {@link mergeLayerEntity}. */
+/**
+ * Group counterpart of {@link mergeLayerEntity}. A group with no `prev`
+ * state (first sync) defaults collapsed when none of its member layers is
+ * visible yet — `hasVisibleLayer` is ignored once the group exists so a
+ * user's manual expand/collapse always sticks.
+ */
 function mergeGroupEntity(
   prev: LegendGroup | undefined,
   input: LegendGroupInput,
   fallbackOrder: number,
+  hasVisibleLayer: boolean,
 ): LegendGroup {
   return {
     ...input,
-    collapsed: prev?.collapsed ?? input.collapsed ?? false,
+    collapsed: prev?.collapsed ?? input.collapsed ?? !hasVisibleLayer,
     collapsedBeforeHide: prev?.collapsedBeforeHide,
     order: prev?.order ?? input.order ?? fallbackOrder,
   } as LegendGroup
@@ -274,9 +280,19 @@ function syncState(
   }))
   normalizeOrders(layerEntries, (l) => l.groupId)
 
+  const groupsWithVisibleLayer = new Set(
+    layerEntries
+      .filter(({ merged }) => merged.visible && merged.groupId != null)
+      .map(({ merged }) => merged.groupId!),
+  )
   const groupEntries = groupInputs.map((input, index) => ({
     index,
-    merged: mergeGroupEntity(state.groups[input.id], input, index),
+    merged: mergeGroupEntity(
+      state.groups[input.id],
+      input,
+      index,
+      groupsWithVisibleLayer.has(input.id),
+    ),
   }))
   normalizeOrders(groupEntries, () => undefined)
 
@@ -382,7 +398,15 @@ function upsertGroupState(
   const count = Object.values(state.groups).filter(
     (g) => g.id !== input.id,
   ).length
-  const merged = mergeGroupEntity(state.groups[input.id], input, count)
+  const hasVisibleLayer = Object.values(state.layers).some(
+    (l) => l.groupId === input.id && l.visible,
+  )
+  const merged = mergeGroupEntity(
+    state.groups[input.id],
+    input,
+    count,
+    hasVisibleLayer,
+  )
   const groups = rebuildRecord(
     state.groups,
     { ...state.groups, [input.id]: merged },

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

@@ -148,6 +148,29 @@ describe('legend store', () => {
     expect(store.getState().groups.g1!.collapsed).toBe(true)
   })
 
+  it('a group with no visible member starts collapsed', () => {
+    const store = createLegendStore('s', {
+      layers: layers.map((l) =>
+        l.groupId === 'g1' ? { ...l, visible: false } : l,
+      ),
+      groups: [
+        { id: 'g1', label: 'One' },
+        { id: 'g2', label: 'Empty' },
+      ],
+    })
+    expect(store.getState().groups.g1!.collapsed).toBe(true)
+    // No members at all also counts as "nothing enabled".
+    expect(store.getState().groups.g2!.collapsed).toBe(true)
+  })
+
+  it('a group with at least one visible member starts expanded', () => {
+    const store = createLegendStore('s', {
+      layers,
+      groups: [{ id: 'g1', label: 'One' }],
+    })
+    expect(store.getState().groups.g1!.collapsed).toBe(false)
+  })
+
   it('selectGroupVisibility derives the tri-state from member layers', () => {
     const store = createLegendStore('s', {
       layers,

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

@@ -1 +0,0 @@
-{"version":3,"file":"legend-store-registry-Bo8U_qWM.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 { isValidElement } from 'react'\nimport { 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/**\n * Same-type, same-key React elements with shallow-equal props count as\n * equal, so a ReactNode field (e.g. `LegendGroup.icon`) re-created inline on\n * every render (`icon={<MyIcon />}`) doesn't look \"changed\" on every sync. A\n * different `key` is treated as a real change, same as a different type.\n */\nfunction reactElementEqual(a: unknown, b: unknown): boolean {\n  if (!isValidElement(a) || !isValidElement(b)) return false\n  if (a.type !== b.type || a.key !== b.key) return false\n  return shallowEqualEntity(\n    a.props as Record<string, unknown>,\n    b.props as Record<string, unknown>,\n  )\n}\n\n/**\n * Shallow equality over the union of both objects' keys — `Object.is` per\n * value, except React elements, which fall back to {@link reactElementEqual}.\n */\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])) continue\n    if (!reactElementEqual(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","reactElementEqual","isValidElement","type","key","shallowEqualEntity","props","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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"}

package/dist/smart-tooltip-D4vwQpFf.js

@@ -1,37 +0,0 @@
-import { jsx as v } from "react/jsx-runtime";
-import { c as S } from "react/compiler-runtime";
-import { useRef as w, useState as I, useLayoutEffect as O } from "react";
-import { T as P } from "./tooltip-BDnrRKrp.js";
-const x = [];
-function _(p) {
-  const t = S(11), {
-    title: a,
-    dependencies: m,
-    timeout: d,
-    TooltipProps: l,
-    children: c
-  } = p, f = m === void 0 ? x : m, e = d === void 0 ? 500 : d, o = w(null), [T, h] = I(!1);
-  let r;
-  t[0] !== e ? (r = () => {
-    const E = setTimeout(() => {
-      if (o.current) {
-        const g = o.current.scrollWidth > o.current.clientWidth || o.current.scrollHeight > o.current.clientHeight;
-        h(g);
-      }
-    }, e);
-    return () => clearTimeout(E);
-  }, t[0] = e, t[1] = r) : r = t[1];
-  let n;
-  t[2] !== f || t[3] !== e ? (n = [f, e], t[2] = f, t[3] = e, t[4] = n) : n = t[4], O(r, n);
-  const u = T && a;
-  let i;
-  t[5] !== c ? (i = c({
-    ref: o
-  }), t[5] = c, t[6] = i) : i = t[6];
-  let s;
-  return t[7] !== l || t[8] !== u || t[9] !== i ? (s = /* @__PURE__ */ v(P, { title: u, ...l, children: i }), t[7] = l, t[8] = u, t[9] = i, t[10] = s) : s = t[10], s;
-}
-export {
-  _ as S
-};
-//# sourceMappingURL=smart-tooltip-D4vwQpFf.js.map

package/dist/smart-tooltip-D4vwQpFf.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"smart-tooltip-D4vwQpFf.js","sources":["../src/components/smart-tooltip/smart-tooltip.tsx"],"sourcesContent":["import type { TooltipProps } from '@mui/material'\nimport { useLayoutEffect, useRef, useState, type JSX, type Ref } from 'react'\nimport { Tooltip } from '../tooltip/tooltip'\n\nconst EMPTY_DEPENDENCIES: unknown[] = []\n\n/**\n * An intelligent tooltip wrapper that automatically detects text overflow and displays a tooltip only when content is truncated.\n *\n * @remarks\n * Uses a render prop pattern. The child function receives a `ref` that must be attached to the element being monitored for overflow. Use the `dependencies` array to trigger re-evaluation when content or container size changes.\n *\n * @example\n * ```tsx\n * <SmartTooltip title=\"This is a long text that might get truncated\">\n *   {({ ref }) => (\n *     <Typography ref={ref} noWrap sx={{ overflow: 'hidden', textOverflow: 'ellipsis' }}>\n *       This is a long text that might get truncated\n *     </Typography>\n *   )}\n * </SmartTooltip>\n * ```\n */\nexport function SmartTooltip<T extends HTMLElement>({\n  title,\n  dependencies = EMPTY_DEPENDENCIES,\n  timeout = 500,\n  TooltipProps,\n  children,\n}: {\n  title: string | undefined\n  dependencies?: unknown[]\n  timeout?: number\n  children: (props: { ref: Ref<T> }) => JSX.Element\n  TooltipProps?: Partial<TooltipProps>\n}) {\n  const ref = useRef<T>(null)\n  const [isOverflowing, setIsOverflowing] = useState(false)\n\n  useLayoutEffect(() => {\n    const timerId = setTimeout(() => {\n      if (ref.current) {\n        const isOverflowing =\n          ref.current.scrollWidth > ref.current.clientWidth ||\n          ref.current.scrollHeight > ref.current.clientHeight\n\n        setIsOverflowing(isOverflowing)\n      }\n    }, timeout)\n\n    return () => clearTimeout(timerId)\n  }, [dependencies, timeout])\n\n  return (\n    <Tooltip title={isOverflowing && title} {...TooltipProps}>\n      {children({ ref })}\n    </Tooltip>\n  )\n}\n"],"names":["EMPTY_DEPENDENCIES","SmartTooltip","t0","$","_c","title","dependencies","t1","timeout","t2","TooltipProps","children","undefined","ref","useRef","isOverflowing","setIsOverflowing","useState","t3","timerId","setTimeout","current","isOverflowing_0","scrollWidth","clientWidth","scrollHeight","clientHeight","clearTimeout","t4","useLayoutEffect","t5","t6","t7","Tooltip"],"mappings":";;;;AAIA,MAAMA,IAAgC,CAAA;AAmB/B,SAAAC,EAAAC,GAAA;AAAA,QAAAC,IAAAC,EAAA,EAAA,GAA6C;AAAA,IAAAC,OAAAA;AAAAA,IAAAC,cAAAC;AAAAA,IAAAC,SAAAC;AAAAA,IAAAC,cAAAA;AAAAA,IAAAC,UAAAA;AAAAA,EAAAA,IAAAT,GAElDI,IAAAC,MAAAK,SAAAZ,IAAAO,GACAC,IAAAC,MAAAG,SAAA,MAAAH,GAUAI,IAAYC,EAAU,IAAI,GAC1B,CAAAC,GAAAC,CAAA,IAA0CC,EAAS,EAAK;AAAC,MAAAC;AAAA,EAAAf,SAAAK,KAEzCU,IAAAA,MAAA;AACd,UAAAC,IAAgBC,WAAW,MAAA;AACzB,UAAIP,EAAGQ,SAAQ;AACb,cAAAC,IACET,EAAGQ,QAAQE,cAAeV,EAAGQ,QAAQG,eACrCX,EAAGQ,QAAQI,eAAgBZ,EAAGQ,QAAQK;AAExCV,QAAAA,EAAiBD,CAAa;AAAA,MAAC;AAAA,IAChC,GACAP,CAAO;AAAC,WAEJ,MAAMmB,aAAaR,CAAO;AAAA,EAAC,GACnChB,OAAAK,GAAAL,OAAAe,KAAAA,IAAAf,EAAA,CAAA;AAAA,MAAAyB;AAAA,EAAAzB,EAAA,CAAA,MAAAG,KAAAH,SAAAK,KAAEoB,IAAA,CAACtB,GAAcE,CAAO,GAACL,OAAAG,GAAAH,OAAAK,GAAAL,OAAAyB,KAAAA,IAAAzB,EAAA,CAAA,GAZ1B0B,EAAgBX,GAYbU,CAAuB;AAGR,QAAAE,IAAAf,KAAAV;AAAsB,MAAA0B;AAAA,EAAA5B,SAAAQ,KACnCoB,IAAApB,EAAS;AAAA,IAAAE,KAAAA;AAAAA,EAAAA,CAAO,GAACV,OAAAQ,GAAAR,OAAA4B,KAAAA,IAAA5B,EAAA,CAAA;AAAA,MAAA6B;AAAA,SAAA7B,EAAA,CAAA,MAAAO,KAAAP,SAAA2B,KAAA3B,EAAA,CAAA,MAAA4B,KADpBC,sBAACC,GAAA,EAAe,OAAAH,GAAsB,GAAMpB,GACzCqB,UAAAA,GACH,GAAU5B,OAAAO,GAAAP,OAAA2B,GAAA3B,OAAA4B,GAAA5B,QAAA6B,KAAAA,IAAA7B,EAAA,EAAA,GAFV6B;AAEU;"}