@carto/ps-react-ui 5.0.0-widgets.9 → 5.0.0

package/dist/spread-Ccpg9fi0.js

@@ -0,0 +1,149 @@
+import { C as e, T as t } from "./stores-tiFePP0A.js";
+import { n, t as r } from "./download-DdaK3qgC.js";
+import { a as i, c as a, l as o, o as s, s as c, u as l } from "./formula-noJzQwKo.js";
+import { c as u } from "react/compiler-runtime";
+import { Box as d, Skeleton as f } from "@mui/material";
+import { jsx as p, jsxs as m } from "react/jsx-runtime";
+//#region src/widgets-v2/spread/separator.tsx
+function h() {
+	let e = u(1), t;
+	return e[0] === Symbol.for("react.memo_cache_sentinel") ? (t = /* @__PURE__ */ p(s, {
+		color: "inherit",
+		children: "-"
+	}), e[0] = t) : t = e[0], t;
+}
+//#endregion
+//#region src/widgets-v2/spread/spread-ui.tsx
+function g(e) {
+	let t = u(8), { items: n, formatter: r, ref: f } = e, g = r ?? _, v;
+	if (t[0] !== g || t[1] !== n) {
+		let e;
+		t[3] === g ? e = t[4] : (e = (e, t) => /* @__PURE__ */ m(d, {
+			sx: i.row,
+			children: [e.series ? /* @__PURE__ */ p(a, {
+				name: e.series.name,
+				color: e.series.color
+			}) : null, /* @__PURE__ */ m(d, {
+				sx: i.body,
+				children: [/* @__PURE__ */ m(d, {
+					sx: i.valueRow,
+					children: [
+						e.prefix ? /* @__PURE__ */ p(o, { children: e.prefix }) : null,
+						/* @__PURE__ */ p(s, {
+							color: e.color,
+							children: g(e.min)
+						}),
+						/* @__PURE__ */ p(h, {}),
+						/* @__PURE__ */ p(s, {
+							color: e.color,
+							children: g(e.max)
+						}),
+						e.suffix ? /* @__PURE__ */ p(c, { children: e.suffix }) : null
+					]
+				}), e.note ? /* @__PURE__ */ p(l, { children: e.note }) : null]
+			})]
+		}, `spread-${e.series?.name ?? ""}-${e.min}-${e.max}-${t}`), t[3] = g, t[4] = e), v = n.map(e), t[0] = g, t[1] = n, t[2] = v;
+	} else v = t[2];
+	let y;
+	return t[5] !== f || t[6] !== v ? (y = /* @__PURE__ */ p(d, {
+		ref: f,
+		sx: i.root,
+		children: v
+	}), t[5] = f, t[6] = v, t[7] = y) : y = t[7], y;
+}
+function _(e) {
+	return String(e);
+}
+//#endregion
+//#region src/widgets-v2/spread/spread.tsx
+var v = Object.freeze([]), y = (e) => ({
+	data: e.data ?? v,
+	formatter: e.formatter
+});
+function b() {
+	let n = u(3), r = t(), i = e(r, y), a;
+	return n[0] !== i.data || n[1] !== i.formatter ? (a = /* @__PURE__ */ p(g, {
+		items: i.data,
+		formatter: i.formatter
+	}), n[0] = i.data, n[1] = i.formatter, n[2] = a) : a = n[2], a;
+}
+//#endregion
+//#region src/widgets-v2/spread/skeleton.tsx
+var x = {
+	root: {
+		display: "flex",
+		flexDirection: "column",
+		gap: 2,
+		py: 1
+	},
+	row: {
+		display: "flex",
+		alignItems: "center",
+		gap: 1.5
+	},
+	block: {
+		width: 200,
+		height: 32
+	}
+};
+function S(e) {
+	let t = u(2), { count: n } = e, r = n === void 0 ? 1 : n, i;
+	return t[0] === r ? i = t[1] : (i = /* @__PURE__ */ p(d, {
+		sx: x.root,
+		children: Array.from({ length: r }).map(C)
+	}), t[0] = r, t[1] = i), i;
+}
+function C(e, t) {
+	return /* @__PURE__ */ p(d, {
+		sx: x.row,
+		children: /* @__PURE__ */ p(f, {
+			variant: "rectangular",
+			sx: x.block
+		})
+	}, `row-${t}`);
+}
+//#endregion
+//#region src/widgets-v2/spread/download.ts
+function w(e) {
+	let t = [];
+	return e.getCaptureEl && t.push(n({
+		filename: e.filename,
+		getCaptureEl: e.getCaptureEl,
+		pixelRatio: e.pngPixelRatio,
+		backgroundColor: e.pngBackgroundColor
+	})), t.push(r({
+		filename: e.filename,
+		getRows: () => {
+			let t = e.getData(), n = [[
+				"series",
+				"prefix",
+				"min",
+				"max",
+				"suffix",
+				"note"
+			]];
+			for (let e of t) n.push([
+				e.series?.name ?? "",
+				e.prefix ?? "",
+				e.min,
+				e.max,
+				e.suffix ?? "",
+				e.note ?? ""
+			]);
+			return n;
+		}
+	})), t;
+}
+//#endregion
+//#region src/widgets-v2/spread/band.ts
+function T({ value: e, spread: t, variant: n = "percentage" }) {
+	let r = n === "absolute" ? t : t / 100 * e, i = Math.abs(r);
+	return {
+		min: e - i,
+		max: e + i
+	};
+}
+//#endregion
+export { g as a, b as i, w as n, h as o, S as r, T as t };
+
+//# sourceMappingURL=spread-Ccpg9fi0.js.map

package/dist/spread-Ccpg9fi0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spread-Ccpg9fi0.js","names":["<Value color='inherit'>-</Value>","{ items, formatter, ref }: SpreadUIProps","(n: number) => String(n)","items.map((item, i) => (\n        // Composite of series name + min/max bounds for stability across\n        // reorders; falls back to the index when bounds happen to collide.\n        <Box\n          key={`spread-${item.series?.name ?? ''}-${item.min}-${item.max}-${i}`}\n          sx={styles.row}\n        >\n          {item.series ? (\n            <Series name={item.series.name} color={item.series.color} />\n          ) : null}\n          <Box sx={styles.body}>\n            <Box sx={styles.valueRow}>\n              {item.prefix ? <Prefix>{item.prefix}</Prefix> : null}\n              <Value color={item.color}>{fmt(item.min)}</Value>\n              <Separator />\n              <Value color={item.color}>{fmt(item.max)}</Value>\n              {item.suffix ? <Suffix>{item.suffix}</Suffix> : null}\n            </Box>\n            {item.note ? <Note>{item.note}</Note> : null}\n          </Box>\n        </Box>\n      ))","(item, i) => (\n        // Composite of series name + min/max bounds for stability across\n        // reorders; falls back to the index when bounds happen to collide.\n        <Box\n          key={`spread-${item.series?.name ?? ''}-${item.min}-${item.max}-${i}`}\n          sx={styles.row}\n        >\n          {item.series ? (\n            <Series name={item.series.name} color={item.series.color} />\n          ) : null}\n          <Box sx={styles.body}>\n            <Box sx={styles.valueRow}>\n              {item.prefix ? <Prefix>{item.prefix}</Prefix> : null}\n              <Value color={item.color}>{fmt(item.min)}</Value>\n              <Separator />\n              <Value color={item.color}>{fmt(item.max)}</Value>\n              {item.suffix ? <Suffix>{item.suffix}</Suffix> : null}\n            </Box>\n            {item.note ? <Note>{item.note}</Note> : null}\n          </Box>\n        </Box>\n      )","<Box ref={ref} sx={styles.root}>\n      {items.map((item, i) => (\n        // Composite of series name + min/max bounds for stability across\n        // reorders; falls back to the index when bounds happen to collide.\n        <Box\n          key={`spread-${item.series?.name ?? ''}-${item.min}-${item.max}-${i}`}\n          sx={styles.row}\n        >\n          {item.series ? (\n            <Series name={item.series.name} color={item.series.color} />\n          ) : null}\n          <Box sx={styles.body}>\n            <Box sx={styles.valueRow}>\n              {item.prefix ? <Prefix>{item.prefix}</Prefix> : null}\n              <Value color={item.color}>{fmt(item.min)}</Value>\n              <Separator />\n              <Value color={item.color}>{fmt(item.max)}</Value>\n              {item.suffix ? <Suffix>{item.suffix}</Suffix> : null}\n            </Box>\n            {item.note ? <Note>{item.note}</Note> : null}\n          </Box>\n        </Box>\n      ))}\n    </Box>","<SpreadUI items={slice.data} formatter={slice.formatter} />","data","formatter","{ count = 1 }: SpreadSkeletonProps","count = 1","<Box sx={styles.root}>\n      {Array.from({ length: count }).map((_, i) => (\n        <Box key={`row-${i}`} sx={styles.row}>\n          <Skeleton variant='rectangular' sx={styles.block} />\n        </Box>\n      ))}\n    </Box>","(_, i) => (\n        <Box key={`row-${i}`} sx={styles.row}>\n          <Skeleton variant='rectangular' sx={styles.block} />\n        </Box>\n      )"],"sources":["../src/widgets-v2/spread/separator.tsx","../src/widgets-v2/spread/spread-ui.tsx","../src/widgets-v2/spread/spread.tsx","../src/widgets-v2/spread/skeleton.tsx","../src/widgets-v2/spread/download.ts","../src/widgets-v2/spread/band.ts"],"sourcesContent":["import { Value } from '../formula'\n\n/**\n * Em-dash separator placed between a Spread row's `min` and `max` values.\n * Built from the Formula {@link Value} primitive so typography (h5/600,\n * baseline alignment) matches the numbers around it. Renders with\n * `text.secondary` so it visually recedes between the two bounds.\n */\nexport function Separator() {\n  return <Value color='inherit'>-</Value>\n}\n","import { Box } from '@mui/material'\nimport type { Ref } from 'react'\nimport { Note, Prefix, Series, Suffix, Value } from '../formula'\nimport { styles } from '../formula/style'\nimport { Separator } from './separator'\nimport type { SpreadDataItem } from './types'\n\nexport interface SpreadUIProps {\n  items: readonly SpreadDataItem[]\n  /** Number formatter — applied to each item's `min` and `max`. */\n  formatter?: (value: number) => string\n  /** Forwarded to the root `<Box>` so consumers can capture the DOM (PNG export). */\n  ref?: Ref<HTMLDivElement>\n}\n\n/**\n * Pure presentational component for the Spread widget. Each item renders as\n * a row containing (in order): optional `Series` avatar, a body with\n * `[prefix] min — max [suffix]` plus optional `Note`. Reuses the Formula\n * primitives ({@link Series}, {@link Prefix}, {@link Value}, {@link Suffix},\n * {@link Note}) and the Formula row styles so Spread and Formula stay\n * visually aligned when used together.\n */\nexport function SpreadUI({ items, formatter, ref }: SpreadUIProps) {\n  const fmt = formatter ?? ((n: number) => String(n))\n  return (\n    <Box ref={ref} sx={styles.root}>\n      {items.map((item, i) => (\n        // Composite of series name + min/max bounds for stability across\n        // reorders; falls back to the index when bounds happen to collide.\n        <Box\n          key={`spread-${item.series?.name ?? ''}-${item.min}-${item.max}-${i}`}\n          sx={styles.row}\n        >\n          {item.series ? (\n            <Series name={item.series.name} color={item.series.color} />\n          ) : null}\n          <Box sx={styles.body}>\n            <Box sx={styles.valueRow}>\n              {item.prefix ? <Prefix>{item.prefix}</Prefix> : null}\n              <Value color={item.color}>{fmt(item.min)}</Value>\n              <Separator />\n              <Value color={item.color}>{fmt(item.max)}</Value>\n              {item.suffix ? <Suffix>{item.suffix}</Suffix> : null}\n            </Box>\n            {item.note ? <Note>{item.note}</Note> : null}\n          </Box>\n        </Box>\n      ))}\n    </Box>\n  )\n}\n","import { useWidgetId, useWidgetShallow } from '../stores'\nimport { SpreadUI } from './spread-ui'\nimport type { SpreadWidgetData } from './types'\n\ninterface SpreadSlice {\n  data: SpreadWidgetData\n  formatter?: (value: number) => string\n}\n\n// Stable empty-data sentinel — keeps the slice's `data` reference stable\n// when the underlying store value is null/undefined so the shallow-equality\n// gate in `useWidgetShallow` doesn't re-render every commit.\nconst EMPTY_DATA: SpreadWidgetData = Object.freeze([]) as SpreadWidgetData\n\nconst spreadSelector = (s: {\n  data: unknown\n  formatter?: (value: number) => string\n}): SpreadSlice => ({\n  data: (s.data ?? EMPTY_DATA) as SpreadWidgetData,\n  formatter: s.formatter,\n})\n\n/**\n * Stateful Spread bridge — reads `data` (post-pipeline) and `formatter` from\n * the per-widget store and forwards them to the pure {@link SpreadUI}.\n */\nexport function Spread() {\n  const id = useWidgetId()\n  const slice = useWidgetShallow(id, spreadSelector)\n  return <SpreadUI items={slice.data} formatter={slice.formatter} />\n}\n","import { Box, Skeleton } from '@mui/material'\nimport type { SxProps, Theme } from '@mui/material'\n\nconst styles = {\n  root: {\n    display: 'flex',\n    flexDirection: 'column',\n    gap: 2,\n    py: 1,\n  },\n  row: {\n    display: 'flex',\n    alignItems: 'center',\n    gap: 1.5,\n  },\n  block: { width: 200, height: 32 },\n} satisfies Record<string, SxProps<Theme>>\n\nexport interface SpreadSkeletonProps {\n  count?: number\n}\n\n/**\n * Loading placeholder for the Spread widget. Renders `count` rows, each\n * sized for the `min — max` pair so the layout doesn't jump once data\n * resolves. Mirrors the row-per-item structure of {@link SpreadUI}.\n */\nexport function SpreadSkeleton({ count = 1 }: SpreadSkeletonProps) {\n  return (\n    <Box sx={styles.root}>\n      {Array.from({ length: count }).map((_, i) => (\n        <Box key={`row-${i}`} sx={styles.row}>\n          <Skeleton variant='rectangular' sx={styles.block} />\n        </Box>\n      ))}\n    </Box>\n  )\n}\n","import {\n  buildCsvDownloadItem,\n  buildPngDownloadItem,\n  type DownloadItem,\n} from '../actions/download'\nimport type { SpreadWidgetData } from './types'\n\n/**\n * Download menu items for the Spread widget. Always includes a CSV item\n * with `series, prefix, min, max, suffix, note` columns (one row per\n * entry). When `getCaptureEl` is supplied, prepends a PNG item that\n * rasterises the captured element via `html2canvas`.\n */\nexport function createSpreadDownloadConfig(args: {\n  filename: string\n  getData: () => SpreadWidgetData\n  getCaptureEl?: () => HTMLElement | null\n  pngPixelRatio?: number\n  pngBackgroundColor?: string | null\n}): DownloadItem[] {\n  const items: DownloadItem[] = []\n  if (args.getCaptureEl) {\n    items.push(\n      buildPngDownloadItem({\n        filename: args.filename,\n        getCaptureEl: args.getCaptureEl,\n        pixelRatio: args.pngPixelRatio,\n        backgroundColor: args.pngBackgroundColor,\n      }),\n    )\n  }\n  items.push(\n    buildCsvDownloadItem({\n      filename: args.filename,\n      getRows: () => {\n        const data = args.getData()\n        const rows: unknown[][] = [\n          ['series', 'prefix', 'min', 'max', 'suffix', 'note'],\n        ]\n        for (const item of data) {\n          rows.push([\n            item.series?.name ?? '',\n            item.prefix ?? '',\n            item.min,\n            item.max,\n            item.suffix ?? '',\n            item.note ?? '',\n          ])\n        }\n        return rows\n      },\n    }),\n  )\n  return items\n}\n","/**\n * How a `spread` amount is applied to a centre value.\n *\n * - `percentage` — `spread` is a whole-number percentage of the centre\n *   value, so `5` means +/-5%.\n * - `absolute` — `spread` is a raw offset in the value's own units.\n */\nexport type SpreadVariant = 'percentage' | 'absolute'\n\nexport interface GetSpreadBandOptions {\n  /** The centre value the band is drawn around. */\n  value: number\n  /** Half-width of the band, read according to `variant`. */\n  spread: number\n  /** Defaults to `percentage`. */\n  variant?: SpreadVariant\n}\n\n/**\n * Derives the `min` / `max` band around a centre value, for feeding a\n * {@link SpreadDataItem} from a single aggregated number (a prediction, a\n * target) plus a tolerance — rather than from a real column range.\n *\n * `spread` is read as a percentage by default, which is what a tolerance\n * almost always is: an absolute offset is meaningless without knowing the\n * value's magnitude, and gets visually lost on large values (+/-5 on a\n * prediction of 204,113 renders as a range indistinguishable from a single\n * number).\n *\n * @example\n * getSpreadBand({ value: 1000, spread: 5 })\n * // -> { min: 950, max: 1050 }\n * getSpreadBand({ value: 1000, spread: 5, variant: 'absolute' })\n * // -> { min: 995, max: 1005 }\n */\nexport function getSpreadBand({\n  value,\n  spread,\n  variant = 'percentage',\n}: GetSpreadBandOptions): { min: number; max: number } {\n  const offset = variant === 'absolute' ? spread : (spread / 100) * value\n  // Keep `min <= max`: a percentage of a negative centre value (or a negative\n  // `spread`) yields a negative offset, which would invert the band.\n  const width = Math.abs(offset)\n\n  return { min: value - width, max: value + width }\n}\n"],"mappings":"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"}

package/dist/stores-mad-9yFn.js

@@ -0,0 +1,369 @@
+import { c as e } from "react/compiler-runtime";
+import { createContext as t, isValidElement as n, useContext as r } from "react";
+import { isDev as i } from "@carto/ps-utils";
+import { useStore as a } from "zustand";
+import { createStore as o } from "zustand/vanilla";
+import { devtools as s } from "zustand/middleware";
+import { useShallow as c } from "zustand/react/shallow";
+//#region src/legend/stores/legend-context.ts
+var l = t(null);
+function u() {
+	let e = r(l);
+	if (e == null) throw 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;
+}
+//#endregion
+//#region src/legend/stores/selectors.ts
+var d = (e, t) => e.order - t.order;
+function f(e) {
+	return Object.values(e.groups).sort(d);
+}
+function p(e, t) {
+	return Object.values(e.layers).filter((e) => e.groupId === t).sort(d);
+}
+function m(e) {
+	return Object.values(e.layers).sort(d);
+}
+function h(e) {
+	let t = Object.values(e.groups);
+	return t.length > 0 && t.every((e) => e.collapsed);
+}
+function g(e) {
+	return Object.keys(e.groups).length > 0;
+}
+function _(e) {
+	let t = (t) => p(e, t).filter((e) => e.visible), n = [];
+	for (let r of f(e)) {
+		let e = t(r.id);
+		e.length > 0 && n.push({
+			group: r,
+			layers: e
+		});
+	}
+	let r = t(void 0);
+	return r.length > 0 && n.push({ layers: r }), n;
+}
+function v(e, t) {
+	let n = e.layers[t];
+	return n ? n.variables.length > 0 || (n.sections?.length ?? 0) > 0 || !!n.helperText : !1;
+}
+function y(e, t) {
+	let n = !1, r = !1;
+	for (let i of p(e, t)) i.visible ? n = !0 : r = !0;
+	return n && r ? "mixed" : r ? "hidden" : "visible";
+}
+//#endregion
+//#region src/legend/stores/legend-store-registry.ts
+var b = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ new Set(), C = (e) => Math.min(1, Math.max(0, e));
+function w(e, t) {
+	return e.visible === t ? null : t ? {
+		visible: t,
+		collapsed: e.collapsedBeforeHide ?? !1,
+		collapsedBeforeHide: void 0
+	} : {
+		visible: t,
+		collapsed: !0,
+		collapsedBeforeHide: e.collapsed
+	};
+}
+function T(e, t) {
+	return e.visible ? { collapsed: t } : {
+		collapsed: t,
+		collapsedBeforeHide: t
+	};
+}
+function E(e, t, n) {
+	let r = e.findIndex((e) => e.id === t);
+	if (r === -1) return null;
+	let i = Math.max(0, Math.min(e.length - 1, n));
+	if (i === r) return null;
+	let a = [...e], [o] = a.splice(r, 1);
+	a.splice(i, 0, o);
+	let s = /* @__PURE__ */ new Map();
+	return a.forEach((e, t) => {
+		e.order !== t && s.set(e.id, t);
+	}), s.size > 0 ? s : null;
+}
+function D(e, t, n) {
+	let r = e.layers[t];
+	return r ? { layers: {
+		...e.layers,
+		[t]: {
+			...r,
+			...n
+		}
+	} } : {};
+}
+function O(e, t, n) {
+	let r = e.groups[t];
+	return r ? { groups: {
+		...e.groups,
+		[t]: {
+			...r,
+			...n
+		}
+	} } : {};
+}
+function k(e, t) {
+	if (!t || !e || e === t) return t;
+	let n = t.map((t) => {
+		let n = e.find((e) => e.id === t.id);
+		return n && n.active !== t.active && t.options.includes(n.active) ? {
+			...t,
+			active: n.active
+		} : t;
+	});
+	return e.length === n.length && n.every((t, n) => {
+		let r = e[n];
+		return r.id === t.id && r.title === t.title && r.options === t.options && r.active === t.active;
+	}) ? e : n;
+}
+function A(e, t) {
+	return !n(e) || !n(t) || e.type !== t.type || e.key !== t.key ? !1 : j(e.props, t.props);
+}
+function j(e, t) {
+	let n = /* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(t)]);
+	for (let r of n) if (!Object.is(e[r], t[r]) && !A(e[r], t[r])) return !1;
+	return !0;
+}
+function M(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let r of e) {
+		let e = t(r.merged), i = n.get(e);
+		i ? i.push(r) : n.set(e, [r]);
+	}
+	for (let e of n.values()) e.sort((e, t) => e.merged.order - t.merged.order || e.index - t.index).forEach((e, t) => {
+		e.merged.order = t;
+	});
+}
+function N(e, t, n) {
+	return {
+		...t,
+		visible: e?.visible ?? t.visible ?? !0,
+		opacity: e?.opacity ?? t.opacity ?? 1,
+		collapsed: e?.collapsed ?? t.collapsed ?? !1,
+		collapsedBeforeHide: e?.collapsedBeforeHide,
+		sections: k(e?.sections, t.sections),
+		order: e?.order ?? t.order ?? n
+	};
+}
+function P(e, t, n, r) {
+	return {
+		...t,
+		collapsed: e?.collapsed ?? t.collapsed ?? !r,
+		collapsedBeforeHide: e?.collapsedBeforeHide,
+		order: e?.order ?? t.order ?? n
+	};
+}
+function F(e, t, n) {
+	let r = t.map((t, n) => ({
+		index: n,
+		merged: N(e.layers[t.id], t, n)
+	}));
+	M(r, (e) => e.groupId);
+	let i = new Set(r.filter(({ merged: e }) => e.visible && e.groupId != null).map(({ merged: e }) => e.groupId)), a = n.map((t, n) => ({
+		index: n,
+		merged: P(e.groups[t.id], t, n, i.has(t.id))
+	}));
+	M(a, () => void 0);
+	let o = r.length !== Object.keys(e.layers).length, s = {};
+	for (let { merged: t } of r) {
+		let n = e.layers[t.id];
+		n && j(n, t) ? s[t.id] = n : (s[t.id] = t, o = !0);
+	}
+	let c = a.length !== Object.keys(e.groups).length, l = {};
+	for (let { merged: t } of a) {
+		let n = e.groups[t.id];
+		n && j(n, t) ? l[t.id] = n : (l[t.id] = t, c = !0);
+	}
+	return !o && !c ? {} : {
+		layers: o ? s : e.layers,
+		groups: c ? l : e.groups
+	};
+}
+function I(e, t, n) {
+	let r = Object.values(t).map((e, t) => ({
+		index: t,
+		merged: { ...e }
+	}));
+	M(r, n);
+	let i = r.length !== Object.keys(e).length, a = {};
+	for (let { merged: t } of r) {
+		let n = e[t.id];
+		n && j(n, t) ? a[t.id] = n : (a[t.id] = t, i = !0);
+	}
+	return i ? a : null;
+}
+function L(e, t) {
+	let n = Object.values(e.layers).filter((e) => e.groupId === t.groupId && e.id !== t.id).length, r = N(e.layers[t.id], t, n), i = I(e.layers, {
+		...e.layers,
+		[t.id]: r
+	}, (e) => e.groupId);
+	return i ? { layers: i } : {};
+}
+function R(e, t) {
+	if (!e.layers[t]) return {};
+	let n = { ...e.layers };
+	delete n[t];
+	let r = I(e.layers, n, (e) => e.groupId);
+	return r ? { layers: r } : {};
+}
+function z(e, t) {
+	let n = Object.values(e.groups).filter((e) => e.id !== t.id).length, r = P(e.groups[t.id], t, n, !0), i = I(e.groups, {
+		...e.groups,
+		[t.id]: r
+	}, () => void 0);
+	return i ? { groups: i } : {};
+}
+function B(e, t) {
+	if (!e.groups[t]) return {};
+	let n = { ...e.groups };
+	delete n[t];
+	let r = I(e.groups, n, () => void 0), i = Object.values(e.layers).filter((e) => e.groupId === t);
+	if (i.length === 0) return r ? { groups: r } : {};
+	let a = { ...e.layers };
+	for (let e of i) a[e.id] = {
+		...e,
+		groupId: void 0
+	};
+	let o = I(e.layers, a, (e) => e.groupId);
+	return {
+		...r ? { groups: r } : {},
+		...o ? { layers: o } : {}
+	};
+}
+function V(e, t = {}) {
+	let n = F({
+		layers: {},
+		groups: {}
+	}, t.layers ?? [], t.groups ?? []);
+	return o()(s((e) => ({
+		layers: n.layers ?? {},
+		groups: n.groups ?? {},
+		setVisibility: (t, n) => e((e) => {
+			let r = e.layers[t], i = r && w(r, n);
+			return i ? D(e, t, i) : {};
+		}, !1, "setVisibility"),
+		setOpacity: (t, n) => e((e) => D(e, t, { opacity: C(n) }), !1, "setOpacity"),
+		setCollapsed: (t, n) => e((e) => {
+			let r = e.layers[t];
+			return r ? D(e, t, T(r, n)) : {};
+		}, !1, "setCollapsed"),
+		setSectionValue: (t, n, r) => e((e) => {
+			let i = e.layers[t], a = i?.sections?.find((e) => e.id === n);
+			return !i?.sections || !a || a.active === r || !a.options.includes(r) ? {} : D(e, t, { sections: i.sections.map((e) => e.id === n ? {
+				...e,
+				active: r
+			} : e) });
+		}, !1, "setSectionValue"),
+		moveLayer: (t, n) => e((e) => {
+			let r = e.layers[t];
+			if (!r) return {};
+			let i = E(p(e, r.groupId), t, n);
+			if (!i) return {};
+			let a = { ...e.layers };
+			for (let [e, t] of i) a[e] = {
+				...a[e],
+				order: t
+			};
+			return { layers: a };
+		}, !1, "moveLayer"),
+		setGroupVisibility: (t, n) => e((e) => {
+			let r = e.groups[t];
+			if (!r) return {};
+			let i = Object.values(e.layers).filter((e) => e.groupId === t), a = i.some((e) => e.visible);
+			if (i.length === 0 || !n && !a) return {};
+			let o = { ...e.layers }, s = !1;
+			for (let e of i) {
+				let t = w(e, n);
+				t && (o[e.id] = {
+					...e,
+					...t
+				}, s = !0);
+			}
+			if (!s) return {};
+			let c = null;
+			return !n && a ? c = {
+				collapsed: !0,
+				collapsedBeforeHide: r.collapsed
+			} : n && !a && (c = {
+				collapsed: r.collapsedBeforeHide ?? !1,
+				collapsedBeforeHide: void 0
+			}), {
+				layers: o,
+				...c ? { groups: {
+					...e.groups,
+					[t]: {
+						...r,
+						...c
+					}
+				} } : {}
+			};
+		}, !1, "setGroupVisibility"),
+		setGroupCollapsed: (t, n) => e((e) => {
+			if (!e.groups[t]) return {};
+			let r = Object.values(e.layers).filter((e) => e.groupId === t);
+			return O(e, t, r.length > 0 && r.every((e) => !e.visible) ? {
+				collapsed: n,
+				collapsedBeforeHide: n
+			} : { collapsed: n });
+		}, !1, "setGroupCollapsed"),
+		moveGroup: (t, n) => e((e) => {
+			if (!e.groups[t]) return {};
+			let r = E(f(e), t, n);
+			if (!r) return {};
+			let i = { ...e.groups };
+			for (let [e, t] of r) i[e] = {
+				...i[e],
+				order: t
+			};
+			return { groups: i };
+		}, !1, "moveGroup"),
+		setLegendLayer: (t) => e((e) => L(e, t), !1, "setLegendLayer"),
+		removeLegendLayer: (t) => e((e) => R(e, t), !1, "removeLegendLayer"),
+		setLegendGroup: (t) => e((e) => z(e, t), !1, "setLegendGroup"),
+		removeLegendGroup: (t) => e((e) => B(e, t), !1, "removeLegendGroup"),
+		_sync: (t, n) => e((e) => F(e, t, n), !1, "_sync")
+	}), {
+		name: `legend-${e}`,
+		enabled: i()
+	}));
+}
+function H(e) {
+	let t = b.get(e);
+	if (!t) throw Error(`[legend] Legend store "${e}" not found.`);
+	return t;
+}
+function U(e) {
+	return b.has(e);
+}
+function W(e) {
+	b.delete(e);
+}
+function G() {
+	b.clear(), x.clear(), S.clear();
+}
+function K(e, t) {
+	b.set(e, t);
+}
+function q(e, t) {
+	b.set(e, t);
+	let n = (x.get(e) ?? 0) + 1;
+	x.set(e, n), n > 1 && i() && !S.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.`), S.add(e));
+}
+function J(e, t) {
+	let n = (x.get(e) ?? 1) - 1;
+	n <= 0 ? (x.delete(e), t.keepAlive || b.delete(e)) : x.set(e, n);
+}
+function Y(t, n) {
+	let r = e(2), i;
+	return r[0] === t ? i = r[1] : (i = H(t), r[0] = t, r[1] = i), a(i, n);
+}
+function X(t, n) {
+	let r = e(2), i;
+	return r[0] === t ? i = r[1] : (i = H(t), r[0] = t, r[1] = i), a(i, c(n));
+}
+//#endregion
+export { m as _, U as a, u as b, J as c, h as d, y as f, f as g, p as h, H as i, X as l, v as m, V as n, q as o, g as p, W as r, K as s, G as t, Y as u, _ as v, l as y };
+
+//# sourceMappingURL=stores-mad-9yFn.js.map

package/dist/stores-mad-9yFn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores-mad-9yFn.js","names":["getLegendStore(id)"],"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 { isDev } from '@carto/ps-utils'\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 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/**\n * Group counterpart of {@link mergeLayerEntity}. A group with no `prev`\n * state (first sync) defaults collapsed when none of its member layers is\n * visible yet — `hasVisibleLayer` is ignored once the group exists so a\n * user's manual expand/collapse always sticks.\n *\n * Only the declarative sync passes a meaningful `hasVisibleLayer` — it sees\n * the whole batch. The imperative path passes `true`; see\n * {@link upsertGroupState}.\n */\nfunction mergeGroupEntity(\n  prev: LegendGroup | undefined,\n  input: LegendGroupInput,\n  fallbackOrder: number,\n  hasVisibleLayer: boolean,\n): LegendGroup {\n  return {\n    ...input,\n    collapsed: prev?.collapsed ?? input.collapsed ?? !hasVisibleLayer,\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 groupsWithVisibleLayer = new Set(\n    layerEntries\n      .filter(({ merged }) => merged.visible && merged.groupId != null)\n      .map(({ merged }) => merged.groupId!),\n  )\n  const groupEntries = groupInputs.map((input, index) => ({\n    index,\n    merged: mergeGroupEntity(\n      state.groups[input.id],\n      input,\n      index,\n      groupsWithVisibleLayer.has(input.id),\n    ),\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/**\n * Add or update a single group (imperative `setLegendGroup`).\n *\n * This sees one group against whatever layers happen to be registered, and\n * group-before-layer is a legitimate order — so inferring \"nothing visible\"\n * from that partial view seeded `collapsed: true`, which then won every\n * later merge through `prev?.collapsed`. Default is expanded unless the\n * input says otherwise; the visibility-based default stays in\n * {@link syncState}, which knows the full batch.\n */\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(\n    state.groups[input.id],\n    input,\n    count,\n    // Never infer collapsed from a partial view of the members.\n    true,\n  )\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"],"mappings":"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"}