impact-nova 2.0.9 → 2.1.0-alpha.10

package/dist/components/forms/select/hooks/useSelectMenuHeight.js

@@ -0,0 +1,29 @@
+import { useState as g, useRef as h, useEffect as v } from "react";
+function b(u, f, m, o) {
+  const [l, c] = g(
+    void 0
+  ), t = h(0);
+  return v(() => {
+    if (t.current = 0, c(void 0), !u) return;
+    let n = null, r = null;
+    const s = () => {
+      const i = o.current;
+      if (!i) return !1;
+      const a = (e) => {
+        e > t.current && (t.current = e, c(e));
+      };
+      return n = new ResizeObserver((e) => {
+        for (const H of e)
+          a(H.contentRect.height);
+      }), n.observe(i), a(i.offsetHeight), !0;
+    }, M = requestAnimationFrame(() => {
+      s() || (r = setTimeout(s, 50));
+    });
+    return () => {
+      cancelAnimationFrame(M), r && clearTimeout(r), n?.disconnect();
+    };
+  }, [u, f, m, o]), l;
+}
+export {
+  b as useSelectMenuHeight
+};

package/dist/components/forms/select/hooks/useSelectMenuScroll.d.ts

@@ -0,0 +1,13 @@
+import { RefObject } from 'react';
+import { Virtualizer } from '@tanstack/react-virtual';
+import { FlatOption } from '../hooks/useFlattenOptions';
+export interface UseSelectMenuScrollParams {
+    isOpen: boolean;
+    isLoading?: boolean;
+    isProcessing: boolean;
+    flatOptions: FlatOption[];
+    listRef: RefObject<HTMLDivElement | null>;
+    rowVirtualizer: Virtualizer<HTMLDivElement, Element>;
+    onMenuScrollToBottom?: () => void;
+}
+export declare function useSelectMenuScroll({ isOpen, isLoading, isProcessing, flatOptions, listRef, rowVirtualizer, onMenuScrollToBottom, }: UseSelectMenuScrollParams): void;

package/dist/components/forms/select/hooks/useSelectMenuScroll.js

@@ -0,0 +1,43 @@
+import { useRef as x, useCallback as E, useEffect as s } from "react";
+function V({
+  isOpen: u,
+  isLoading: f,
+  isProcessing: a,
+  flatOptions: g,
+  listRef: c,
+  rowVirtualizer: m,
+  onMenuScrollToBottom: r
+}) {
+  const e = x(null), h = m.getVirtualItems(), l = h[h.length - 1], n = E(() => {
+    f || a || e.current || r && (r(), e.current = setTimeout(() => {
+      e.current = null;
+    }, 500));
+  }, [f, a, r]);
+  s(() => () => {
+    e.current && (clearTimeout(e.current), e.current = null);
+  }, []), s(() => {
+    if (!u || !c.current || !r)
+      return;
+    const t = c.current, i = () => {
+      const { scrollTop: d, scrollHeight: v, clientHeight: I } = t;
+      v - d - I <= 64 && n();
+    };
+    return t.addEventListener("scroll", i), i(), () => {
+      t.removeEventListener("scroll", i);
+    };
+  }, [u, c, r, n]), s(() => {
+    if (!u || !r || !l)
+      return;
+    const t = g.length - 1;
+    t < 0 || l.index < t - 1 || n();
+  }, [
+    u,
+    r,
+    g.length,
+    l,
+    n
+  ]);
+}
+export {
+  V as useSelectMenuScroll
+};

package/dist/components/forms/select/hooks/useSelectOpenEffects.d.ts

@@ -0,0 +1,26 @@
+import { MutableRefObject } from 'react';
+import { Virtualizer } from '@tanstack/react-virtual';
+import { FlatOption } from '../hooks/useFlattenOptions';
+import { SelectionModel } from '../hooks/useSelectionModel';
+import { Option } from '../select.types';
+export interface UseSelectOpenEffectsParams<OptionType extends Option> {
+    isOpen: boolean;
+    isSearchable: boolean;
+    searchPosition: string;
+    isReadOnly: boolean;
+    isLoading?: boolean;
+    isProcessing: boolean;
+    fetchError: unknown;
+    isMulti?: boolean;
+    isSelectAllEnabled: boolean;
+    flatOptions: FlatOption[];
+    searchValue: string;
+    highlightedIndex: number;
+    setHighlightedIndex: (index: number) => void;
+    openedViaKeyboardRef: MutableRefObject<boolean>;
+    scrollToSelectedOnOpen: boolean;
+    selectionModel: SelectionModel;
+    internalValue: OptionType | null | unknown;
+    rowVirtualizer: Virtualizer<HTMLDivElement, Element>;
+}
+export declare function useSelectOpenEffects<OptionType extends Option>({ isOpen, isSearchable, searchPosition, isReadOnly, isLoading, isProcessing, fetchError, isMulti, isSelectAllEnabled, flatOptions, searchValue, highlightedIndex, setHighlightedIndex, openedViaKeyboardRef, scrollToSelectedOnOpen, selectionModel, internalValue, rowVirtualizer, }: UseSelectOpenEffectsParams<OptionType>): void;

package/dist/components/forms/select/hooks/useSelectOpenEffects.js

@@ -0,0 +1,92 @@
+import { useEffect as L } from "react";
+import { SELECT_ALL_INDEX as N } from "../select.constants.js";
+import { hasSelectAllRow as X } from "../utils/getSelectableOptionIndices.js";
+function J({
+  isOpen: m,
+  isSearchable: F,
+  searchPosition: T,
+  isReadOnly: e,
+  isLoading: a,
+  isProcessing: t,
+  fetchError: I,
+  isMulti: n,
+  isSelectAllEnabled: _,
+  flatOptions: u,
+  searchValue: B,
+  highlightedIndex: C,
+  setHighlightedIndex: r,
+  openedViaKeyboardRef: A,
+  scrollToSelectedOnOpen: q,
+  selectionModel: f,
+  internalValue: x,
+  rowVirtualizer: c
+}) {
+  L(() => {
+    if (!m) {
+      r(-1);
+      return;
+    }
+    if (A.current) {
+      if (A.current = !1, F && T === "menu" && !e) {
+        r(-1);
+        return;
+      }
+      r(
+        X({
+          isLoading: !!a,
+          isProcessing: t,
+          fetchError: I,
+          isMulti: n,
+          isSelectAllEnabled: _,
+          isReadOnly: e,
+          flatOptionsLength: u.length
+        }) ? N : 0
+      );
+    }
+  }, [
+    m,
+    F,
+    T,
+    e,
+    a,
+    t,
+    I,
+    n,
+    _,
+    u.length,
+    A,
+    r
+  ]), L(() => {
+    C !== -1 && r(0);
+  }, [B]), L(() => {
+    if (!m)
+      return;
+    const v = requestAnimationFrame(() => {
+      c.measure();
+    });
+    return () => cancelAnimationFrame(v);
+  }, [m, c]), L(() => {
+    if (!m || !q || t || u.length === 0)
+      return;
+    const v = u.findIndex((E) => n ? f.mode === "exclude" ? !f.set.has(E.value) : f.set.has(E.value) : x?.value === E.value);
+    if (v === -1)
+      return;
+    const D = setTimeout(() => {
+      c.scrollToIndex(v, { align: "center" });
+    }, 50);
+    return () => clearTimeout(D);
+  }, [
+    m,
+    q,
+    t,
+    u,
+    n,
+    f.mode,
+    f.set,
+    x,
+    c
+  ]);
+}
+export {
+  J as useSelectOpenEffects
+};

package/dist/components/forms/select/hooks/useSelectOutsideScrollLock.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare function useSelectOutsideScrollLock(isOpen: boolean, menuRef: RefObject<HTMLDivElement | null>): void;

package/dist/components/forms/select/hooks/useSelectOutsideScrollLock.js

@@ -0,0 +1,23 @@
+import { useEffect as u } from "react";
+function s(r, o) {
+  u(() => {
+    if (!r)
+      return;
+    const e = (t) => {
+      const n = t.target;
+      n && o.current?.contains(n) || (t.preventDefault(), t.stopPropagation());
+    };
+    return document.addEventListener("scroll", e, !0), document.addEventListener("wheel", e, {
+      passive: !1,
+      capture: !0
+    }), document.addEventListener("touchmove", e, {
+      passive: !1,
+      capture: !0
+    }), () => {
+      document.removeEventListener("scroll", e, !0), document.removeEventListener("wheel", e, !0), document.removeEventListener("touchmove", e, !0);
+    };
+  }, [r, o]);
+}
+export {
+  s as useSelectOutsideScrollLock
+};

package/dist/components/forms/select/hooks/useSelectSearchFocus.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare function useSelectSearchFocus(isOpen: boolean, isSearchable: boolean, searchPosition: string, searchInputRef: RefObject<HTMLInputElement | null>): void;

package/dist/components/forms/select/hooks/useSelectSearchFocus.js

@@ -0,0 +1,19 @@
+import { useEffect as n } from "react";
+function i(t, r, u, e) {
+  n(() => {
+    if (!(t && r && u === "menu"))
+      return;
+    let c = !1;
+    const o = () => {
+      !c && e.current && e.current.focus();
+    };
+    requestAnimationFrame(o);
+    const m = setTimeout(o, 50);
+    return () => {
+      c = !0, clearTimeout(m);
+    };
+  }, [t, r, u, e]);
+}
+export {
+  i as useSelectSearchFocus
+};

package/dist/components/forms/select/hooks/useSelectSelectionHandlers.d.ts

@@ -0,0 +1,36 @@
+import { MouseEvent } from 'react';
+import { FlatOption } from '../hooks/useFlattenOptions';
+import { SelectionModel } from '../hooks/useSelectionModel';
+import { ActionMeta, Group, MultiValue, OnChangeValue, Option, SingleValue } from '../select.types';
+export interface SelectVisibleStats {
+    totalVisible: number;
+    selectedVisible: number;
+}
+export interface UseSelectSelectionHandlersParams<OptionType extends Option, IsMulti extends boolean, GroupType extends Group> {
+    isMulti?: boolean;
+    isDisabled?: boolean;
+    isReadOnly: boolean;
+    internalValue: SingleValue<OptionType> | MultiValue<OptionType>;
+    setInternalValue: (value: SingleValue<OptionType> | MultiValue<OptionType>) => void;
+    onChange?: (newValue: OnChangeValue<OptionType, IsMulti>, actionMeta: ActionMeta<OptionType>) => void;
+    onMenuClose?: (value?: OnChangeValue<OptionType, IsMulti>, selectionOrder?: string[]) => void;
+    onClearAll?: () => void;
+    enableSubMenus: boolean;
+    enableGroups: boolean;
+    enableInvertedSelection?: boolean;
+    maxSelectableOptions?: number;
+    closeMenuOnSelect: boolean;
+    options: (OptionType | GroupType)[];
+    flatOptions: FlatOption[];
+    searchValue: string;
+    selectionModel: SelectionModel;
+    visibleStats: SelectVisibleStats;
+    workerSelectAll: <T extends Option>(currentValue: MultiValue<T>, isInverted: boolean, maxSelectable?: number) => Promise<MultiValue<T>>;
+    setIsOpen: (open: boolean) => void;
+    setSearchValue: (value: string) => void;
+}
+export declare function useSelectSelectionHandlers<OptionType extends Option, IsMulti extends boolean, GroupType extends Group>(params: UseSelectSelectionHandlersParams<OptionType, IsMulti, GroupType>): {
+    handleSelect: (option: FlatOption | Option) => void;
+    handleSelectAll: () => Promise<void>;
+    clearValue: (event: MouseEvent) => void;
+};

package/dist/components/forms/select/hooks/useSelectSelectionHandlers.js

@@ -0,0 +1,248 @@
+import { hasSelectableFlatOptions as I, forEachSelectableFlatOption as v, collectSelectableFlatOptionValues as x } from "../utils/selectFlatOptions.js";
+import { isInvertedSelection as h, isOptionArray as V, getLeafOptions as M } from "../utils/select.js";
+function E(e) {
+  const r = (t, b) => {
+    e.onChange && e.onChange(t, b);
+  }, O = (t, b) => {
+    e.onChange && e.onChange(t, b);
+  };
+  return { handleSelect: (t) => {
+    if (!(e.isDisabled || e.isReadOnly || t.isDisabled || ("children" in t || "options" in t) && t.isParentSelectable === !1)) {
+      if (e.isMulti) {
+        const f = e.internalValue || [];
+        if ("children" in t || "options" in t) {
+          const c = M(
+            t,
+            e.enableSubMenus,
+            e.enableGroups
+          ).filter((l) => !l.isDisabled);
+          if (h(f)) {
+            const l = f.excludedValues, s = c.every(
+              (i) => !l.includes(i.value)
+            );
+            let n = [...l];
+            s ? c.forEach((i) => {
+              n.includes(i.value) || n.push(i.value);
+            }) : n = n.filter(
+              (i) => !c.some((d) => d.value === i)
+            );
+            const u = {
+              isAllSelected: !0,
+              excludedValues: n
+            };
+            e.setInternalValue(u), r(u, {
+              action: "select-option",
+              option: t
+            });
+          } else if (V(f)) {
+            const l = f, s = c.every(
+              (u) => l.some((i) => i.value === u.value)
+            );
+            let n = [...l];
+            if (s ? n = n.filter(
+              (u) => !c.some((i) => i.value === u.value)
+            ) : c.forEach((u) => {
+              n.some((i) => i.value === u.value) || n.push(u);
+            }), e.maxSelectableOptions && n.length > e.maxSelectableOptions)
+              return;
+            e.setInternalValue(n), r(n, {
+              action: "select-option",
+              option: t
+            });
+          }
+        } else if (h(f)) {
+          const o = f.excludedValues, c = o.includes(t.value), s = {
+            isAllSelected: !0,
+            excludedValues: c ? o.filter((n) => n !== t.value) : [...o, t.value]
+          };
+          e.setInternalValue(s), r(s, {
+            action: c ? "select-option" : "deselect-option",
+            option: t
+          });
+        } else if (V(f)) {
+          const o = f, c = e.selectionModel.mode === "exclude" ? !e.selectionModel.set.has(t.value) : e.selectionModel.set.has(t.value);
+          let l = [];
+          if (c)
+            l = o.filter((s) => s.value !== t.value);
+          else {
+            if (e.maxSelectableOptions && o.length >= e.maxSelectableOptions)
+              return;
+            l = [...o, t];
+          }
+          e.setInternalValue(l), r(l, {
+            action: c ? "deselect-option" : "select-option",
+            option: t
+          });
+        }
+        return;
+      }
+      if (e.setInternalValue(t), O(t, {
+        action: "select-option",
+        option: t
+      }), e.closeMenuOnSelect) {
+        e.setIsOpen(!1);
+        const f = t;
+        e.onMenuClose?.(f, void 0), e.setSearchValue("");
+      }
+    }
+  }, handleSelectAll: async () => {
+    if (!e.isMulti || e.isDisabled || e.isReadOnly)
+      return;
+    if (e.options.length > 3e3) {
+      try {
+        const l = await e.workerSelectAll(
+          e.internalValue,
+          h(e.internalValue),
+          e.maxSelectableOptions
+        );
+        e.setInternalValue(l), r(l, { action: "select-option" });
+      } catch {
+      }
+      return;
+    }
+    if (e.searchValue) {
+      if (!I(e.flatOptions))
+        return;
+      const l = e.internalValue || [], { totalVisible: s, selectedVisible: n } = e.visibleStats, u = s > 0 && s === n;
+      if (h(l)) {
+        let d = [...l.excludedValues];
+        if (u)
+          v(e.flatOptions, (S) => {
+            d.includes(S.value) || d.push(S.value);
+          });
+        else {
+          const S = x(
+            e.flatOptions
+          );
+          d = d.filter((w) => !S.has(w));
+        }
+        const a = {
+          isAllSelected: !0,
+          excludedValues: d
+        };
+        e.setInternalValue(a), r(a, { action: "select-option" });
+      } else if (V(l)) {
+        let i = [...l];
+        if (u) {
+          const d = x(
+            e.flatOptions
+          );
+          i = i.filter((a) => !d.has(a.value));
+        } else {
+          const d = new Set(i.map((a) => a.value));
+          v(e.flatOptions, (a) => {
+            d.has(a.value) || (i.push(a), d.add(a.value));
+          });
+        }
+        if (e.maxSelectableOptions && i.length > e.maxSelectableOptions)
+          return;
+        e.setInternalValue(i), r(i, {
+          action: "select-option"
+        });
+      }
+      return;
+    }
+    if (e.maxSelectableOptions) {
+      const l = e.internalValue, { totalVisible: s } = e.visibleStats, n = V(l) ? l.length : 0, u = Math.min(s, e.maxSelectableOptions);
+      if (V(l) && n >= u && n > 0) {
+        const i = l.filter((d) => d.isDisabled);
+        e.setInternalValue(i), r(i, { action: "select-option" });
+      } else if (V(l)) {
+        const i = l.filter((a) => a.isDisabled);
+        let d = i.length;
+        for (const a of e.flatOptions) {
+          if (d >= e.maxSelectableOptions)
+            break;
+          a.isGroup || a.isSubmenuParent || a.isDisabled || (i.push(a), d += 1);
+        }
+        e.setInternalValue(i), r(i, { action: "select-option" });
+      }
+      return;
+    }
+    const t = e.internalValue, b = h(t) && t.excludedValues.length === 0;
+    if (e.enableInvertedSelection) {
+      if (b) {
+        const l = V(t) ? t.filter((s) => s.isDisabled) : [];
+        e.setInternalValue(l), r(l, { action: "select-option" });
+      } else {
+        const s = {
+          isAllSelected: !0,
+          excludedValues: e.flatOptions.filter(
+            (n) => n.isDisabled && (V(t) ? !t.some((u) => u.value === n.value) : !0)
+          ).map((n) => n.value)
+        };
+        e.setInternalValue(s), r(s, { action: "select-option" });
+      }
+      return;
+    }
+    const { totalVisible: f, selectedVisible: o } = e.visibleStats;
+    if (f > 0 && f === o) {
+      const l = V(t) ? t.filter((s) => s.isDisabled) : [];
+      e.setInternalValue(l), r(l, { action: "select-option" });
+      return;
+    }
+    const c = V(t) ? t.filter((l) => l.isDisabled) : [];
+    v(e.flatOptions, (l) => {
+      c.push(l);
+    }), e.setInternalValue(c), r(c, { action: "select-option" });
+  }, clearValue: (t) => {
+    if (t.stopPropagation(), e.isReadOnly)
+      return;
+    if (e.isMulti) {
+      const o = [], c = (s) => {
+        for (const n of s) {
+          if (e.enableGroups && "options" in n) {
+            c(
+              n.options
+            );
+            continue;
+          }
+          if (e.enableSubMenus && "children" in n && Array.isArray(n.children)) {
+            c(n.children);
+            continue;
+          }
+          const u = n;
+          u.isDisabled && (e.selectionModel.mode === "exclude" ? !e.selectionModel.set.has(u.value) : e.selectionModel.set.has(u.value)) && o.push(u);
+        }
+      };
+      c(e.options);
+      const l = o;
+      e.setInternalValue(l), r(l, { action: "clear" }), e.onClearAll?.();
+      return;
+    }
+    const b = e.internalValue;
+    if (b) {
+      let o;
+      const c = (l) => {
+        for (const s of l) {
+          if (o)
+            return;
+          if (e.enableGroups && "options" in s) {
+            if (c(
+              s.options
+            ), o)
+              return;
+            continue;
+          }
+          if (e.enableSubMenus && "children" in s && Array.isArray(s.children)) {
+            if (c(s.children), o)
+              return;
+            continue;
+          }
+          const n = s;
+          if (n.value === b.value) {
+            o = n;
+            return;
+          }
+        }
+      };
+      if (c(e.options), o?.isDisabled)
+        return;
+    }
+    const f = null;
+    e.setInternalValue(f), O(f, { action: "clear" }), e.onClearAll?.();
+  } };
+}
+export {
+  E as useSelectSelectionHandlers
+};

package/dist/components/forms/select/hooks/useSelectValueState.d.ts

@@ -0,0 +1,19 @@
+import { Option, PropsValue } from '../select.types';
+export interface UseSelectValueStateParams<OptionType> {
+    value: PropsValue<OptionType> | undefined;
+    defaultValue: PropsValue<OptionType> | undefined;
+    isMulti: boolean;
+    onChange?: unknown;
+}
+export interface UseSelectValueStateResult<OptionType> {
+    usesMenuSession: boolean;
+    currentValue: PropsValue<OptionType>;
+    setCurrentValue: (next: PropsValue<OptionType>) => void;
+    beginMenuSession: () => void;
+    endMenuSession: () => PropsValue<OptionType> | undefined;
+}
+/**
+ * Controlled selects without `onChange` keep edits in a menu session so
+ * `onMenuClose` can batch-commit without stale `value` props.
+ */
+export declare function useSelectValueState<OptionType extends Option = Option>({ value, defaultValue, isMulti, onChange, }: UseSelectValueStateParams<OptionType>): UseSelectValueStateResult<OptionType>;

package/dist/components/forms/select/hooks/useSelectValueState.js

@@ -0,0 +1,41 @@
+import { useState as i, useRef as v, useCallback as r } from "react";
+import { cloneSelectValue as M } from "../utils/select.js";
+function h({
+  value: c,
+  defaultValue: V,
+  isMulti: s,
+  onChange: f
+}) {
+  const u = c !== void 0, e = u && f === void 0, [S, d] = i(
+    V ?? (s ? [] : null)
+  ), [a, l] = i(null), o = v(null), t = u ? c : S, m = e && a !== null ? a : t, p = r(
+    (n) => {
+      if (!u) {
+        d(n);
+        return;
+      }
+      e && (o.current = n, l(n));
+    },
+    [u, e]
+  ), C = r(() => {
+    if (!e)
+      return;
+    const n = M(t, s);
+    o.current = n, l(n);
+  }, [e, t, s]), b = r(() => {
+    if (!e)
+      return;
+    const n = o.current ?? t;
+    return o.current = null, l(null), n;
+  }, [e, t]);
+  return {
+    usesMenuSession: e,
+    currentValue: m,
+    setCurrentValue: p,
+    beginMenuSession: C,
+    endMenuSession: b
+  };
+}
+export {
+  h as useSelectValueState
+};

package/dist/components/forms/select/hooks/useSelectionModel.d.ts

@@ -0,0 +1,6 @@
+import { Option, SingleValue, MultiValue } from '../select.types';
+export interface SelectionModel {
+    mode: "include" | "exclude";
+    set: Set<string>;
+}
+export declare const useSelectionModel: <OptionType extends Option>(internalValue: SingleValue<OptionType> | MultiValue<OptionType>, isMulti: boolean) => SelectionModel;

package/dist/components/forms/select/hooks/useVisibleStats.d.ts

@@ -0,0 +1,16 @@
+import { Option, Group, SingleValue, MultiValue } from '../select.types';
+import { FlatOption } from './useFlattenOptions';
+import { SelectionModel } from './useSelectionModel';
+interface VisibleStats {
+    totalVisible: number;
+    selectedVisible: number;
+}
+interface GroupStats {
+    selected: number;
+    total: number;
+}
+export declare const useVisibleStats: <OptionType extends Option>(flatOptions: FlatOption[], totalOptionsCount: number, searchValue: string, selectionModel: SelectionModel, internalValue: SingleValue<OptionType> | MultiValue<OptionType>, isMulti: boolean) => {
+    stats: VisibleStats;
+    getGroupStats: (item: Option | Group) => GroupStats;
+};
+export {};

package/dist/components/forms/select/hooks/useVisibleStats.js

@@ -0,0 +1,54 @@
+import { useMemo as h, useRef as g, useEffect as D } from "react";
+const z = (c, f, o, u, b, v) => {
+  const n = h(() => {
+    const t = /* @__PURE__ */ new Set();
+    if (c.length > 0)
+      for (const r of c)
+        r.isDisabled && t.add(r.value);
+    return t;
+  }, [c]), S = h(() => {
+    let t = 0, r = 0;
+    const { mode: a, set: l } = u;
+    if (!o && c.length > 0 && f > 0) {
+      let s = 0;
+      if (a === "include")
+        for (const e of n)
+          l.has(e) && s++;
+      else {
+        let e = 0;
+        for (const d of n)
+          l.has(d) && e++;
+        s = n.size - e;
+      }
+      t = f + s, a === "include" ? r = l.size : r = c.length - l.size;
+    } else
+      for (const s of c)
+        if (!s.isGroup && !s.isSubmenuParent) {
+          const e = a === "exclude" ? !l.has(s.value) : l.has(s.value);
+          (!s.isDisabled || e) && (t++, e && r++);
+        }
+    return { totalVisible: t, selectedVisible: r };
+  }, [
+    c,
+    u,
+    f,
+    o,
+    n
+  ]), i = g(/* @__PURE__ */ new Map());
+  return D(() => {
+    i.current.clear();
+  }, [c, u]), { stats: S, getGroupStats: (t) => {
+    if (i.current.has(t))
+      return i.current.get(t);
+    let r = 0, a = 0;
+    const l = (e) => {
+      "options" in e ? e.options.forEach(l) : "children" in e && Array.isArray(e.children) ? e.children.forEach(l) : e.isDisabled || (a++, (v ? u.mode === "exclude" ? !u.set.has(e.value) : u.set.has(e.value) : b?.value === e.value) && r++);
+    };
+    l(t);
+    const s = { selected: r, total: a };
+    return i.current.set(t, s), s;
+  } };
+};
+export {
+  z as useVisibleStats
+};