@scattered-light/loomiere-base-ui 0.6.1 → 0.7.0

package/dist/chunk-M7KJASGK.js

@@ -0,0 +1,802 @@
+import * as React4 from 'react';
+import { Button as Button$1 } from '@base-ui/react/button';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { Select as Select$1 } from '@base-ui/react/select';
+import { Combobox as Combobox$1 } from '@base-ui/react/combobox';
+
+// src/utils/cn.ts
+function cn(...inputs) {
+  const out = [];
+  for (const input of inputs) {
+    if (input == null || input === false) continue;
+    if (typeof input === "string" || typeof input === "number") {
+      out.push(String(input));
+    } else if (Array.isArray(input)) {
+      const inner = cn(...input);
+      if (inner) out.push(inner);
+    } else if (typeof input === "object") {
+      for (const [k, v] of Object.entries(input)) {
+        if (v) out.push(k);
+      }
+    }
+  }
+  return out.join(" ");
+}
+function cnState(base, className, state) {
+  return cn(base, typeof className === "function" ? className(state) : className);
+}
+function styledPart(Base, displayName, baseClass) {
+  const Comp = React4.forwardRef(function StyledPart(props, ref) {
+    const { className, ...rest } = props;
+    return /* @__PURE__ */ jsx(
+      Base,
+      {
+        ref,
+        ...rest,
+        className: (state) => cnState(baseClass, className, state)
+      }
+    );
+  });
+  Comp.displayName = displayName;
+  return Comp;
+}
+function styledPartUnless(Base, displayName, baseClass, skipClass) {
+  const Comp = React4.forwardRef(function StyledPart(props, ref) {
+    const { className, ...rest } = props;
+    return /* @__PURE__ */ jsx(
+      Base,
+      {
+        ref,
+        ...rest,
+        className: (state) => {
+          const extra = typeof className === "function" ? className(state) : className;
+          const skip = extra?.split(/\s+/).includes(skipClass);
+          return cn(skip ? void 0 : baseClass, extra);
+        }
+      }
+    );
+  });
+  Comp.displayName = displayName;
+  return Comp;
+}
+function isIconOnly(children) {
+  const items = React4.Children.toArray(children);
+  return items.length === 1 && React4.isValidElement(items[0]);
+}
+function buttonPart(Base, displayName, { partClass, optIn = false, otherClass, skipClass } = {}) {
+  const Comp = React4.forwardRef(function ButtonPart(props, ref) {
+    const { className, emphasis, palette, ...rest } = props;
+    const asked = emphasis !== void 0 || palette !== void 0;
+    return /* @__PURE__ */ jsx(
+      Base,
+      {
+        ref,
+        "data-emphasis": emphasis,
+        "data-color": palette,
+        "data-icon-only": isIconOnly(rest.children) ? "" : void 0,
+        ...rest,
+        className: (state) => {
+          const extra = typeof className === "function" ? className(state) : className;
+          const classes = extra?.split(/\s+/) ?? [];
+          const isButton = !(skipClass && classes.includes(skipClass)) && (!optIn || asked || classes.includes("Button"));
+          return cn(
+            partClass,
+            isButton && !classes.includes("Button") ? "Button" : void 0,
+            isButton ? void 0 : otherClass,
+            extra
+          );
+        }
+      }
+    );
+  });
+  Comp.displayName = displayName;
+  return Comp;
+}
+var Button = React4.forwardRef(function Button2({ className, emphasis, palette, children, ...props }, ref) {
+  return /* @__PURE__ */ jsx(
+    Button$1,
+    {
+      ref,
+      "data-emphasis": emphasis,
+      "data-color": palette,
+      "data-icon-only": isIconOnly(children) ? "" : void 0,
+      ...props,
+      className: (state) => cnState("Button", className, state),
+      children
+    }
+  );
+});
+Button.displayName = "Button";
+var Trigger = buttonPart(
+  Select$1.Trigger,
+  "SelectTrigger",
+  { optIn: true, otherClass: "SelectTrigger" }
+);
+var Value = styledPart(
+  Select$1.Value,
+  "SelectValue",
+  "SelectValue"
+);
+var Icon = styledPart(
+  Select$1.Icon,
+  "SelectIcon",
+  "SelectIcon"
+);
+var Backdrop = styledPart(
+  Select$1.Backdrop,
+  "SelectBackdrop",
+  "SelectBackdrop"
+);
+var Positioner = styledPart(
+  Select$1.Positioner,
+  "SelectPositioner",
+  "SelectPositioner"
+);
+var Popup = styledPart(
+  Select$1.Popup,
+  "SelectPopup",
+  "SelectPopup"
+);
+var List = styledPart(
+  Select$1.List,
+  "SelectList",
+  "SelectList"
+);
+var Item = styledPart(
+  Select$1.Item,
+  "SelectItem",
+  "SelectItem"
+);
+var ItemIndicator = styledPart(
+  Select$1.ItemIndicator,
+  "SelectItemIndicator",
+  "SelectItemIndicator"
+);
+var ItemText = styledPart(
+  Select$1.ItemText,
+  "SelectItemText",
+  "SelectItemText"
+);
+var Arrow = styledPart(
+  Select$1.Arrow,
+  "SelectArrow",
+  "SelectArrow"
+);
+var ScrollDownArrow = styledPart(
+  Select$1.ScrollDownArrow,
+  "SelectScrollDownArrow",
+  "SelectScrollArrow"
+);
+var ScrollUpArrow = styledPart(
+  Select$1.ScrollUpArrow,
+  "SelectScrollUpArrow",
+  "SelectScrollArrow"
+);
+var Group = styledPart(
+  Select$1.Group,
+  "SelectGroup",
+  "SelectGroup"
+);
+var GroupLabel = styledPart(
+  Select$1.GroupLabel,
+  "SelectGroupLabel",
+  "SelectGroupLabel"
+);
+var Separator = styledPart(
+  Select$1.Separator,
+  "SelectSeparator",
+  "SelectSeparator"
+);
+var Select = {
+  Root: Select$1.Root,
+  Label: Select$1.Label,
+  Trigger,
+  Value,
+  Icon,
+  Portal: Select$1.Portal,
+  Backdrop,
+  Positioner,
+  Popup,
+  List,
+  Item,
+  ItemIndicator,
+  ItemText,
+  Arrow,
+  ScrollDownArrow,
+  ScrollUpArrow,
+  Group,
+  GroupLabel,
+  Separator
+};
+function Root({
+  className,
+  style,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx("div", { className: cn("ComboboxRoot", className), style, children: /* @__PURE__ */ jsx(Combobox$1.Root, { ...props }) });
+}
+var Trigger2 = React4.forwardRef(
+  function ComboboxTrigger({ className, ...props }, ref) {
+    return /* @__PURE__ */ jsx(
+      Combobox$1.Trigger,
+      {
+        ref,
+        ...props,
+        className: (state) => {
+          const extra = typeof className === "function" ? className(state) : className;
+          const selectTrigger = extra?.split(/\s+/).includes("ComboboxSelectTrigger");
+          return cn(selectTrigger ? void 0 : "ComboboxTrigger", extra);
+        }
+      }
+    );
+  }
+);
+var Label = styledPart(
+  Combobox$1.Label,
+  "ComboboxLabel",
+  "ComboboxLabel"
+);
+var Input = styledPart(
+  Combobox$1.Input,
+  "ComboboxInput",
+  "ComboboxInput"
+);
+var Clear = styledPart(
+  Combobox$1.Clear,
+  "ComboboxClear",
+  "ComboboxClear"
+);
+var Icon2 = styledPart(
+  Combobox$1.Icon,
+  "ComboboxIcon",
+  "ComboboxIcon"
+);
+var Chips = styledPart(
+  Combobox$1.Chips,
+  "ComboboxChips",
+  "ComboboxChips"
+);
+var Chip = styledPart(
+  Combobox$1.Chip,
+  "ComboboxChip",
+  "ComboboxChip"
+);
+var ChipRemove = styledPart(
+  Combobox$1.ChipRemove,
+  "ComboboxChipRemove",
+  "ComboboxChipRemove"
+);
+var Positioner2 = styledPart(
+  Combobox$1.Positioner,
+  "ComboboxPositioner",
+  "ComboboxPositioner"
+);
+var Popup2 = styledPart(
+  Combobox$1.Popup,
+  "ComboboxPopup",
+  "ComboboxPopup"
+);
+var List2 = styledPart(
+  Combobox$1.List,
+  "ComboboxList",
+  "ComboboxList"
+);
+var Item2 = styledPart(
+  Combobox$1.Item,
+  "ComboboxItem",
+  "ComboboxItem"
+);
+var ItemIndicator2 = styledPart(
+  Combobox$1.ItemIndicator,
+  "ComboboxItemIndicator",
+  "ComboboxItemIndicator"
+);
+var GroupLabel2 = styledPart(
+  Combobox$1.GroupLabel,
+  "ComboboxGroupLabel",
+  "ComboboxGroupLabel"
+);
+var Separator2 = styledPart(
+  Combobox$1.Separator,
+  "ComboboxSeparator",
+  "ComboboxSeparator"
+);
+var Empty = styledPart(
+  Combobox$1.Empty,
+  "ComboboxEmpty",
+  "ComboboxEmpty"
+);
+var Status = styledPart(
+  Combobox$1.Status,
+  "ComboboxStatus",
+  "ComboboxStatus"
+);
+var Combobox = {
+  Root,
+  Label,
+  Value: Combobox$1.Value,
+  Input,
+  InputGroup: Combobox$1.InputGroup,
+  Trigger: Trigger2,
+  List: List2,
+  Status,
+  Portal: Combobox$1.Portal,
+  Backdrop: Combobox$1.Backdrop,
+  Positioner: Positioner2,
+  Popup: Popup2,
+  Arrow: Combobox$1.Arrow,
+  Icon: Icon2,
+  Group: Combobox$1.Group,
+  GroupLabel: GroupLabel2,
+  Item: Item2,
+  ItemIndicator: ItemIndicator2,
+  Chips,
+  Chip,
+  ChipRemove,
+  Row: Combobox$1.Row,
+  Collection: Combobox$1.Collection,
+  Empty,
+  Clear,
+  Separator: Separator2,
+  useFilter: Combobox$1.useFilter,
+  useFilteredItems: Combobox$1.useFilteredItems,
+  createItems: Combobox$1.createItems
+};
+var ICONS = {
+  start: "inbox",
+  "no-results": "search_off",
+  error: "error",
+  done: "check_circle",
+  "no-access": "lock",
+  // A pointer, not an empty inbox: the pane is waiting for a choice in the list beside it.
+  unselected: "left_click"
+};
+var MEDIA_STATUS = {
+  error: "error",
+  done: "success"
+};
+function announcedRole(kind, announce) {
+  if (announce === false) return void 0;
+  if (kind === "error") return announce ? "alert" : void 0;
+  if (announce || kind === "no-results" || kind === "done") return "status";
+  return void 0;
+}
+function titleTag(size, headingLevel) {
+  if (headingLevel) return `h${headingLevel}`;
+  if (size === "compact") return "p";
+  return "h2";
+}
+function textOf(node) {
+  if (typeof node === "string" || typeof node === "number") return String(node);
+  return null;
+}
+var EmptyStateContext = React4.createContext(null);
+var EmptyStateRoot = React4.forwardRef(function EmptyStateRoot2({ className, kind = "start", size = "standard", announce, children, ...props }, ref) {
+  const role = announcedRole(kind, announce);
+  const [copy, setCopy] = React4.useState({ title: null, description: null });
+  const [live, setLive] = React4.useState("");
+  const openedAsDone = React4.useRef(kind === "done");
+  const report = React4.useCallback((part, value) => {
+    setCopy((current) => current[part] === value ? current : { ...current, [part]: value });
+  }, []);
+  const message = [copy.title, copy.description].filter(Boolean).join(" ");
+  React4.useEffect(() => {
+    if (kind !== "done") openedAsDone.current = false;
+    if (!role || kind === "done" && openedAsDone.current) return;
+    const frame = requestAnimationFrame(() => setLive(message));
+    return () => cancelAnimationFrame(frame);
+  }, [kind, message, role]);
+  const context = React4.useMemo(() => ({ kind, size, report }), [kind, report, size]);
+  return /* @__PURE__ */ jsx(EmptyStateContext.Provider, { value: context, children: /* @__PURE__ */ jsxs("div", { ref, "data-kind": kind, "data-size": size, className: cn("EmptyState", className), ...props, children: [
+    role ? /* @__PURE__ */ jsx("span", { className: "visually-hidden", role, children: live }) : null,
+    children
+  ] }) });
+});
+var EmptyStateMedia = React4.forwardRef(function EmptyStateMedia2({ className, kind, custom, ...props }, ref) {
+  const state = React4.useContext(EmptyStateContext);
+  const tone = kind ?? state?.kind;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      "data-status": tone ? MEDIA_STATUS[tone] : void 0,
+      "data-custom": custom ? "" : void 0,
+      className: cn("EmptyStateMedia", className),
+      ...props
+    }
+  );
+});
+var EmptyStateTitle = React4.forwardRef(function EmptyStateTitle2({ className, size, headingLevel, children, ...props }, ref) {
+  const state = React4.useContext(EmptyStateContext);
+  const Tag = titleTag(size ?? state?.size ?? "standard", headingLevel);
+  const text = textOf(children);
+  React4.useLayoutEffect(() => {
+    state?.report("title", text);
+    return () => state?.report("title", null);
+  }, [state, text]);
+  return /* @__PURE__ */ jsx(Tag, { ref, className: cn("EmptyStateTitle", className), ...props, children });
+});
+var EmptyStateDescription = React4.forwardRef(
+  function EmptyStateDescription2({ className, children, ...props }, ref) {
+    const state = React4.useContext(EmptyStateContext);
+    const text = textOf(children);
+    React4.useLayoutEffect(() => {
+      state?.report("description", text);
+      return () => state?.report("description", null);
+    }, [state, text]);
+    return /* @__PURE__ */ jsx("p", { ref, className: cn("EmptyStateDescription", className), ...props, children });
+  }
+);
+var EmptyStateActions = React4.forwardRef(function EmptyStateActions2({ className, ...props }, ref) {
+  return /* @__PURE__ */ jsx("div", { ref, className: cn("EmptyStateActions", className), ...props });
+});
+function Glyph({ name }) {
+  return /* @__PURE__ */ jsx("span", { className: "material-symbols-outlined", "aria-hidden": "true", children: name });
+}
+var EmptyState = Object.assign(
+  React4.forwardRef(function EmptyState2({
+    className,
+    kind = "start",
+    size = "standard",
+    icon,
+    media,
+    title,
+    description,
+    actions,
+    headingLevel,
+    announce,
+    children,
+    ...props
+  }, ref) {
+    const showMedia = media !== void 0 || icon !== null;
+    return /* @__PURE__ */ jsxs(EmptyStateRoot, { ref, kind, size, announce, className, ...props, children: [
+      showMedia ? /* @__PURE__ */ jsx(EmptyStateMedia, { custom: media !== void 0, children: media !== void 0 ? media : typeof icon === "string" || icon === void 0 ? /* @__PURE__ */ jsx(Glyph, { name: typeof icon === "string" ? icon : ICONS[kind] }) : /* @__PURE__ */ jsx("span", { "aria-hidden": "true", children: icon }) }) : null,
+      /* @__PURE__ */ jsxs("div", { className: "EmptyStateText", children: [
+        /* @__PURE__ */ jsx(EmptyStateTitle, { headingLevel, children: title }),
+        description ? /* @__PURE__ */ jsx(EmptyStateDescription, { children: description }) : null
+      ] }),
+      actions ? /* @__PURE__ */ jsx(EmptyStateActions, { children: actions }) : null,
+      children
+    ] });
+  }),
+  {
+    Root: EmptyStateRoot,
+    Media: EmptyStateMedia,
+    Title: EmptyStateTitle,
+    Description: EmptyStateDescription,
+    Actions: EmptyStateActions
+  }
+);
+
+// src/custom/collection/collection-utils.ts
+var collators = /* @__PURE__ */ new Map();
+function collatorFor(locale) {
+  let collator = collators.get(locale);
+  if (!collator) {
+    collator = new Intl.Collator(locale, { numeric: true, sensitivity: "base" });
+    collators.set(locale, collator);
+  }
+  return collator;
+}
+function normalizeSearch(value) {
+  return value.normalize("NFKD").replace(/\p{M}/gu, "").toLowerCase();
+}
+function isEmptyValue(value) {
+  return value == null || value === "";
+}
+function fractionDigitsOf(currency) {
+  try {
+    return new Intl.NumberFormat("en", { style: "currency", currency }).resolvedOptions().maximumFractionDigits ?? 2;
+  } catch {
+    return 2;
+  }
+}
+function toMinor(value, digits) {
+  if (isEmptyValue(value)) return null;
+  const scale = 10n ** BigInt(digits);
+  const text = typeof value === "number" ? numberToDecimal(value) : String(value);
+  if (text == null) return null;
+  const match = text.trim().replace(/,/g, "").replace(/^\((.*)\)$/, "-$1").match(/^([+-])?(\d+)(?:\.(\d+))?$/);
+  if (!match) return null;
+  const sign = match[1] === "-" ? -1n : 1n;
+  const whole = BigInt(match[2] || "0");
+  const fracRaw = match[3] ?? "";
+  const frac = BigInt(fracRaw.padEnd(digits, "0").slice(0, digits) || "0");
+  let minor = whole * scale + frac;
+  const roundDigit = fracRaw.charAt(digits);
+  if (roundDigit && roundDigit >= "5") minor += 1n;
+  return minor * sign;
+}
+function numberToDecimal(value) {
+  if (!Number.isFinite(value)) return null;
+  const text = Object.is(value, -0) ? "-0" : String(value);
+  if (!/[eE]/.test(text)) return text;
+  return value.toLocaleString("en", { useGrouping: false, maximumFractionDigits: 20 });
+}
+function minorToDecimal(minor, digits) {
+  const sign = minor < 0n ? "-" : "";
+  const abs = minor < 0n ? -minor : minor;
+  const scale = 10n ** BigInt(digits);
+  const whole = abs / scale;
+  if (!digits) return `${sign}${whole}`;
+  const frac = (abs % scale).toString().padStart(digits, "0");
+  return `${sign}${whole}.${frac}`;
+}
+function compareDecimal(a, b) {
+  const places = Math.max(decimalPlaces(a), decimalPlaces(b));
+  const left = toMinor(a, places);
+  const right = toMinor(b, places);
+  if (left == null || right == null) return 0;
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+function decimalPlaces(value) {
+  const text = (typeof value === "number" ? numberToDecimal(value) : String(value)) ?? "";
+  const plain = text.replace(/,/g, "");
+  const dot = plain.indexOf(".");
+  return dot === -1 ? 0 : plain.length - dot - 1;
+}
+var DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+function calendarDate(value) {
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
+  if (typeof value === "string") {
+    const match = DATE_ONLY.exec(value);
+    if (match) return new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  return null;
+}
+function sortRows(items, kind, desc, locale) {
+  const collator = collatorFor(locale);
+  const sorted = [...items].sort((a, b) => {
+    const aEmpty = isEmptyValue(a.value);
+    const bEmpty = isEmptyValue(b.value);
+    if (aEmpty || bEmpty) {
+      if (aEmpty && bEmpty) return a.index - b.index;
+      return aEmpty ? 1 : -1;
+    }
+    const compared = comparePresent(a.value, b.value, kind, collator);
+    if (compared === 0) return a.index - b.index;
+    return desc ? -compared : compared;
+  });
+  return sorted.map((item) => item.row);
+}
+function comparePresent(a, b, kind, collator) {
+  if (kind === "number" || kind === "money" || kind === "percent") {
+    return compareDecimal(a, b);
+  }
+  if (kind === "date") {
+    const at = dateStamp(a);
+    const bt = dateStamp(b);
+    if (at == null || bt == null) return 0;
+    return at < bt ? -1 : at > bt ? 1 : 0;
+  }
+  if (kind === "boolean") return Number(Boolean(a)) - Number(Boolean(b));
+  return collator.compare(String(a), String(b));
+}
+function dateStamp(value) {
+  return calendarDate(value)?.getTime() ?? null;
+}
+function formatMoney(value, options) {
+  const digits = options.fractionDigits ?? fractionDigitsOf(options.currency);
+  const minor = toMinor(value, digits);
+  if (minor == null) return "";
+  return new Intl.NumberFormat(options.locale, {
+    style: "currency",
+    currency: options.currency,
+    minimumFractionDigits: digits,
+    maximumFractionDigits: digits,
+    currencySign: options.negative === "parens" ? "accounting" : "standard"
+  }).format(minorToDecimal(minor, digits));
+}
+function formatNumber(value, locale, fractionDigits) {
+  if (isEmptyValue(value)) return "";
+  const numeric = typeof value === "number" ? value : Number(String(value).replace(/,/g, ""));
+  if (!Number.isFinite(numeric)) return String(value);
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: fractionDigits,
+    maximumFractionDigits: fractionDigits ?? 20
+  }).format(numeric);
+}
+function formatPercent(value, locale) {
+  if (isEmptyValue(value)) return "";
+  const numeric = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(numeric)) return String(value);
+  return new Intl.NumberFormat(locale, { style: "percent", maximumFractionDigits: 2 }).format(numeric);
+}
+function formatDate(value, locale, dateFormat) {
+  const date = calendarDate(value);
+  if (!date) return "";
+  return new Intl.DateTimeFormat(locale, dateFormat ?? { dateStyle: "medium" }).format(date);
+}
+function isoDate(value) {
+  if (typeof value === "string" && DATE_ONLY.test(value)) return value;
+  const date = value instanceof Date ? value : calendarDate(value);
+  if (!date) return "";
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${date.getFullYear()}-${month}-${day}`;
+}
+function moneySearchForms(value, currency, locale, fractionDigits) {
+  const digits = fractionDigits ?? fractionDigitsOf(currency);
+  const minor = toMinor(value, digits);
+  if (minor == null) return [];
+  const plain = minorToDecimal(minor, digits);
+  const trimmed = plain.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
+  const formatted = formatMoney(plain, { locale, currency, fractionDigits: digits });
+  const grouped = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency,
+    minimumFractionDigits: digits,
+    maximumFractionDigits: digits
+  }).formatToParts(plain).filter((part) => part.type === "integer" || part.type === "group" || part.type === "decimal" || part.type === "fraction" || part.type === "minusSign").map((part) => part.value).join("");
+  return [plain, trimmed, grouped, formatted];
+}
+function searchHaystack(parts) {
+  return parts.filter((part) => part != null && part !== "").join(" ");
+}
+function searchMatches(query, haystack) {
+  const normalized = normalizeSearch(query).trim();
+  if (!normalized) return true;
+  const words = normalized.split(/\s+/);
+  const text = normalizeSearch(haystack).replace(/,/g, "");
+  return words.every((word) => text.includes(word.replace(/,/g, "")));
+}
+function sumMoney(values, fractionDigits) {
+  const currencies = new Set(values.map((value) => value.currency).filter(Boolean));
+  if (currencies.size > 1) return { currency: null, minor: null, mixed: true };
+  const currency = [...currencies][0] ?? null;
+  if (!currency) return { currency: null, minor: 0n, mixed: false };
+  const digits = fractionDigits ?? fractionDigitsOf(currency);
+  let total = 0n;
+  for (const value of values) {
+    const minor = toMinor(value.amount, digits);
+    if (minor != null) total += minor;
+  }
+  return { currency, minor: total, mixed: false };
+}
+function balanceOf(amounts, control, currency) {
+  const digits = fractionDigitsOf(currency);
+  const allocated = amounts.reduce((sum, amount) => sum + (toMinor(amount, digits) ?? 0n), 0n);
+  const target = toMinor(control, digits) ?? 0n;
+  const delta = target - allocated;
+  const tone = delta === 0n ? "balanced" : delta > 0n ? "under" : "over";
+  return { tone, allocated, control: target, delta, digits };
+}
+function pageBounds(pageIndex, pageSize, total) {
+  const size = pageSize > 0 ? pageSize : total || 1;
+  const pageCount = total === 0 ? 1 : Math.ceil(total / size);
+  const safe = Math.min(Math.max(0, pageIndex), pageCount - 1);
+  const start = total === 0 ? 0 : safe * size;
+  const end = Math.min(total, start + size);
+  return { pageIndex: safe, pageCount, start, end };
+}
+function pageFlat(entries, pageIndex, pageSize) {
+  const leaves = entries.filter((entry) => entry.kind === "leaf");
+  const bounds = pageBounds(pageIndex, pageSize, leaves.length);
+  const pageLeaves = new Set(leaves.slice(bounds.start, bounds.end));
+  const out = [];
+  let currentGroup = null;
+  let leavesBeforeGroupOnPage = 0;
+  let emittedGroup = false;
+  let groupHadLeaves = false;
+  const closeGroup = () => {
+    if (currentGroup && !emittedGroup && !groupHadLeaves) out.push(currentGroup);
+  };
+  for (const entry of entries) {
+    if (entry.kind === "group") {
+      closeGroup();
+      currentGroup = entry;
+      emittedGroup = false;
+      groupHadLeaves = false;
+      leavesBeforeGroupOnPage = 0;
+      continue;
+    }
+    groupHadLeaves = true;
+    if (!pageLeaves.has(entry)) {
+      if (!emittedGroup) leavesBeforeGroupOnPage += 1;
+      continue;
+    }
+    if (currentGroup && !emittedGroup) {
+      out.push({ ...currentGroup, continued: leavesBeforeGroupOnPage > 0 });
+      emittedGroup = true;
+    }
+    out.push(entry);
+  }
+  closeGroup();
+  return { entries: out, leafCount: leaves.length, bounds };
+}
+function treeVisibleIds(rows, getId, getChildren, matches) {
+  const visible = /* @__PURE__ */ new Set();
+  const walk = (row, ancestors) => {
+    const id = getId(row);
+    let childHit = false;
+    for (const child of getChildren(row) ?? []) {
+      if (walk(child, [...ancestors, id])) childHit = true;
+    }
+    if (matches(row) || childHit) {
+      visible.add(id);
+      for (const ancestor of ancestors) visible.add(ancestor);
+      return true;
+    }
+    return false;
+  };
+  for (const row of rows) walk(row, []);
+  return visible;
+}
+function countFacets(rows, valueOf) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = isEmptyValue(valueOf(row)) ? "" : String(valueOf(row));
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+function selectableIds(ids, rows, getRowId, canSelect, getSubRows) {
+  const known = /* @__PURE__ */ new Map();
+  const walk = (list) => {
+    for (const row of list) {
+      known.set(getRowId(row), row);
+      const children = getSubRows?.(row);
+      if (children) walk(children);
+    }
+  };
+  walk(rows);
+  return ids.filter((id) => {
+    const row = known.get(id);
+    return row != null && (canSelect?.(row) ?? true);
+  });
+}
+function hiddenSelectedCount(selectedIds, filteredIds) {
+  let hidden = 0;
+  for (const id of selectedIds) if (!filteredIds.has(id)) hidden += 1;
+  return hidden;
+}
+function sameSort(a, b) {
+  if (a == null || b == null) return a == null && b == null;
+  return a.id === b.id && a.desc === b.desc;
+}
+function nextSort(current, columnId, initial) {
+  const onColumn = current?.id === columnId;
+  let next;
+  if (!onColumn) next = { id: columnId, desc: false };
+  else if (!current?.desc) next = { id: columnId, desc: true };
+  else next = initial;
+  if (sameSort(next, current)) return { id: columnId, desc: false };
+  return next;
+}
+function useUnderWidth(token) {
+  const ref = React4.useRef(null);
+  const [under, setUnder] = React4.useState(false);
+  React4.useEffect(() => {
+    const node = ref.current;
+    if (!node) return;
+    const probe = document.createElement("div");
+    probe.style.width = `var(${token})`;
+    probe.style.position = "absolute";
+    probe.style.visibility = "hidden";
+    probe.style.pointerEvents = "none";
+    document.body.appendChild(probe);
+    const watch = () => {
+      if (probe.offsetWidth <= 0) return;
+      setUnder(node.clientWidth <= probe.offsetWidth);
+    };
+    const observer = new ResizeObserver(watch);
+    observer.observe(node);
+    observer.observe(probe);
+    watch();
+    return () => {
+      observer.disconnect();
+      probe.remove();
+    };
+  }, [token]);
+  return { ref, under };
+}
+
+export { Button, Combobox, EmptyState, Select, balanceOf, buttonPart, cn, cnState, collatorFor, compareDecimal, comparePresent, countFacets, formatDate, formatMoney, formatNumber, formatPercent, fractionDigitsOf, hiddenSelectedCount, isEmptyValue, isoDate, minorToDecimal, moneySearchForms, nextSort, pageBounds, pageFlat, searchHaystack, searchMatches, selectableIds, sortRows, styledPart, styledPartUnless, sumMoney, toMinor, treeVisibleIds, useUnderWidth };
+//# sourceMappingURL=chunk-M7KJASGK.js.map
+//# sourceMappingURL=chunk-M7KJASGK.js.map