@carto/ps-react-ui 4.12.1 → 4.13.0

package/dist/selectors-DwHj6mE2.js

@@ -0,0 +1,388 @@
+import { createContext as E, useContext as V } from "react";
+import { c as G } from "react/compiler-runtime";
+import { useStore as k } from "zustand";
+import { createStore as P } from "zustand/vanilla";
+import { devtools as M } from "zustand/middleware";
+import { useShallow as x } from "zustand/react/shallow";
+const $ = E(null);
+function X() {
+  const e = V($);
+  if (e == null)
+    throw new Error("useLegendId() must be called inside <Legend.Provider>. If you are calling from outside the Provider tree, use the hooks (useLegendStore, useLegendShallow) directly with an explicit id.");
+  return e;
+}
+const g = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Set(), B = () => {
+  try {
+    return !1;
+  } catch {
+    return !1;
+  }
+}, A = (e) => Math.min(1, Math.max(0, e));
+function j(e, r) {
+  return e.visible === r ? null : r ? (
+    // Showing: restore the pre-hide collapsed state (default expand).
+    {
+      visible: r,
+      collapsed: e.collapsedBeforeHide ?? !1,
+      collapsedBeforeHide: void 0
+    }
+  ) : (
+    // Hiding: snapshot, then collapse.
+    {
+      visible: r,
+      collapsed: !0,
+      collapsedBeforeHide: e.collapsed
+    }
+  );
+}
+function D(e, r) {
+  return e.visible ? {
+    collapsed: r
+  } : {
+    collapsed: r,
+    collapsedBeforeHide: r
+  };
+}
+function h(e, r, n) {
+  const s = e.layers[r];
+  return s ? {
+    layers: {
+      ...e.layers,
+      [r]: {
+        ...s,
+        ...n
+      }
+    }
+  } : {};
+}
+function q(e, r, n) {
+  const s = e.groups[r];
+  return s ? {
+    groups: {
+      ...e.groups,
+      [r]: {
+        ...s,
+        ...n
+      }
+    }
+  } : {};
+}
+function _(e, r) {
+  if (!r || !e || e === r) return r;
+  const n = r.map((o) => {
+    const t = e.find((l) => l.id === o.id);
+    return t && t.active !== o.active && o.options.includes(t.active) ? {
+      ...o,
+      active: t.active
+    } : o;
+  });
+  return e.length === n.length && n.every((o, t) => {
+    const l = e[t];
+    return l.id === o.id && l.title === o.title && l.options === o.options && l.active === o.active;
+  }) ? e : n;
+}
+function L(e, r) {
+  const n = /* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(r)]);
+  for (const s of n)
+    if (!Object.is(e[s], r[s])) return !1;
+  return !0;
+}
+function v(e, r) {
+  const n = /* @__PURE__ */ new Map();
+  for (const s of e) {
+    const o = r(s.merged), t = n.get(o);
+    t ? t.push(s) : n.set(o, [s]);
+  }
+  for (const s of n.values())
+    s.sort((o, t) => o.merged.order - t.merged.order || o.index - t.index).forEach((o, t) => {
+      o.merged.order = t;
+    });
+}
+function I(e, r, n) {
+  return {
+    ...r,
+    visible: e?.visible ?? r.visible ?? !0,
+    opacity: e?.opacity ?? r.opacity ?? 1,
+    collapsed: e?.collapsed ?? r.collapsed ?? !1,
+    collapsedBeforeHide: e?.collapsedBeforeHide,
+    sections: _(e?.sections, r.sections),
+    order: e?.order ?? r.order ?? n
+  };
+}
+function H(e, r, n) {
+  return {
+    ...r,
+    collapsed: e?.collapsed ?? r.collapsed ?? !1,
+    collapsedBeforeHide: e?.collapsedBeforeHide,
+    order: e?.order ?? r.order ?? n
+  };
+}
+function w(e, r, n) {
+  const s = r.map((u, a) => ({
+    index: a,
+    merged: I(e.layers[u.id], u, a)
+  }));
+  v(s, (u) => u.groupId);
+  const o = n.map((u, a) => ({
+    index: a,
+    merged: H(e.groups[u.id], u, a)
+  }));
+  v(o, () => {
+  });
+  let t = s.length !== Object.keys(e.layers).length;
+  const l = {};
+  for (const {
+    merged: u
+  } of s) {
+    const a = e.layers[u.id];
+    a && L(a, u) ? l[u.id] = a : (l[u.id] = u, t = !0);
+  }
+  let c = o.length !== Object.keys(e.groups).length;
+  const i = {};
+  for (const {
+    merged: u
+  } of o) {
+    const a = e.groups[u.id];
+    a && L(a, u) ? i[u.id] = a : (i[u.id] = u, c = !0);
+  }
+  return !t && !c ? {} : {
+    layers: t ? l : e.layers,
+    groups: c ? i : e.groups
+  };
+}
+function y(e, r, n) {
+  const s = Object.values(r).map((l, c) => ({
+    index: c,
+    merged: {
+      ...l
+    }
+  }));
+  v(s, n);
+  let o = s.length !== Object.keys(e).length;
+  const t = {};
+  for (const {
+    merged: l
+  } of s) {
+    const c = e[l.id];
+    c && L(c, l) ? t[l.id] = c : (t[l.id] = l, o = !0);
+  }
+  return o ? t : null;
+}
+function z(e, r) {
+  const n = Object.values(e.layers).filter((t) => t.groupId === r.groupId && t.id !== r.id).length, s = I(e.layers[r.id], r, n), o = y(e.layers, {
+    ...e.layers,
+    [r.id]: s
+  }, (t) => t.groupId);
+  return o ? {
+    layers: o
+  } : {};
+}
+function R(e, r) {
+  if (!e.layers[r]) return {};
+  const n = {
+    ...e.layers
+  };
+  delete n[r];
+  const s = y(e.layers, n, (o) => o.groupId);
+  return s ? {
+    layers: s
+  } : {};
+}
+function U(e, r) {
+  const n = Object.values(e.groups).filter((t) => t.id !== r.id).length, s = H(e.groups[r.id], r, n), o = y(e.groups, {
+    ...e.groups,
+    [r.id]: s
+  }, () => {
+  });
+  return o ? {
+    groups: o
+  } : {};
+}
+function F(e, r) {
+  if (!e.groups[r]) return {};
+  const n = {
+    ...e.groups
+  };
+  delete n[r];
+  const s = y(e.groups, n, () => {
+  }), o = Object.values(e.layers).filter((c) => c.groupId === r);
+  if (o.length === 0) return s ? {
+    groups: s
+  } : {};
+  const t = {
+    ...e.layers
+  };
+  for (const c of o)
+    t[c.id] = {
+      ...c,
+      groupId: void 0
+    };
+  const l = y(e.layers, t, (c) => c.groupId);
+  return {
+    ...s ? {
+      groups: s
+    } : {},
+    ...l ? {
+      layers: l
+    } : {}
+  };
+}
+function Y(e, r = {}) {
+  const n = w({
+    layers: {},
+    groups: {}
+  }, r.layers ?? [], r.groups ?? []);
+  return P()(M((s) => ({
+    layers: n.layers ?? {},
+    groups: n.groups ?? {},
+    setVisibility: (o, t) => s((l) => {
+      const c = l.layers[o], i = c && j(c, t);
+      return i ? h(l, o, i) : {};
+    }, !1, "setVisibility"),
+    setOpacity: (o, t) => s((l) => h(l, o, {
+      opacity: A(t)
+    }), !1, "setOpacity"),
+    setCollapsed: (o, t) => s((l) => {
+      const c = l.layers[o];
+      return c ? h(l, o, D(c, t)) : {};
+    }, !1, "setCollapsed"),
+    setSectionValue: (o, t, l) => s((c) => {
+      const i = c.layers[o], u = i?.sections?.find((d) => d.id === t);
+      if (!i?.sections || !u || u.active === l || !u.options.includes(l))
+        return {};
+      const a = i.sections.map((d) => d.id === t ? {
+        ...d,
+        active: l
+      } : d);
+      return h(c, o, {
+        sections: a
+      });
+    }, !1, "setSectionValue"),
+    setGroupVisibility: (o, t) => s((l) => {
+      const c = l.groups[o];
+      if (!c) return {};
+      const i = Object.values(l.layers).filter((f) => f.groupId === o), u = i.some((f) => f.visible);
+      if (i.length === 0 || !t && !u) return {};
+      const a = {
+        ...l.layers
+      };
+      let d = !1;
+      for (const f of i) {
+        const O = j(f, t);
+        O && (a[f.id] = {
+          ...f,
+          ...O
+        }, d = !0);
+      }
+      if (!d) return {};
+      let m = null;
+      return !t && u ? m = {
+        collapsed: !0,
+        collapsedBeforeHide: c.collapsed
+      } : t && !u && (m = {
+        collapsed: c.collapsedBeforeHide ?? !1,
+        collapsedBeforeHide: void 0
+      }), {
+        layers: a,
+        ...m ? {
+          groups: {
+            ...l.groups,
+            [o]: {
+              ...c,
+              ...m
+            }
+          }
+        } : {}
+      };
+    }, !1, "setGroupVisibility"),
+    setGroupCollapsed: (o, t) => s((l) => {
+      if (!l.groups[o]) return {};
+      const i = Object.values(l.layers).filter((a) => a.groupId === o), u = i.length > 0 && i.every((a) => !a.visible);
+      return q(l, o, u ? {
+        collapsed: t,
+        collapsedBeforeHide: t
+      } : {
+        collapsed: t
+      });
+    }, !1, "setGroupCollapsed"),
+    setLegendLayer: (o) => s((t) => z(t, o), !1, "setLegendLayer"),
+    removeLegendLayer: (o) => s((t) => R(t, o), !1, "removeLegendLayer"),
+    setLegendGroup: (o) => s((t) => U(t, o), !1, "setLegendGroup"),
+    removeLegendGroup: (o) => s((t) => F(t, o), !1, "removeLegendGroup"),
+    _sync: (o, t) => s((l) => w(l, o, t), !1, "_sync")
+  }), {
+    name: `legend-${e}`,
+    enabled: B()
+  }));
+}
+function C(e) {
+  const r = g.get(e);
+  if (!r) throw new Error(`[legend] Legend store "${e}" not found.`);
+  return r;
+}
+function Z(e) {
+  return g.has(e);
+}
+function ee(e) {
+  g.delete(e);
+}
+function re() {
+  g.clear(), p.clear(), b.clear();
+}
+function oe(e, r) {
+  g.set(e, r);
+}
+function se(e, r) {
+  g.set(e, r);
+  const n = (p.get(e) ?? 0) + 1;
+  p.set(e, n), n > 1 && B() && !b.has(e) && (console.warn(`[legend] Duplicate <Legend.Provider id="${e}"> detected. Multiple providers sharing an id will race on prop sync. Use unique ids per legend panel.`), b.add(e));
+}
+function te(e, r) {
+  const n = (p.get(e) ?? 1) - 1;
+  n <= 0 ? (p.delete(e), r.keepAlive || g.delete(e)) : p.set(e, n);
+}
+function ne(e, r) {
+  const n = G(2);
+  let s;
+  return n[0] !== e ? (s = C(e), n[0] = e, n[1] = s) : s = n[1], k(s, r);
+}
+function le(e, r) {
+  const n = G(2);
+  let s;
+  return n[0] !== e ? (s = C(e), n[0] = e, n[1] = s) : s = n[1], k(s, x(r));
+}
+const S = (e, r) => e.order - r.order;
+function ce(e) {
+  return Object.values(e.groups).sort(S);
+}
+function ue(e, r) {
+  return Object.values(e.layers).filter((n) => n.groupId === r).sort(S);
+}
+function ae(e) {
+  return Object.values(e.layers).sort(S);
+}
+function ie(e, r) {
+  let n = !1, s = !1;
+  for (const o of Object.values(e.layers))
+    o.groupId === r && (o.visible ? n = !0 : s = !0);
+  return n && s ? "mixed" : s ? "hidden" : "visible";
+}
+export {
+  $ as L,
+  Y as a,
+  ue as b,
+  re as c,
+  ee as d,
+  ce as e,
+  ae as f,
+  C as g,
+  Z as h,
+  oe as i,
+  X as j,
+  le as k,
+  ne as l,
+  se as r,
+  ie as s,
+  te as u
+};
+//# sourceMappingURL=selectors-DwHj6mE2.js.map

package/dist/selectors-DwHj6mE2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors-DwHj6mE2.js","sources":["../src/legend/stores/legend-context.ts","../src/legend/stores/legend-store-registry.ts","../src/legend/stores/selectors.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 { 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'\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\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        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        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","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 * 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 Object.values(state.layers)) {\n    if (layer.groupId !== groupId) continue\n    if (layer.visible) anyVisible = true\n    else anyHidden = true\n  }\n  if (anyVisible && anyHidden) return 'mixed'\n  return anyHidden ? 'hidden' : 'visible'\n}\n"],"names":["LegendContext","createContext","useLegendId","id","useContext","Error","legendStores","Map","legendMountCounts","warnedDuplicates","Set","isDev","import","clamp01","n","Math","min","max","visibilityPatch","entity","visible","collapsed","collapsedBeforeHide","undefined","collapsePatch","updateLayer","state","patch","layer","layers","updateGroup","group","groups","mergeSections","prev","next","merged","map","section","prevSection","find","p","active","options","includes","length","every","m","i","title","shallowEqualEntity","a","b","keys","Object","key","is","normalizeOrders","entries","bucketOf","buckets","entry","bucket","get","push","set","values","sort","order","index","forEach","mergeLayerEntity","input","fallbackOrder","opacity","sections","mergeGroupEntity","syncState","layerInputs","groupInputs","layerEntries","l","groupId","groupEntries","layersChanged","groupsChanged","rebuildRecord","e","changed","out","before","upsertLayerState","siblingCount","filter","removeLayerState","upsertGroupState","count","g","removeGroupState","nextGroups","members","nextLayers","member","createLegendStore","init","seeded","createStore","devtools","setVisibility","lid","s","setOpacity","setCollapsed","setSectionValue","sectionId","value","x","setGroupVisibility","gid","anyVisible","some","groupPatch","setGroupCollapsed","hidden","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","byOrder","selectOrderedGroups","selectLayersByGroup","selectOrderedLayers","selectGroupVisibility","anyHidden"],"mappings":"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"}

package/dist/types/components/index.d.ts

@@ -18,5 +18,6 @@ export { BasemapsUI } from './basemaps/basemaps';
 export type { BasemapsUIProps } from './basemaps/types';
 export { Tooltip, setTooltipEnterDelay } from './tooltip/tooltip';
 export { SmartTooltip } from './smart-tooltip/smart-tooltip';
+export { ResponsiveDrawer } from './responsive-drawer/responsive-drawer';
 export type { CopyButtonProps } from './copy-button/types';
 export { CopyButton } from './copy-button/copy-button';

package/dist/types/components/responsive-drawer/responsive-drawer.d.ts

@@ -1,12 +1,44 @@
-import { PopoverProps } from '@mui/material';
+import { PopoverOrigin, PopoverProps } from '@mui/material';
 import { ReactNode } from 'react';
+type ResponsiveDrawerPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+/** Placement of the panel relative to its anchor (desktop popover only). */
+export type ResponsiveDrawerPlacement = 'side' | 'overlay';
+/**
+ * Resolve the Popover anchor/transform origins for a given corner + placement.
+ *
+ * `transformOrigin` (the panel corner that pins to the anchor point) is the same
+ * for both placements: the panel's own corner matching `position`. `anchorOrigin`
+ * (the point on the anchor the panel pins to) differs:
+ * - `'side'` flips horizontally → the panel opens beside the trigger.
+ * - `'overlay'` uses the same corner → the panel sits **on top of** the anchor
+ *   (e.g. a trigger that's hidden while the panel is open), pinned corner-to-corner.
+ */
+export declare function resolveOrigins(position: ResponsiveDrawerPosition, placement: ResponsiveDrawerPlacement): {
+    anchorOrigin: PopoverOrigin;
+    transformOrigin: PopoverOrigin;
+};
 export declare function ResponsiveDrawer<T extends {
     collapsed: boolean;
     onChangeCollapsed: (collapsed: boolean) => void;
-    position: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    position: ResponsiveDrawerPosition;
     slotProps?: PopoverProps['slotProps'];
-}>({ ref, children, collapsed, isMobile, position, sx, slotProps, onChangeCollapsed, }: Required<Pick<T, 'collapsed' | 'onChangeCollapsed' | 'position'>> & Pick<PopoverProps, 'slotProps' | 'sx'> & {
+}>({ ref, children, collapsed, isMobile, position, sx, slotProps, onChangeCollapsed, modal, placement, }: Required<Pick<T, 'collapsed' | 'onChangeCollapsed' | 'position'>> & Pick<PopoverProps, 'slotProps' | 'sx'> & {
     ref: HTMLElement | null;
     isMobile: boolean;
     children: ReactNode;
+    /**
+     * When `false`, the desktop popover is **non-modal**: no backdrop, clicks
+     * pass through to the content behind it (e.g. a map stays interactive), no
+     * focus trap, and neither backdrop-click nor Escape closes it (close it via
+     * `onChangeCollapsed`). Defaults to `true` (standard dismissable popover).
+     * Desktop-only — the mobile drawer is unaffected.
+     */
+    modal?: boolean;
+    /**
+     * Desktop popover placement relative to the anchor: `'side'` (default) opens
+     * beside the trigger; `'overlay'` pins corner-to-corner, sitting on top of
+     * the anchor (e.g. a trigger hidden while the panel is open). Desktop-only.
+     */
+    placement?: ResponsiveDrawerPlacement;
 }): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/legend/components/contexts.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Per-row composition context provided by `Legend.Row`. Actions placed inside
+ * the row resolve their target layer from here instead of taking a `layerId`
+ * prop, and the opacity compound shares its popover state through it (the
+ * popover anchors to the row's sticky header element to span its full width).
+ */
+export interface LegendRowContextValue {
+    layerId: string;
+    /** The row's sticky header element — anchor for `Legend.Opacity.Popover`. */
+    headerEl: HTMLElement | null;
+    opacityOpen: boolean;
+    setOpacityOpen: (open: boolean) => void;
+}
+export declare const LegendRowContext: import('react').Context<LegendRowContextValue | null>;
+/** Nearest `Legend.Row` composition context, or `null` outside a row. */
+export declare function useLegendRow(): LegendRowContextValue | null;
+/** Per-group composition context provided by `Legend.Group` (the group id). */
+export declare const LegendGroupContext: import('react').Context<string | null>;
+/** Nearest `Legend.Group` id, or `null` outside a group. */
+export declare function useLegendGroupId(): string | null;

package/dist/types/legend/components/icons.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Indeterminate visibility — an outlined eye with an internal slash, shown on
+ * a group whose member layers are partially hidden ("mixed" state). Path data
+ * exported from the Figma source (`MUI_visibility_indeterminate`, CARTO PS Lib
+ * Documentation node 5877-16982); the glyph is centered at (184, 24) in the
+ * header frame and drawn on a 18px grid (75% of the 24px box), so it is
+ * re-centered into the standard viewBox and scaled by 4/3 — the resulting
+ * 22×15-unit eye matches the MUI `Visibility*` icons exactly.
+ */
+export declare const VisibilityIndeterminateIcon: import('../../../node_modules/@mui/material/OverridableComponent').OverridableComponent<import('node_modules/@mui/material').SvgIconTypeMap<{}, "svg">> & {
+    muiName: string;
+};

package/dist/types/legend/components/index.d.ts

@@ -0,0 +1,26 @@
+export { LegendGroup } from './legend-group/legend-group';
+export type { LegendGroupProps } from './legend-group/legend-group';
+export { LegendRow } from './legend-row/legend-row';
+export type { LegendRowProps } from './legend-row/legend-row';
+export { LegendActions } from './legend-actions/legend-actions';
+export type { LegendActionsProps } from './legend-actions/legend-actions';
+export { LegendRowContext, LegendGroupContext, useLegendRow, useLegendGroupId, } from './contexts';
+export type { LegendRowContextValue } from './contexts';
+export { LegendVisibilityToggle } from './legend-visibility-toggle/legend-visibility-toggle';
+export { LegendRowMenu } from './legend-row-menu/legend-row-menu';
+export { LegendZoomTo } from './legend-row-menu/legend-zoom-to';
+export { LegendOpacity } from './legend-opacity/legend-opacity';
+export { LegendConfigSelect } from './legend-config-select/legend-config-select';
+export { LegendItem } from './legend-item/legend-item';
+export { LegendItemUI } from './legend-item/legend-item-ui';
+export type { LegendItemUIProps } from './legend-item/legend-item-ui';
+export { LegendSwatch, DEFAULT_SWATCH_SIZE, } from './legend-swatch/legend-swatch';
+export type { LegendSwatchProps } from './legend-swatch/legend-swatch';
+export { LegendCategoryUI } from './legend-category/legend-category-ui';
+export type { LegendCategoryUIProps } from './legend-category/legend-category-ui';
+export { LegendRampUI } from './legend-ramp/legend-ramp-ui';
+export type { LegendRampUIProps } from './legend-ramp/legend-ramp-ui';
+export { LegendProportionUI } from './legend-proportion/legend-proportion-ui';
+export type { LegendProportionUIProps } from './legend-proportion/legend-proportion-ui';
+export { LegendIconUI } from './legend-icon/legend-icon-ui';
+export type { LegendIconUIProps } from './legend-icon/legend-icon-ui';

package/dist/types/legend/components/legend-actions/legend-actions.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+export interface LegendActionsProps {
+    children?: ReactNode;
+}
+/**
+ * Header actions slot for `Legend.Row` / `Legend.Group` (widgets-v2 `Actions`
+ * parity): the wrapper partitions its children by component identity and
+ * renders this slot inside the header, next to the collapse chevron, wrapped
+ * in the hover-fade group (`PsLegend-rowFade` in rows, `PsLegend-groupFade`
+ * in group headers — resolved from the nearest context).
+ *
+ * @experimental This API is new and may change in a future release.
+ */
+export declare function LegendActions({ children }: LegendActionsProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Splits a wrapper's children by component identity: `<Legend.Actions>`
+ * elements belong in the header, everything else in the collapsible body.
+ * Identity comparison works because consumers import the slot from the same
+ * module (same pattern as widgets-v2 `Wrapper`).
+ */
+export declare function partitionLegendChildren(children: ReactNode): {
+    actions: ReactNode[];
+    body: ReactNode[];
+};

package/dist/types/legend/components/legend-actions/styles.d.ts

@@ -0,0 +1,7 @@
+export declare const styles: {
+    fadeGroup: {
+        display: "flex";
+        alignItems: "center";
+        gap: number;
+    };
+};

package/dist/types/legend/components/legend-category/legend-category-ui.d.ts

@@ -0,0 +1,13 @@
+import { LegendCategoryVariable } from '../../stores';
+export interface LegendCategoryUIProps {
+    data: LegendCategoryVariable;
+}
+/**
+ * Categorical legend — a list of swatches with labels (and optional trailing
+ * values, compact-formatted). The variable-level shape / fill pattern /
+ * stroke style / `isStrokeColor` act as defaults; each item may override any
+ * of them, so one list can mix patterns (or shapes) across entries.
+ *
+ * @experimental This API is new and may change in a future release.
+ */
+export declare function LegendCategoryUI({ data }: LegendCategoryUIProps): import("react/jsx-runtime").JSX.Element;