@kanzo-tech/ui 0.0.1-alpha

package/dist/lib/is-active-path.js

@@ -0,0 +1,7 @@
+function t(n, l) {
+  return n != null && l != null && (n === l || n.startsWith(`${l}/`));
+}
+export {
+  t as isActivePath
+};
+//# sourceMappingURL=is-active-path.js.map

package/dist/lib/is-active-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-active-path.js","sources":["../../src/lib/is-active-path.ts"],"sourcesContent":["/**\n * Is `href` the active route, given the current path?\n *\n * A prefix match, but not `startsWith`: `/settings` is active on `/settings/cloud` and is **not**\n * active on `/settings-archive`. That boundary is the whole reason this is a function rather than\n * an expression written at each call site — it is four lines and it was wrong in two of them.\n *\n * The library ships no navigation component to apply it for you: a nav is a layout tree, so it is\n * hand-composed from `SidebarMenu*` and a router link through `asChild`. This is the one part of\n * that arrangement that is logic rather than markup, so it is the one part that is exported.\n */\nexport function isActivePath(activePath: string | undefined, href: string | undefined): boolean {\n  return (\n    activePath != null &&\n    href != null &&\n    (activePath === href || activePath.startsWith(`${href}/`))\n  );\n}\n"],"names":["isActivePath","activePath","href"],"mappings":"AAWO,SAASA,EAAaC,GAAgCC,GAAmC;AAC9F,SACED,KAAc,QACdC,KAAQ,SACPD,MAAeC,KAAQD,EAAW,WAAW,GAAGC,CAAI,GAAG;AAE5D;"}

package/dist/lib/theme-tick.d.ts

@@ -0,0 +1,37 @@
+import { RefObject } from 'react';
+/**
+ * Re-render the caller when the colours change, whichever way they changed.
+ *
+ * **Two sources, because there are two, and missing the second was a real regression.** Most of the
+ * theme reaches the page as `data-*` attributes and `.dark` on `document.documentElement`, so
+ * observing its attributes catches a mode flip, a density change and a brand swap. A **palette**
+ * changes none of them: a document is a stylesheet, so switching one replaces a `<style>` in
+ * `<head>` and every token underneath changes value with nothing on `<html>` moving at all. A
+ * MutationObserver on the root cannot see that, so a WebGL graph holding colours in buffers kept
+ * painting the palette it was mounted with.
+ *
+ * So there are three observations, and the third is the one that is easy to leave out. The provider
+ * reports the palette *preference*, which moves the moment the user clicks — but the stylesheet it
+ * selects usually arrives later, over the network. Ticking only then would re-resolve every token
+ * against the document still on the page and never look again. **`<head>` is therefore watched too**,
+ * for children and for character data, because that is where a document actually lands however a
+ * host chooses to apply it — a swapped `<style>`, a replaced `<link>`, an injected sheet.
+ *
+ * The early tick costs one wasted re-resolve and the late one is what makes the answer right. A
+ * `<head>` mutation is also how a router inserting route CSS looks, so this ticks a little more often
+ * than colour strictly changes; that is the trade, and it is the correct way round, because a false
+ * tick costs a rebuild and a missed one costs a graph painting a brand nobody selected.
+ *
+ * The provider half is optional, so a chart still works without one.
+ *
+ * Returns a counter to feed into an effect's dependency list.
+ */
+export declare function useThemeTick(): number;
+/**
+ * `categoricalCapacity` as a hook, re-read whenever the theme moves.
+ *
+ * `CHART_SLOTS` on the first render so the server and the client agree, then the measured value —
+ * the same shape {@link useThemeTick} already imposes on anything reading the cascade.
+ */
+export declare function useChartCapacity(host?: RefObject<Element | null>): number;
+//# sourceMappingURL=theme-tick.d.ts.map

package/dist/lib/theme-tick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-tick.d.ts","sourceRoot":"","sources":["../../src/lib/theme-tick.ts"],"names":[],"mappings":"AAMA,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAK5D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAwBrC;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,MAAM,CAQzE"}

package/dist/lib/theme-tick.js

@@ -0,0 +1,30 @@
+"use client";
+import { useState as a, useEffect as m } from "react";
+import { CHART_SLOTS as s } from "@kanzo-tech/theme";
+import { useKanzoThemeOptional as d } from "../theme/theme-context.js";
+import { categoricalCapacity as f } from "./token-color.js";
+function p() {
+  var r;
+  const e = ((r = d()) == null ? void 0 : r.resolvedTheme) ?? "", [n, c] = a({ tick: 0, palette: e });
+  return n.palette !== e && c((t) => ({ tick: t.tick + 1, palette: e })), m(() => {
+    if (typeof MutationObserver > "u") return;
+    const t = () => c((u) => ({ ...u, tick: u.tick + 1 })), o = new MutationObserver(t);
+    o.observe(document.documentElement, { attributes: !0 });
+    const i = new MutationObserver(t);
+    return i.observe(document.head, { childList: !0, subtree: !0, characterData: !0 }), () => {
+      o.disconnect(), i.disconnect();
+    };
+  }, []), n.tick;
+}
+function y(e) {
+  const n = p(), [c, r] = a(s);
+  return m(() => {
+    const t = (e == null ? void 0 : e.current) ?? (typeof document > "u" ? null : document.documentElement);
+    t && r(f(t));
+  }, [e, n]), c;
+}
+export {
+  y as useChartCapacity,
+  p as useThemeTick
+};
+//# sourceMappingURL=theme-tick.js.map

package/dist/lib/theme-tick.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-tick.js","sources":["../../src/lib/theme-tick.ts"],"sourcesContent":["\"use client\";\n\n// The client half of `./token-color.js`: the two hooks that re-read the live cascade. They are\n// here rather than beside the pure functions because a hook forces `\"use client\"` onto its whole\n// module, and that directive is what made `categoricalColor` unreachable from a Server Component.\n\nimport { useEffect, useState, type RefObject } from \"react\";\nimport { CHART_SLOTS } from \"@kanzo-tech/theme\";\nimport { useKanzoThemeOptional } from \"../theme/theme-context.js\";\nimport { categoricalCapacity } from \"./token-color.js\";\n\n/**\n * Re-render the caller when the colours change, whichever way they changed.\n *\n * **Two sources, because there are two, and missing the second was a real regression.** Most of the\n * theme reaches the page as `data-*` attributes and `.dark` on `document.documentElement`, so\n * observing its attributes catches a mode flip, a density change and a brand swap. A **palette**\n * changes none of them: a document is a stylesheet, so switching one replaces a `<style>` in\n * `<head>` and every token underneath changes value with nothing on `<html>` moving at all. A\n * MutationObserver on the root cannot see that, so a WebGL graph holding colours in buffers kept\n * painting the palette it was mounted with.\n *\n * So there are three observations, and the third is the one that is easy to leave out. The provider\n * reports the palette *preference*, which moves the moment the user clicks — but the stylesheet it\n * selects usually arrives later, over the network. Ticking only then would re-resolve every token\n * against the document still on the page and never look again. **`<head>` is therefore watched too**,\n * for children and for character data, because that is where a document actually lands however a\n * host chooses to apply it — a swapped `<style>`, a replaced `<link>`, an injected sheet.\n *\n * The early tick costs one wasted re-resolve and the late one is what makes the answer right. A\n * `<head>` mutation is also how a router inserting route CSS looks, so this ticks a little more often\n * than colour strictly changes; that is the trade, and it is the correct way round, because a false\n * tick costs a rebuild and a missed one costs a graph painting a brand nobody selected.\n *\n * The provider half is optional, so a chart still works without one.\n *\n * Returns a counter to feed into an effect's dependency list.\n */\nexport function useThemeTick(): number {\n  const palette = useKanzoThemeOptional()?.resolvedTheme ?? \"\";\n  const [state, setState] = useState({ tick: 0, palette });\n\n  // Adjusted during render rather than in an effect: React re-runs this component before anything\n  // commits, so a consumer never reads a tick that is one palette behind. An effect would let one\n  // frame paint with the old colours first, which on a graph is a visible flash of the wrong brand.\n  if (state.palette !== palette) setState((s) => ({ tick: s.tick + 1, palette }));\n\n  useEffect(() => {\n    if (typeof MutationObserver === \"undefined\") return;\n    const bump = () => setState((s) => ({ ...s, tick: s.tick + 1 }));\n    const root = new MutationObserver(bump);\n    root.observe(document.documentElement, { attributes: true });\n    // Not `subtree` on the root: that would fire for every DOM change in the app.\n    const head = new MutationObserver(bump);\n    head.observe(document.head, { childList: true, subtree: true, characterData: true });\n    return () => {\n      root.disconnect();\n      head.disconnect();\n    };\n  }, []);\n\n  return state.tick;\n}\n\n/**\n * `categoricalCapacity` as a hook, re-read whenever the theme moves.\n *\n * `CHART_SLOTS` on the first render so the server and the client agree, then the measured value —\n * the same shape {@link useThemeTick} already imposes on anything reading the cascade.\n */\nexport function useChartCapacity(host?: RefObject<Element | null>): number {\n  const tick = useThemeTick();\n  const [capacity, setCapacity] = useState(CHART_SLOTS);\n  useEffect(() => {\n    const element = host?.current ?? (typeof document === \"undefined\" ? null : document.documentElement);\n    if (element) setCapacity(categoricalCapacity(element));\n  }, [host, tick]);\n  return capacity;\n}\n"],"names":[],"mappings":";;;;;AAsCO;;AACL;AAMA;AAGE;AACA;AAEA;AAEA;AACA;AAEE;AACK;AACP;AAIJ;AAQO;AACL;AAEA;AACE;AACA;AAAqD;AAGzD;;;;;"}

package/dist/lib/token-color.d.ts

@@ -0,0 +1,74 @@
+import { CHART_SLOTS } from '@kanzo-tech/theme';
+/**
+ * Resolve a Kanzo colour token to a concrete, Plot-safe `rgb(...)` string.
+ *
+ * vgplot delegates every fill to Observable Plot, whose `isColor` (0.6.x) accepts named colours,
+ * hex and `rgb()`/`hsl()` — but **not** `var(--token)`, `color-mix()`, `oklch()` or `color(srgb …)`,
+ * which is exactly how Tailwind v4's default palette (and therefore our tokens) is authored/served.
+ * Hand Plot any of those and it treats the string as a data column, so the query fails.
+ *
+ * So we read the token off the live DOM through an `in srgb` `color-mix` (which pins it to sRGB)
+ * and normalise the result to `rgb(...)` via {@link toPlotColor}. The probe is appended to `host`
+ * so a scoped theme override (a `data-*` attribute on an ancestor) resolves against the same
+ * cascade the chart sits in. Read at mount and re-read on every theme change (see `useThemeTick`),
+ * so a re-theme re-colours the marks — the vgplot analogue of the way CodeEditor's `var()`-backed
+ * theme re-skins CodeMirror.
+ */
+export declare function resolveTokenColor(host: Element, token: string): string;
+/**
+ * How many categorical slots the stylesheet declares. A 9th series folds into "Other" — never
+ * cycle, or identity stops meaning anything.
+ *
+ * This file used to export the scheme's literal values too, first as eight hand-written hexes and
+ * then as the default entry of `theme-data.json`. Both were a *second* source of truth beside
+ * `--chart-*`, and that is the defect this whole colour layer exists to end: the same series was
+ * one colour through `ChartConfig` and another through a token. It is gone, not relocated. The
+ * tenant palette document owns the categorical set, `compile()` projects it onto these tokens, and
+ * a chart reads the token — one answer, which follows the mode and follows the client.
+ *
+ * The count stays a compile-time constant because a stylesheet cannot have a variable number of
+ * custom properties. How many of the slots carry a *real* category is the document's `capacity`,
+ * which can be lower: past it, `compile` writes `var(--muted-foreground)`, and a set that carries
+ * fewer categories than it has slots is saying so rather than inventing colours.
+ */
+export { CHART_SLOTS };
+/**
+ * The custom property carrying the document's `categorical.capacity`.
+ *
+ * `compile()` emits it at the head of both blocks — the one declaration in the sheet that is not a
+ * colour, because it is the one fact about the set that the colours cannot carry. A custom property
+ * and not a JS constant: the cascade is the only channel a scoped palette override travels down,
+ * and it is the same channel `--chart-*` itself arrives on. A stylesheet that declares nothing
+ * (anything older than the document, or a test fixture) falls back to `CHART_SLOTS`.
+ *
+ * Module-level only: `categoricalCapacity` is the way to read it, and an export whose whole use is
+ * to be passed straight back into the function beside it is a second way to do one thing.
+ */
+export declare const CHART_CAPACITY_PROPERTY = "--chart-capacity";
+/**
+ * How many slots name a real category, read off the live cascade.
+ *
+ * `compile()` writes `var(--muted-foreground)` into every slot past capacity, so the *colour* of a
+ * ninth series is already right without anyone knowing the number. What is not right is the
+ * **count**: a legend that draws a row per slot claims eight distinguishable kinds where a set may
+ * carry six, and any "group the tail into Other" logic folds at the wrong index. Measured over 24
+ * brand hues one every 15° at L 0.62 / C 0.15, capacity came back 6–8 (mean 7.50) with 11 of the 24
+ * under 8 — so this is the common case, not an edge one.
+ *
+ * Read against `host` rather than `<html>` for the same reason `resolveTokenColor` is: a scoped
+ * palette override on an ancestor has to win.
+ */
+export declare function categoricalCapacity(host: Element): number;
+/**
+ * The categorical colour for series index `i`, as a **token**.
+ *
+ * A token and not a literal so one answer covers both jobs: it follows the light/dark flip, and it
+ * follows whichever scheme the product selected — neither of which a baked hex can do. The chart
+ * pipeline already resolves `var(--…)` against the live element, and the DOM resolves it natively
+ * for legends and swatches.
+ *
+ * `capacity` is where the Other boundary sits. It defaults to `CHART_SLOTS` because that is the
+ * only honest answer without a DOM to read — a caller with one passes `categoricalCapacity(host)`.
+ */
+export declare function categoricalColor(i: number, other?: string, capacity?: number): string;
+//# sourceMappingURL=token-color.d.ts.map

package/dist/lib/token-color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-color.d.ts","sourceRoot":"","sources":["../../src/lib/token-color.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AA0BhD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAStE;AAED;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,WAAW,EAAE,CAAC;AAEvB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB,qBAAqB,CAAC;AAE1D;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAazD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,MAAM,EACT,KAAK,SAA4B,EACjC,QAAQ,SAAc,GACrB,MAAM,CAER"}

package/dist/lib/token-color.js

@@ -0,0 +1,35 @@
+import { CHART_SLOTS as o } from "@kanzo-tech/theme";
+import { CHART_SLOTS as h } from "@kanzo-tech/theme";
+function l(e) {
+  const t = e.match(
+    /^color\(srgb\s+([-+\d.eE]+)\s+([-+\d.eE]+)\s+([-+\d.eE]+)(?:\s*\/\s*([-+\d.eE]+))?\s*\)$/i
+  );
+  if (!t) return e;
+  const r = (a) => Math.min(255, Math.max(0, Math.round(Number(a) * 255))), [n, c, s] = [t[1], t[2], t[3]].map((a) => r(a)), i = t[4] != null ? Math.min(1, Math.max(0, Number(t[4]))) : 1;
+  return i < 1 ? `rgba(${n}, ${c}, ${s}, ${i})` : `rgb(${n}, ${c}, ${s})`;
+}
+function d(e, t) {
+  const r = document.createElement("span");
+  r.style.color = `color-mix(in srgb, var(${t}) 100%, transparent)`, r.style.display = "none", e.appendChild(r);
+  const n = getComputedStyle(r).color;
+  return r.remove(), n ? l(n) : t;
+}
+const u = "--chart-capacity";
+function p(e) {
+  if (typeof getComputedStyle > "u") return o;
+  const t = getComputedStyle(e).getPropertyValue(u).trim();
+  if (t === "") return o;
+  const r = Number.parseInt(t, 10);
+  return !Number.isFinite(r) || r < 0 ? o : Math.min(r, o);
+}
+function f(e, t = "var(--muted-foreground)", r = o) {
+  return e >= 0 && e < Math.min(r, o) ? `var(--chart-${e + 1})` : t;
+}
+export {
+  u as CHART_CAPACITY_PROPERTY,
+  h as CHART_SLOTS,
+  p as categoricalCapacity,
+  f as categoricalColor,
+  d as resolveTokenColor
+};
+//# sourceMappingURL=token-color.js.map

package/dist/lib/token-color.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-color.js","sources":["../../src/lib/token-color.ts"],"sourcesContent":["// Token colour resolution — no engine, no hook, no directive.\n//\n// This half used to live in `charts/theme.ts`, which mixed it with two hooks and therefore carried\n// `\"use client\"`. Two things broke as a result. `chart-config.ts` *calls* `categoricalColor`, so in\n// an RSC graph a public `/analytics` export resolved to a client reference and a Server Component\n// threw. And the placement rule (a part belongs on a subpath only if it imports that subpath's\n// engine) put a twelve-line token resolver behind the DuckDB/Mosaic peer set — a WebGL graph and a\n// docs helper both paid for the whole analytics stack to reach it.\n//\n// So the split is on the client boundary, not on the topic: everything here is pure, and the two\n// hooks that read the live cascade live in `./theme-tick.js`. Both are on the root barrel.\n\nimport { CHART_SLOTS } from \"@kanzo-tech/theme\";\n\n/**\n * Convert a browser-computed colour into the plain `rgb(...)` form Observable Plot accepts.\n *\n * Forcing a token through `color-mix(in srgb, …)` pins it to sRGB, but a modern browser then\n * *serialises* that as `color(srgb 0.61 0.61 0.61)` — and Plot's `isColor` (0.6.x) rejects the\n * `color()` function, so it mistakes the fill for a data column and the query dies with a binder\n * error. Canvas normalisation preserves `color(srgb …)` too, so we parse the sRGB components\n * ourselves. `rgb(...)` / `rgba(...)` / hex / named inputs (older browsers) pass straight through.\n */\nfunction toPlotColor(computed: string): string {\n  // The components may be negative or above 1: a wide-gamut token pinned to sRGB serialises\n  // out of gamut (`color(srgb 0.96 0.28 -0.15)` for `--chart-1` in Chrome). Missing those was a\n  // real failure, not a rounding detail — the unparsed string reached Plot, which read it as a\n  // *column name* and killed the query with a binder error. Parse them, then clamp.\n  const m = computed.match(\n    /^color\\(srgb\\s+([-+\\d.eE]+)\\s+([-+\\d.eE]+)\\s+([-+\\d.eE]+)(?:\\s*\\/\\s*([-+\\d.eE]+))?\\s*\\)$/i,\n  );\n  if (!m) return computed;\n  const channel = (v: string) => Math.min(255, Math.max(0, Math.round(Number(v) * 255)));\n  const [r, g, b] = [m[1], m[2], m[3]].map((v) => channel(v as string));\n  const a = m[4] != null ? Math.min(1, Math.max(0, Number(m[4]))) : 1;\n  return a < 1 ? `rgba(${r}, ${g}, ${b}, ${a})` : `rgb(${r}, ${g}, ${b})`;\n}\n\n/**\n * Resolve a Kanzo colour token to a concrete, Plot-safe `rgb(...)` string.\n *\n * vgplot delegates every fill to Observable Plot, whose `isColor` (0.6.x) accepts named colours,\n * hex and `rgb()`/`hsl()` — but **not** `var(--token)`, `color-mix()`, `oklch()` or `color(srgb …)`,\n * which is exactly how Tailwind v4's default palette (and therefore our tokens) is authored/served.\n * Hand Plot any of those and it treats the string as a data column, so the query fails.\n *\n * So we read the token off the live DOM through an `in srgb` `color-mix` (which pins it to sRGB)\n * and normalise the result to `rgb(...)` via {@link toPlotColor}. The probe is appended to `host`\n * so a scoped theme override (a `data-*` attribute on an ancestor) resolves against the same\n * cascade the chart sits in. Read at mount and re-read on every theme change (see `useThemeTick`),\n * so a re-theme re-colours the marks — the vgplot analogue of the way CodeEditor's `var()`-backed\n * theme re-skins CodeMirror.\n */\nexport function resolveTokenColor(host: Element, token: string): string {\n  const probe = document.createElement(\"span\");\n  // The 0%-transparent second colour just keeps the first at full opacity; `in srgb` pins it.\n  probe.style.color = `color-mix(in srgb, var(${token}) 100%, transparent)`;\n  probe.style.display = \"none\";\n  host.appendChild(probe);\n  const resolved = getComputedStyle(probe).color;\n  probe.remove();\n  return resolved ? toPlotColor(resolved) : token;\n}\n\n/**\n * How many categorical slots the stylesheet declares. A 9th series folds into \"Other\" — never\n * cycle, or identity stops meaning anything.\n *\n * This file used to export the scheme's literal values too, first as eight hand-written hexes and\n * then as the default entry of `theme-data.json`. Both were a *second* source of truth beside\n * `--chart-*`, and that is the defect this whole colour layer exists to end: the same series was\n * one colour through `ChartConfig` and another through a token. It is gone, not relocated. The\n * tenant palette document owns the categorical set, `compile()` projects it onto these tokens, and\n * a chart reads the token — one answer, which follows the mode and follows the client.\n *\n * The count stays a compile-time constant because a stylesheet cannot have a variable number of\n * custom properties. How many of the slots carry a *real* category is the document's `capacity`,\n * which can be lower: past it, `compile` writes `var(--muted-foreground)`, and a set that carries\n * fewer categories than it has slots is saying so rather than inventing colours.\n */\nexport { CHART_SLOTS };\n\n/**\n * The custom property carrying the document's `categorical.capacity`.\n *\n * `compile()` emits it at the head of both blocks — the one declaration in the sheet that is not a\n * colour, because it is the one fact about the set that the colours cannot carry. A custom property\n * and not a JS constant: the cascade is the only channel a scoped palette override travels down,\n * and it is the same channel `--chart-*` itself arrives on. A stylesheet that declares nothing\n * (anything older than the document, or a test fixture) falls back to `CHART_SLOTS`.\n *\n * Module-level only: `categoricalCapacity` is the way to read it, and an export whose whole use is\n * to be passed straight back into the function beside it is a second way to do one thing.\n */\nexport const CHART_CAPACITY_PROPERTY = \"--chart-capacity\";\n\n/**\n * How many slots name a real category, read off the live cascade.\n *\n * `compile()` writes `var(--muted-foreground)` into every slot past capacity, so the *colour* of a\n * ninth series is already right without anyone knowing the number. What is not right is the\n * **count**: a legend that draws a row per slot claims eight distinguishable kinds where a set may\n * carry six, and any \"group the tail into Other\" logic folds at the wrong index. Measured over 24\n * brand hues one every 15° at L 0.62 / C 0.15, capacity came back 6–8 (mean 7.50) with 11 of the 24\n * under 8 — so this is the common case, not an edge one.\n *\n * Read against `host` rather than `<html>` for the same reason `resolveTokenColor` is: a scoped\n * palette override on an ancestor has to win.\n */\nexport function categoricalCapacity(host: Element): number {\n  if (typeof getComputedStyle === \"undefined\") return CHART_SLOTS;\n  const raw = getComputedStyle(host).getPropertyValue(CHART_CAPACITY_PROPERTY).trim();\n  // **A declared zero is an answer; an absent property is not.** They used to be one branch, and\n  // that was right while zero could only arrive by accident. A document may now decline the\n  // categorical channel outright — one ink, no category carried by colour — and it says so with\n  // this number, so folding zero back up to the full slot count would paint eight distinguishable\n  // colours on the one document that published none. The cascade tells the two apart already:\n  // `getPropertyValue` returns an empty string for a property nobody declared.\n  if (raw === \"\") return CHART_SLOTS;\n  const declared = Number.parseInt(raw, 10);\n  if (!Number.isFinite(declared) || declared < 0) return CHART_SLOTS;\n  return Math.min(declared, CHART_SLOTS);\n}\n\n/**\n * The categorical colour for series index `i`, as a **token**.\n *\n * A token and not a literal so one answer covers both jobs: it follows the light/dark flip, and it\n * follows whichever scheme the product selected — neither of which a baked hex can do. The chart\n * pipeline already resolves `var(--…)` against the live element, and the DOM resolves it natively\n * for legends and swatches.\n *\n * `capacity` is where the Other boundary sits. It defaults to `CHART_SLOTS` because that is the\n * only honest answer without a DOM to read — a caller with one passes `categoricalCapacity(host)`.\n */\nexport function categoricalColor(\n  i: number,\n  other = \"var(--muted-foreground)\",\n  capacity = CHART_SLOTS,\n): string {\n  return i >= 0 && i < Math.min(capacity, CHART_SLOTS) ? `var(--chart-${i + 1})` : other;\n}\n"],"names":["toPlotColor","computed","m","channel","v","r","g","b","a","resolveTokenColor","host","token","probe","resolved","CHART_CAPACITY_PROPERTY","categoricalCapacity","CHART_SLOTS","raw","declared","categoricalColor","i","other","capacity"],"mappings":";;AAuBA,SAASA,EAAYC,GAA0B;AAK7C,QAAMC,IAAID,EAAS;AAAA,IACjB;AAAA,EAAA;AAEF,MAAI,CAACC,EAAG,QAAOD;AACf,QAAME,IAAU,CAACC,MAAc,KAAK,IAAI,KAAK,KAAK,IAAI,GAAG,KAAK,MAAM,OAAOA,CAAC,IAAI,GAAG,CAAC,CAAC,GAC/E,CAACC,GAAGC,GAAGC,CAAC,IAAI,CAACL,EAAE,CAAC,GAAGA,EAAE,CAAC,GAAGA,EAAE,CAAC,CAAC,EAAE,IAAI,CAACE,MAAMD,EAAQC,CAAW,CAAC,GAC9DI,IAAIN,EAAE,CAAC,KAAK,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,OAAOA,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI;AAClE,SAAOM,IAAI,IAAI,QAAQH,CAAC,KAAKC,CAAC,KAAKC,CAAC,KAAKC,CAAC,MAAM,OAAOH,CAAC,KAAKC,CAAC,KAAKC,CAAC;AACtE;AAiBO,SAASE,EAAkBC,GAAeC,GAAuB;AACtE,QAAMC,IAAQ,SAAS,cAAc,MAAM;AAE3C,EAAAA,EAAM,MAAM,QAAQ,0BAA0BD,CAAK,wBACnDC,EAAM,MAAM,UAAU,QACtBF,EAAK,YAAYE,CAAK;AACtB,QAAMC,IAAW,iBAAiBD,CAAK,EAAE;AACzC,SAAAA,EAAM,OAAA,GACCC,IAAWb,EAAYa,CAAQ,IAAIF;AAC5C;AAgCO,MAAMG,IAA0B;AAehC,SAASC,EAAoBL,GAAuB;AACzD,MAAI,OAAO,mBAAqB,IAAa,QAAOM;AACpD,QAAMC,IAAM,iBAAiBP,CAAI,EAAE,iBAAiBI,CAAuB,EAAE,KAAA;AAO7E,MAAIG,MAAQ,GAAI,QAAOD;AACvB,QAAME,IAAW,OAAO,SAASD,GAAK,EAAE;AACxC,SAAI,CAAC,OAAO,SAASC,CAAQ,KAAKA,IAAW,IAAUF,IAChD,KAAK,IAAIE,GAAUF,CAAW;AACvC;AAaO,SAASG,EACdC,GACAC,IAAQ,2BACRC,IAAWN,GACH;AACR,SAAOI,KAAK,KAAKA,IAAI,KAAK,IAAIE,GAAUN,CAAW,IAAI,eAAeI,IAAI,CAAC,MAAMC;AACnF;"}

package/dist/lib/use-is-mobile.d.ts

@@ -0,0 +1,2 @@
+export declare const useIsMobile: () => boolean;
+//# sourceMappingURL=use-is-mobile.d.ts.map

package/dist/lib/use-is-mobile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-is-mobile.d.ts","sourceRoot":"","sources":["../../src/lib/use-is-mobile.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,WAAW,eAoBvB,CAAC"}

package/dist/lib/use-is-mobile.js

@@ -0,0 +1,17 @@
+"use client";
+import o from "react";
+const e = 768, d = () => {
+  const [s, t] = o.useState(
+    void 0
+  );
+  return o.useEffect(() => {
+    const n = window.matchMedia(`(max-width: ${e - 1}px)`), i = () => {
+      t(window.innerWidth < e);
+    };
+    return n.addEventListener("change", i), t(window.innerWidth < e), () => n.removeEventListener("change", i);
+  }, []), !!s;
+};
+export {
+  d as useIsMobile
+};
+//# sourceMappingURL=use-is-mobile.js.map

package/dist/lib/use-is-mobile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-is-mobile.js","sources":["../../src/lib/use-is-mobile.ts"],"sourcesContent":["\"use client\";\n\n// The directive is not optional here even though the hook is internal: it calls `useState` /\n// `useEffect` and registers a `matchMedia` listener. It was contained only by the accident that its\n// single importer is a client module, which is one import away from a break.\n\nimport React from \"react\";\n\nconst MOBILE_BREAKPOINT = 768;\n\nexport const useIsMobile = () => {\n  const [isMobile, setIsMobile] = React.useState<boolean | undefined>(\n    undefined\n  );\n\n  React.useEffect(() => {\n    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);\n\n    const onChange = () => {\n      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);\n    };\n\n    mql.addEventListener(\"change\", onChange);\n\n    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);\n\n    return () => mql.removeEventListener(\"change\", onChange);\n  }, []);\n\n  return !!isMobile;\n};\n"],"names":["React"],"mappings":";;AAQA;AAGE;AAAsC;AACpC;AAGFA;AACE;AAGE;AAAiD;AAGnD;AAIuD;AAI3D;;;;"}

package/dist/shark-parity.divergences.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Every way this library's export surface differs from Shark UI's, with the reason for each.
+ *
+ * `shark-parity.test.ts` computes the difference against the checked-in snapshot of Shark's
+ * registry and requires that every entry it finds is declared here — and that every entry declared
+ * here is still a real difference. Both halves matter. The first is what would have caught 31
+ * context aliases being deleted on a house rule while Shark shipped 38 of the 43 names involved
+ *; the second is what stops this file rotting into an
+ * allowlist that only ever grows.
+ *
+ * **A reason is not a note.** The reference governs the surface, a measurement overrules the
+ * reference, and a house principle overrules neither. So where this library made a CHOICE against
+ * Shark, the reason is one of four
+ * things, and saying which is the point:
+ *
+ * 1. a measurement — a number, what it was measured against, a threshold it crosses;
+ * 2. a rule on `/docs/design`, cited by path, which carries its own evidence and what would
+ *    reverse it;
+ * 3. an assertion in another guard, cited by file and test name;
+ * 4. `Undecided — …`, where nothing above applies. That is a legitimate state
+ *    (`/docs/design/references`: *where none of that decides, the owner does, and the case is recorded as undecided rather than argued into one of the branches*),
+ *    and the test pins the exact list, so one cannot be added or quietly resolved without an edit
+ *    somebody reviews.
+ *
+ * **And two more, because most entries here are not a choice at all** — this paragraph exists
+ * because the list above said "one of four things" while the file had used six for months, and a
+ * queue item was filed against the guard for not enforcing the four. Counted 2026-08-24 over all 87
+ * declarations: 53 cite a decision record, 8 cite a guard, 2 measure, **0** are `Undecided` (that
+ * went 21 → 0 and the test pins the empty list), and the remaining 24 are:
+ *
+ * 5. `Not built. …` — 19 of them. Shark ships a component and we have not written one. There is no
+ *    divergence to justify, only an absence to record, and what the entry owes is what stands in
+ *    its place or that nothing does.
+ * 6. `Ours…` — 3, plus one cross-reference to a sibling entry and one prose entry in
+ *    `BEYOND_THE_SURFACE` for a difference that is not a name at all. A name we ship and Shark does
+ *    not is the mirror of 5 and owes the same thing.
+ *
+ * Anything cited by path is checked to exist. A reason pointing at a file somebody deleted is not
+ * a reason. The shape itself is NOT checked — see the guard's own "what it cannot prove".
+ */
+/** Shark's registry filename → our module, relative to `src/`, where the two do not match. */
+export declare const MODULE_MAP: Readonly<Record<string, string>>;
+/**
+ * A Shark component we do not ship, keyed by its registry filename.
+ *
+ * Most of these are the ordinary shape of adopting a reference incrementally rather than a
+ * disagreement with it: `/docs/design/admission` says a family nobody renders does not get
+ * built, and an export needs a second call site. Where we solve the same problem differently, the entry names what we solve it
+ * with, because that is the thing a reader is looking for.
+ */
+export declare const UNADOPTED: Readonly<Record<string, string>>;
+/**
+ * A module of ours Shark has no file for, keyed by our filename in `simples/` (or the key it takes
+ * in `MODULE_MAP`). These are additions to the reference, and each answers to the house rules
+ * instead — admission, and a second call site.
+ */
+export declare const OURS_ALONE: Readonly<Record<string, string>>;
+/**
+ * The same Ark part under a different exported name. Declaring these as a pair rather than as one
+ * absence plus one addition is the honest shape: nothing is missing and nothing is extra, the two
+ * references simply disagree about spelling, and the naming rule picks Ark's part name.
+ *
+ * Keyed `"<shark file>:<Shark's name>"`.
+ */
+export declare const RENAMED: Readonly<Record<string, {
+    readonly ours: string;
+    readonly reason: string;
+}>>;
+/**
+ * A name Shark exports that we do not, keyed `"<shark file>:<Name>"`.
+ *
+ * This map used to be dominated by the parts sweep — thirty-four names withheld because our own
+ * root renders the part, plus four recipes withheld because a class list is not API. Both were
+ * house principles, and parity restored all thirty-eight against the reference order —
+ * `/docs/design/references`. What is left is the shape a
+ * withheld name is supposed to have: a decision with its own record, or an open question with
+ * nobody's name on it yet.
+ */
+export declare const WITHHELD: Readonly<Record<string, string>>;
+/**
+ * A name we export that Shark's matching component does not, keyed `"<shark file>:<Name>"`.
+ *
+ * `/docs/design/references` reads, as written, in both directions: *a `useX` or a
+ * part Shark's registry exports, we export under that name; one it does not export, we do not.*
+ * Thirteen of the entries below are Ark parts Shark's file does not export, so under the widest
+ * reading of that sentence they should not exist. They do exist for one reason, and it is a real
+ * one: **our root is thin where Shark's pre-arranges.** `Rating` is the clean example — Shark's
+ * root lays out label, control and hidden input itself and exports two names; ours exports the
+ * anatomy and lets the caller compose it. Withdrawing the parts would not match Shark, it would
+ * leave a component that cannot be labelled. See BEYOND_THE_SURFACE.
+ */
+export declare const ADDED: Readonly<Record<string, string>>;
+/**
+ * Divergences this guard cannot express as a name, recorded here because they are the ones a
+ * reader arrives looking for — and because each is checkable somewhere, which is what a divergence
+ * has to be. `held` is a list of paths relative to the repository root; the test asserts every one
+ * of them exists, so a citation cannot outlive the file it points at.
+ */
+export declare const BEYOND_THE_SURFACE: readonly {
+    readonly what: string;
+    readonly why: string;
+    readonly held: readonly string[];
+}[];
+//# sourceMappingURL=shark-parity.divergences.d.ts.map

package/dist/shark-parity.divergences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shark-parity.divergences.d.ts","sourceRoot":"","sources":["../src/shark-parity.divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,8FAA8F;AAC9F,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAIvD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA8BtD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAUvD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAUhG,CAAC;AA+DF;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAmCrD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA2BlD,CAAC;AAaF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC,EAsHA,CAAC"}

package/dist/simples/FacetFilter.d.ts

@@ -0,0 +1,57 @@
+import { default as React } from 'react';
+import { Button } from './button';
+export interface FacetFilterItem {
+    value: string;
+    label?: React.ReactNode;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    /** Rows behind this value, drawn at the row's end. */
+    count?: number;
+}
+export interface FacetFilterProps extends Omit<React.ComponentProps<typeof Button>, "children" | "onSelect"> {
+    /** Trigger label. */
+    label?: React.ReactNode;
+    /** The values on offer. */
+    items: readonly FacetFilterItem[];
+    /** The values currently filtered on. */
+    value: readonly string[];
+    onValueChange: (next: string[]) => void;
+    /** Tick any number of values. `false` keeps at most one ticked. */
+    multiple?: boolean;
+    /**
+     * Draw a filter field above the list, narrowing the rows on offer.
+     *
+     * Deliberately a prop and never a count threshold: the caller knows whether the column is
+     * `provider` or `subject_uri`, and a control that grows a search field once the crossfilter
+     * pushes it past *n* values reshapes itself under the cursor.
+     *
+     * @default false
+     */
+    searchable?: boolean;
+    /** Placeholder for the `searchable` field. */
+    searchPlaceholder?: string;
+    /** Accessible name for the `searchable` field. */
+    searchLabel?: string;
+    /** Shown when the `searchable` query excludes every row. Not the same state as `empty`. */
+    searchEmpty?: React.ReactNode;
+    /** Shown when there is nothing to offer. */
+    empty?: React.ReactNode;
+    /** A footnote under the list — a truncation notice, a hint. */
+    note?: React.ReactNode;
+    /** Class for the popover surface; `className` styles the trigger. */
+    contentClassName?: string;
+}
+/**
+ * The surface behind every facet filter: a trigger that reports its own count, a listbox of
+ * values, and a way out.
+ *
+ * A filter is **a value**, not a command, so this is a listbox and not a menu of checkbox items.
+ * Where the values come from and
+ * where the choice goes are the caller's: TanStack facets on one side of this library, a Mosaic
+ * clause on the other. What is *not* the caller's are the two rules below, which both adapters
+ * had independently rediscovered, and which are invisible until they bite — and which both have to
+ * survive `searchable`, because a query that hides a ticked row takes the untick with it.
+ */
+export declare const FacetFilter: (props: FacetFilterProps) => React.JSX.Element;
+//# sourceMappingURL=FacetFilter.d.ts.map

package/dist/simples/FacetFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FacetFilter.d.ts","sourceRoot":"","sources":["../../src/simples/FacetFilter.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAalC,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACxB,IAAI,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnD,sDAAsD;IACtD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBACf,SAAQ,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,MAAM,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IAC1E,qBAAqB;IACrB,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACxB,2BAA2B;IAC3B,KAAK,EAAE,SAAS,eAAe,EAAE,CAAC;IAClC,wCAAwC;IACxC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACxC,mEAAmE;IACnE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,8CAA8C;IAC9C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kDAAkD;IAClD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2FAA2F;IAC3F,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC9B,4CAA4C;IAC5C,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACxB,+DAA+D;IAC/D,IAAI,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACvB,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,gBAAgB,sBAmMlD,CAAC"}

package/dist/simples/FacetFilter.js

@@ -0,0 +1,167 @@
+"use client";
+import { jsxs as o, jsx as l, Fragment as k } from "react/jsx-runtime";
+import { createListCollection as q } from "@ark-ui/react/collection";
+import { useFilter as B } from "@ark-ui/react/locale";
+import { ListFilterIcon as A } from "lucide-react";
+import { useState as H, useRef as O, useMemo as h } from "react";
+import { cn as Q } from "../lib/cn.js";
+import { Badge as Y } from "./badge.js";
+import { Button as y } from "./button.js";
+import { Listbox as _, ListboxInput as D, ListboxContent as G, ListboxItem as J, ListboxItemText as K, ListboxItemIndicator as U, ListboxEmpty as W } from "./listbox.js";
+import { Popover as X, PopoverTrigger as Z, PopoverContent as $ } from "./popover.js";
+import { Separator as ee } from "./separator.js";
+const fe = (r) => {
+  const {
+    label: C,
+    items: f,
+    value: a,
+    onValueChange: d,
+    multiple: L = !0,
+    searchable: u = !1,
+    searchPlaceholder: I = "Filter values…",
+    searchLabel: N = "Filter values",
+    searchEmpty: F = "No matching values.",
+    empty: T = "No values.",
+    note: p,
+    className: E,
+    contentClassName: S,
+    size: w = "sm",
+    variant: z = "outline",
+    slot: P,
+    ...V
+  } = r, [v, g] = H(""), x = O(null), { contains: b } = B(te), s = h(() => {
+    const e = new Map(f.map((t) => [t.value, t]));
+    for (const t of a)
+      e.has(t) || e.set(t, { value: t });
+    return [...e.values()].sort(
+      (t, R) => c(t).localeCompare(c(R))
+    );
+  }, [f, a]), m = u ? v.trim() : "", n = h(() => {
+    if (!m) return s;
+    const e = new Set(a);
+    return s.filter(
+      (t) => e.has(t.value) || b(c(t), m)
+    );
+  }, [b, s, m, a]), j = h(
+    () => q({
+      items: n,
+      itemToValue: (e) => e.value,
+      itemToString: c
+    }),
+    [n]
+  ), i = [...a], M = n.length === 0 && s.length > 0;
+  return (
+    // Not modal, unlike our `Popover` default. A filter is judged by what changes behind it, and a
+    // modal popover marks the rest of the page `aria-hidden` — so the table you are filtering
+    // becomes unreadable to a screen reader at the exact moment it is being filtered.
+    //
+    // The query resets with the surface, because `Popover` unmounts its content on exit: the
+    // input's DOM value goes with it while this state would not, leaving a reopened filter showing
+    // every row from a query it still believes in.
+    //
+    // `initialFocusEl` aims the popover's opening focus at the field when there is one. Zag's
+    // default lands on the content itself, and it lands *late* — so a first keystroke typed
+    // straight after opening goes to the list as typeahead, and the focus then moves out from
+    // under the caret. Pointing it at the field makes "open it and start typing" work, which is
+    // the only reason a filter field is there.
+    /* @__PURE__ */ o(
+      X,
+      {
+        initialFocusEl: u ? () => x.current : void 0,
+        modal: !1,
+        onOpenChange: () => g(""),
+        children: [
+          /* @__PURE__ */ l(Z, { asChild: !0, children: /* @__PURE__ */ o(
+            y,
+            {
+              className: E,
+              size: w,
+              variant: z,
+              ...V,
+              slot: P ?? "facet-filter",
+              children: [
+                /* @__PURE__ */ l(A, {}),
+                C,
+                i.length > 0 && /* @__PURE__ */ l(Y, { size: "xs", variant: "secondary", children: i.length })
+              ]
+            }
+          ) }),
+          /* @__PURE__ */ o(
+            $,
+            {
+              className: Q("w-56 p-1", S),
+              slot: "facet-filter-content",
+              children: [
+                /* @__PURE__ */ o(
+                  _,
+                  {
+                    collection: j,
+                    onValueChange: (e) => d(e.value),
+                    selectionMode: L ? "multiple" : "single",
+                    value: i,
+                    children: [
+                      u && // `autoHighlight` is Ark's, off by default and worth turning on here: it re-highlights
+                      // the first row of the collection every time the collection changes, so typing leaves
+                      // the top match under Enter instead of requiring an ArrowDown first. `keyboardPriority`
+                      // stays "caret" — Home/End belong to the text you are editing.
+                      /* @__PURE__ */ l(
+                        D,
+                        {
+                          "aria-label": N,
+                          autoHighlight: !0,
+                          onChange: (e) => g(e.target.value),
+                          placeholder: I,
+                          ref: x,
+                          size: "sm",
+                          value: v
+                        }
+                      ),
+                      /* @__PURE__ */ o(G, { className: "max-h-72 overflow-y-auto", children: [
+                        n.map((e) => {
+                          const t = e.icon;
+                          return /* @__PURE__ */ o(J, { item: e, children: [
+                            t && /* @__PURE__ */ l(t, {}),
+                            /* @__PURE__ */ l(K, { children: e.label ?? e.value }),
+                            e.count !== void 0 && /* @__PURE__ */ l("span", { className: "text-muted-foreground text-xs tabular-nums", children: e.count }),
+                            /* @__PURE__ */ l(U, {})
+                          ] }, e.value);
+                        }),
+                        /* @__PURE__ */ l(W, { children: M ? F : T })
+                      ] })
+                    ]
+                  }
+                ),
+                p && /* @__PURE__ */ l(
+                  "p",
+                  {
+                    className: "px-2 py-1.5 text-muted-foreground text-xs",
+                    "data-slot": "facet-filter-note",
+                    children: p
+                  }
+                ),
+                i.length > 0 && /* @__PURE__ */ o(k, { children: [
+                  /* @__PURE__ */ l(ee, { className: "my-1" }),
+                  /* @__PURE__ */ l(
+                    y,
+                    {
+                      className: "w-full justify-center",
+                      slot: "facet-filter-clear",
+                      onClick: () => d([]),
+                      size: "sm",
+                      variant: "ghost",
+                      children: "Clear filter"
+                    }
+                  )
+                ] })
+              ]
+            }
+          )
+        ]
+      }
+    )
+  );
+}, te = { sensitivity: "base" }, c = (r) => typeof r.label == "string" ? r.label : r.value;
+export {
+  fe as FacetFilter
+};
+//# sourceMappingURL=FacetFilter.js.map