@payfit/unity-components 2.46.13 → 2.46.14

package/dist/esm/components/menu/parts/MenuSeparator.js

@@ -0,0 +1,9 @@
+import { jsx as r } from "react/jsx-runtime";
+import { Separator as a } from "react-aria-components/Separator";
+function e() {
+  return /* @__PURE__ */ r(a, { className: "uy:h-[1px] uy:bg-surface-neutral-lowest uy:w-full uy:mt-100 uy:mb-100" });
+}
+e.displayName = "MenuSeparator";
+export {
+  e as MenuSeparator
+};

package/dist/esm/components/menu/parts/MenuTrigger.d.ts

@@ -0,0 +1,10 @@
+import { PropsWithChildren } from 'react';
+interface MenuTriggerProps {
+    className?: string;
+    asChild?: boolean;
+}
+export declare function MenuTrigger({ children, asChild, className, }: PropsWithChildren<MenuTriggerProps>): import("react/jsx-runtime").JSX.Element;
+export declare namespace MenuTrigger {
+    var displayName: string;
+}
+export {};

package/dist/esm/components/menu/parts/MenuTrigger.js

@@ -0,0 +1,14 @@
+import { jsx as o } from "react/jsx-runtime";
+import { Slot as m } from "@radix-ui/react-slot";
+import { Button as n } from "react-aria-components/Button";
+function i({
+  children: r,
+  asChild: t,
+  className: e
+}) {
+  return /* @__PURE__ */ o(t ? m : n, { className: e, children: r });
+}
+i.displayName = "MenuTrigger";
+export {
+  i as MenuTrigger
+};

package/dist/esm/components/menu/parts/RawMenuItem.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { MenuItemProps as MenuItemAriaComponentProps } from 'react-aria-components/Menu';
+import { DataAttributes } from '../../../types/DataAttributes.js';
+export interface MenuItemProps extends DataAttributes {
+    children?: MenuItemAriaComponentProps['children'];
+    href?: MenuItemAriaComponentProps['href'];
+    onAction?: MenuItemAriaComponentProps['onAction'];
+    isDisabled?: MenuItemAriaComponentProps['isDisabled'];
+    prefix?: ReactNode;
+    className?: string;
+}
+export declare const RawMenuItem: import('react').ForwardRefExoticComponent<MenuItemProps & {
+    children?: ReactNode | undefined;
+} & import('react').RefAttributes<HTMLDivElement>>;

package/dist/esm/components/menu/parts/RawMenuItem.js

@@ -0,0 +1,43 @@
+import { jsxs as n, jsx as d } from "react/jsx-runtime";
+import { forwardRef as l } from "react";
+import { uyTv as y } from "@payfit/unity-themes";
+import { MenuItem as c } from "react-aria-components/Menu";
+const f = y({
+  base: [
+    "uy:cursor-pointer uy:group",
+    "uy:flex uy:p-100 uy:items-start uy:gap-100 uy:rounded-25 uy:typography-body uy:text-content-neutral",
+    "uy:not-aria-disabled:data-[hovered=true]:bg-surface-neutral-hover",
+    "uy:not-aria-disabled:data-[pressed=true]:bg-surface-neutral-pressed",
+    "uy:active:bg-surface-neutral-active",
+    "uy:data-[focused=true]:not-data-[focus-visible=true]:outline-0 uy:data-[focus-visible=true]:outline-2 uy:data-[focus-visible=true]:outline-offset-2 uy:data-[focus-visible=true]:outline-utility-focus-ring",
+    "uy:aria-disabled:text-content-neutral-disabled uy:aria-disabled:cursor-not-allowed"
+  ]
+}), m = l(function({
+  prefix: e,
+  children: t,
+  href: u,
+  onAction: a,
+  className: r,
+  isDisabled: o,
+  ...s
+}, i) {
+  return /* @__PURE__ */ n(
+    c,
+    {
+      ref: i,
+      href: u,
+      isDisabled: o,
+      onAction: a,
+      className: f({ className: r }),
+      ...s,
+      children: [
+        /* @__PURE__ */ d("div", { className: "uy:text-content-neutral-low uy:group-aria-disabled:text-content-neutral-disabled", children: e || null }),
+        t
+      ]
+    }
+  );
+});
+m.displayName = "RawMenuItem";
+export {
+  m as RawMenuItem
+};

package/dist/esm/components/multi-select/MultiSelect.d.ts

@@ -0,0 +1,60 @@
+import { MultiSelectComponent } from './MultiselectTypes.js';
+/**
+ * The MultiSelect component allows users to select multiple items from a dropdown list.
+ * The component provides two different APIs:
+ * 1. Static API - For simple cases where options are defined as direct children and use primitive values as keys (strings or numbers)
+ * 2. Dynamic API - For data-driven cases where options are generated from a dynamic collection with typed objects
+ * @example
+ * ```tsx
+ * import { MultiSelect, MultiSelectOption, MultiSelectOptGroup } from '@payfit/unity-components'
+ *
+ * // Static API - Options defined as direct children
+ * <MultiSelect
+ *   placeholder="Select fruits..."
+ *   onChange={(selected) => console.log(selected)}
+ * >
+ *   <MultiSelectOptGroup label="Citrus" withSeparator>
+ *     <MultiSelectOption value="orange">Orange</MultiSelectOption>
+ *     <MultiSelectOption value="lemon">Lemon</MultiSelectOption>
+ *   </MultiSelectOptGroup>
+ *   <MultiSelectOption value="apple">Apple</MultiSelectOption>
+ * </MultiSelect>
+ *
+ * // Dynamic API - Options generated from a collection with typed objects
+ * interface Fruit {
+ *   id: string;
+ *   name: string;
+ *   category: string;
+ * }
+ *
+ * const fruits: Set<Fruit> = new Set([
+ *   { id: 'apple-1', name: 'Apple', category: 'Core' },
+ *   { id: 'orange-1', name: 'Orange', category: 'Citrus' }
+ * ]);
+ *
+ * <MultiSelect
+ *   items={fruits}
+ *   placeholder="Select fruits..."
+ *   value={new Set(['apple-1'])}
+ *   getItemValue={item => item.id}
+ *   renderValue={(items) =>
+ *     Array.from(items)
+ *       .map(item => item.name)
+ *       .join(', ')
+ *   }
+ * >
+ *   {(item) => (
+ *     <MultiSelectOption value={item.id}>
+ *       {item.name}
+ *     </MultiSelectOption>
+ *   )}
+ * </MultiSelect>
+ * ```
+ * @component
+ * @template TItems - The type of the items collection. Use `Set<T>` for flat lists or `Map<string, T[]>` for grouped lists. When omitted or undefined, the component uses the static API with React children.
+ * @remarks
+ * [API & Docs](https://unity-components.payfit.io/?path=/docs/inputs-multiselect--docs) • [Design Guidelines](https://www.payfit.design/24f360409/p/928776-multiselect)
+ */
+export declare const MultiSelect: MultiSelectComponent & {
+    displayName: string;
+};

package/dist/esm/components/multi-select/MultiSelect.js

@@ -0,0 +1,256 @@
+import { jsx as f, jsxs as ie, Fragment as fe } from "react/jsx-runtime";
+import { forwardRef as de, useMemo as I, useCallback as i, useRef as me } from "react";
+import { ComboboxProvider as Se, SelectProvider as q, useSelectContext as ye, useStoreState as pe } from "@ariakit/react";
+import { useComboboxFilter as he } from "./hooks/use-combobox-filter.js";
+import { useMultiSelectionState as Ve } from "./hooks/use-multiselection-state.js";
+import { MultiSelectContext as z } from "./Multiselect.context.js";
+import { MultiSelectButton as ge } from "./parts/MultiSelectButton.js";
+import { MultiSelectPopover as ve } from "./parts/MultiSelectPopover.js";
+function J(t) {
+  return t instanceof Map;
+}
+function Ie(t) {
+  return !Object.prototype.hasOwnProperty.call(t, "items");
+}
+function a(t) {
+  return String(t);
+}
+function b(t) {
+  return isNaN(Number(t)) ? t : Number(t);
+}
+function X(t) {
+  return Array.from(t, a);
+}
+function U(t) {
+  return new Set(X(t));
+}
+function W({
+  props: t,
+  ref: C,
+  content: r,
+  typedRenderValue: A,
+  selectedItemsForDisplay: O
+}) {
+  const K = ye(), P = pe(K, "open"), u = me(!1), {
+    placeholder: M,
+    isDisabled: c,
+    isReadOnly: y,
+    isLoading: p,
+    isInvalid: w,
+    onClearButtonPress: x,
+    onBlur: n,
+    onFocus: R,
+    ...j
+  } = t, h = i(() => {
+    P || !u.current && n && (u.current = !0, n());
+  }, [P, n]), d = i(() => {
+    u.current = !1, R?.();
+  }, [R]), V = i(() => {
+    setTimeout(() => {
+      const S = document.activeElement, g = K?.getState().contentElement;
+      g && S !== g && !g.contains(S) && !u.current && n && (u.current = !0, n());
+    }, 0);
+  }, [n, K]);
+  return /* @__PURE__ */ ie(fe, { children: [
+    /* @__PURE__ */ f(
+      ge,
+      {
+        ref: C,
+        placeholder: M,
+        isDisabled: c,
+        isReadOnly: y,
+        isLoading: p,
+        isInvalid: w,
+        renderValue: A,
+        selectedItems: O,
+        onClearButtonPress: x,
+        onBlur: h,
+        onFocus: d,
+        ...j
+      }
+    ),
+    /* @__PURE__ */ f(ve, { onBlur: V, children: r })
+  ] });
+}
+const be = (t, C) => {
+  const r = Ie(t), A = (e) => typeof e == "object" && e !== null && "value" in e && (typeof e.value == "string" || typeof e.value == "number") ? e.value : typeof e == "object" && e !== null && "id" in e && (typeof e.id == "string" || typeof e.id == "number") ? e.id : typeof e == "string" || typeof e == "number" ? e : String(e), P = r ? (e) => Array.from(e).map(String).join(", ") : (e) => Array.from(e).map((o) => A(o)).join(", "), u = t, M = t, c = I(
+    () => r ? void 0 : u.items,
+    [r, u.items]
+  ), y = r ? void 0 : u.getItemValue, { children: p } = r ? M : u, w = r ? void 0 : u.searchOptions, { children: x } = M, n = i(
+    (e) => r || !y ? A(e) : y(e),
+    [r, y]
+  ), {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    children: R,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getItemValue: j,
+    value: h,
+    defaultValue: d,
+    onChange: V,
+    isSearchable: S,
+    renderValue: g,
+    maxVisibleItems: N = 7
+  } = t, Y = g ?? P, v = i(() => r || !c ? [] : J(c) ? Array.from(c.values()).flat() : Array.from(c), [c, r]), Z = i(() => {
+    if ("value" in t)
+      return h ? U(h) : /* @__PURE__ */ new Set();
+  }, [t, h]), $ = i(() => d ? U(d) : /* @__PURE__ */ new Set(), [d]), ee = i(
+    (e) => {
+      if (!V) return;
+      const o = new Set(
+        Array.from(e).map((s) => b(s))
+      );
+      V(o);
+    },
+    [V]
+  ), {
+    selectedKeys: m,
+    selectKey: E,
+    unselectKey: T
+  } = Ve({
+    selectedKeys: Z(),
+    defaultSelectedKeys: $(),
+    onSelectionChange: ee
+  }), te = i(
+    (e) => {
+      E(a(e));
+    },
+    [E]
+  ), re = i(
+    (e) => {
+      T(a(e));
+    },
+    [T]
+  ), { setSearchQuery: ne, matchingItems: F } = he({
+    items: v(),
+    extractSearchableText: (e) => r ? [""] : [a(n(e))],
+    enabled: S,
+    searchOptions: w
+  }), oe = () => {
+    if (r) return Array.from(m);
+    const e = v();
+    return Array.from(m).map((o) => {
+      const s = e.find(
+        (l) => a(n(l)) === o
+      );
+      return s ? n(s) : b(o);
+    });
+  }, le = () => {
+    if (r)
+      return new Set(
+        Array.from(m).map((s) => b(s))
+      );
+    const e = v(), o = /* @__PURE__ */ new Set();
+    return Array.from(m).forEach((s) => {
+      const l = e.find(
+        (D) => a(n(D)) === s
+      );
+      l && o.add(l);
+    }), o;
+  }, se = () => {
+    if (d)
+      return X(d);
+  }, B = I(oe, [
+    m,
+    r,
+    n,
+    v
+  ]), G = I(le, [
+    m,
+    r,
+    n,
+    v
+  ]), L = I(se, [d]), _ = (e) => {
+    const o = new Set(e), s = new Set(B.map((l) => a(l)));
+    for (const l of o)
+      s.has(l) || te(b(l));
+    for (const l of s)
+      o.has(l) || re(b(l));
+  }, H = i(() => {
+    if (r)
+      return x;
+    if (!c) return null;
+    if (J(c)) {
+      const e = c;
+      return Array.from(e.entries()).map(
+        ([o, s]) => {
+          const l = s.filter(
+            (D) => F.some((ue) => {
+              const ce = n(D), ae = n(ue);
+              return a(ae) === a(ce);
+            })
+          );
+          return p(o, l);
+        }
+      );
+    }
+    return F.map(
+      (e) => p(e)
+    );
+  }, [
+    p,
+    c,
+    F,
+    x,
+    n,
+    r
+  ]), Q = I(() => H(), [H]), k = Y;
+  return S ? /* @__PURE__ */ f(Se, { resetValueOnHide: !0, setValue: ne, children: /* @__PURE__ */ f(
+    q,
+    {
+      value: B.map(
+        (e) => a(e)
+      ),
+      defaultValue: L,
+      setValue: _,
+      focusLoop: !0,
+      children: /* @__PURE__ */ f(
+        z.Provider,
+        {
+          value: { isSearchable: S, maxVisibleItems: N, selectedKeys: m },
+          children: /* @__PURE__ */ f(
+            W,
+            {
+              props: t,
+              ref: C,
+              content: Q,
+              typedRenderValue: k,
+              selectedItemsForDisplay: G
+            }
+          )
+        }
+      )
+    }
+  ) }) : /* @__PURE__ */ f(
+    q,
+    {
+      value: B.map(
+        (e) => a(e)
+      ),
+      defaultValue: L,
+      setValue: _,
+      focusLoop: !0,
+      children: /* @__PURE__ */ f(
+        z.Provider,
+        {
+          value: { isSearchable: S, maxVisibleItems: N, selectedKeys: m },
+          children: /* @__PURE__ */ f(
+            W,
+            {
+              props: t,
+              ref: C,
+              content: Q,
+              typedRenderValue: k,
+              selectedItemsForDisplay: G
+            }
+          )
+        }
+      )
+    }
+  );
+}, Ce = de(
+  be
+);
+Ce.displayName = "MultiSelect";
+export {
+  Ce as MultiSelect
+};

package/dist/esm/components/multi-select/Multiselect.context.d.ts

@@ -0,0 +1,7 @@
+interface MultiSelectContextType {
+    isSearchable?: boolean;
+    maxVisibleItems?: number;
+    selectedKeys?: Set<string>;
+}
+export declare const MultiSelectContext: import('react').Context<MultiSelectContextType>;
+export {};

package/dist/esm/components/multi-select/Multiselect.context.js

@@ -0,0 +1,8 @@
+import { createContext as e } from "react";
+const o = e({
+  isSearchable: !1,
+  selectedKeys: /* @__PURE__ */ new Set()
+});
+export {
+  o as MultiSelectContext
+};

package/dist/esm/components/multi-select/MultiselectTypes.d.ts

@@ -0,0 +1,114 @@
+import { UseComboboxFilterProps } from './hooks/use-combobox-filter.js';
+type Key = string | number;
+/**
+ * Common props shared by all MultiSelect variants.
+ */
+export interface MultiSelectBaseProps {
+    /** The ID of the element */
+    id?: string;
+    /** Default content when no value is selected */
+    placeholder?: string;
+    /** Whether the select is searchable and shows a search input on top of the options */
+    isSearchable?: boolean;
+    /** Whether the select is disabled */
+    isDisabled?: boolean;
+    /** Whether the select is invalid */
+    isInvalid?: boolean;
+    /** Whether the select is read only */
+    isReadOnly?: boolean;
+    /** Whether the select is in a loading state */
+    isLoading?: boolean;
+    /** Callback when the clear button is pressed */
+    onClearButtonPress?: () => void;
+    /** Maximum number of items to show in the select button before showing a counter badge */
+    maxVisibleItems?: number;
+    /** Callback when the select is focused */
+    onFocus?: () => void;
+    /** Callback when the select is blurred */
+    onBlur?: () => void;
+    /** The ID of the element that labels this select when no visible label is provided */
+    'aria-labelledby'?: string;
+    /** The ID of the element that labels this select when no visible label is provided */
+    'aria-label'?: string;
+}
+/**
+ * Props for flat (non-grouped) dynamic items MultiSelect.
+ * @template TItems The type of set of items.
+ */
+export interface FlatSelectProps<TItems extends Set<unknown>> extends MultiSelectBaseProps {
+    /** The items to display in the select */
+    items: TItems;
+    /** Function to get the value from an item, defaults to String(item) */ getItemValue?: (item: TItems extends Set<infer U> ? U : never) => Key;
+    /** The currently selected values (controlled mode) */
+    value?: Set<Key>;
+    /** The default selected values (uncontrolled mode) */
+    defaultValue?: Set<Key>;
+    /** Callback when the selection changes */
+    onChange?: (value: Set<Key>) => void;
+    /** Function to render the selected value(s) in the button */
+    renderValue?: (value: Set<TItems extends Set<infer U> ? U : never>) => string;
+    /** Children must be a render function that returns Option components */ children: (item: TItems extends Set<infer U> ? U : never) => React.JSX.Element;
+    /** Options for filtering the items */
+    searchOptions?: UseComboboxFilterProps<TItems extends Set<infer U> ? U : never>['searchOptions'];
+}
+/**
+ * Props for grouped dynamic items MultiSelect.
+ * @template TItems The type of map from group key to array of items.
+ */
+export interface GroupedSelectProps<TItems extends Map<string, unknown[]>> extends MultiSelectBaseProps {
+    /** The items to display in the select, grouped by category */
+    items: TItems;
+    /** Function to get the value from an item, defaults to String(item) */
+    getItemValue?: (item: TItems extends Map<string, Array<infer U>> ? U : never) => Key;
+    /** The currently selected values (controlled mode) */
+    value?: Set<Key>;
+    /** The default selected values (uncontrolled mode) */
+    defaultValue?: Set<Key>;
+    /** Callback when the selection changes */
+    onChange?: (value: Set<Key>) => void;
+    /** Function to render the selected value(s) in the button */
+    renderValue?: (value: Set<TItems extends Map<string, Array<infer U>> ? U : never>) => string;
+    /** Children must be a render function that returns OptGroup components */
+    children: (groupKey: string, items: TItems extends Map<string, Array<infer U>> ? U[] : never) => React.JSX.Element;
+    /** Options for filtering the items */
+    searchOptions?: UseComboboxFilterProps<TItems extends Map<string, Array<infer U>> ? U : never>['searchOptions'];
+}
+/**
+ * Props for static MultiSelect API (all items are defined via React children).
+ */
+export interface StaticItemsProps<TItem = Key> extends MultiSelectBaseProps {
+    /** The items to display in the select (for dynamic API) */
+    items?: never;
+    /** Function to get the value from an item, defaults to String(item) */
+    getItemValue?: never;
+    /** The currently selected values (controlled mode) */
+    value?: Set<TItem>;
+    /** The default selected values (uncontrolled mode) */
+    defaultValue?: Set<TItem>;
+    /** Callback when the selection changes */
+    onChange?: (value: Set<TItem>) => void;
+    /** Function to render the selected value(s) in the button */
+    renderValue?: (value: Set<TItem>) => string;
+    /** Children must be Option components */
+    children: React.ReactNode;
+    /** Options for filtering the items */
+    searchOptions?: UseComboboxFilterProps<TItem>['searchOptions'];
+}
+/**
+ * Helper type to simplify usage for dynamic MultiSelect props.
+ * Picks flat or grouped variant depending on items type.
+ */
+export type DynamicMultiSelectProps<TItems = Set<unknown> | Map<string, unknown[]>> = TItems extends Set<unknown> ? FlatSelectProps<TItems> : TItems extends Map<string, unknown[]> ? GroupedSelectProps<TItems> : never;
+/**
+ * Top-level MultiSelect props type, picks static or dynamic variant as appropriate.
+ */
+export type MultiSelectProps<TItems = Set<unknown> | Map<string, unknown[]> | undefined> = TItems extends undefined ? StaticItemsProps : DynamicMultiSelectProps<TItems>;
+/**
+ * MultiSelect component type signature.
+ */
+export type MultiSelectComponent = <TItems = undefined>(props: MultiSelectProps<TItems> & {
+    ref?: React.ForwardedRef<HTMLButtonElement>;
+} & {
+    displayName?: string;
+}) => React.JSX.Element;
+export {};

package/dist/esm/components/multi-select/TanstackMultiSelect.d.ts

@@ -0,0 +1,7 @@
+import { MultiSelectComponent, MultiSelectProps } from './MultiselectTypes.js';
+export type TanstackMultiSelectProps<TItems = undefined> = Omit<MultiSelectProps<TItems>, 'value' | 'defaultValue' | 'onChange' | 'onBlur' | 'isInvalid'> & {
+    children?: MultiSelectProps<TItems>['children'];
+};
+export declare const TanstackMultiSelect: MultiSelectComponent & {
+    displayName: string;
+};

package/dist/esm/components/multi-select/TanstackMultiSelect.js

@@ -0,0 +1,41 @@
+import { jsx as h } from "react/jsx-runtime";
+import { forwardRef as p } from "react";
+import { useFieldContext as C } from "../../hooks/tanstack-form-context.js";
+import { useFieldA11yContext as B } from "../form-field/TanstackFormField.context.js";
+import { MultiSelect as y } from "./MultiSelect.js";
+const S = (l, o) => {
+  const e = C(), t = B(), s = e.state.meta.isTouched && !e.state.meta.isValid, { onClearButtonPress: a, onFocus: i, isReadOnly: r, isDisabled: d, ...n } = l, u = (f) => {
+    e.handleChange(f);
+  }, c = () => {
+    e.handleBlur();
+  }, m = () => {
+    e.setValue(/* @__PURE__ */ new Set()), a && a();
+  };
+  return (
+    // @ts-expect-error - Typescript is not able to infer the type of the MultiSelect component
+    /* @__PURE__ */ h(
+      y,
+      {
+        ...n,
+        ref: o,
+        id: t.inputId || n.id,
+        value: e.state.value,
+        onChange: u,
+        onBlur: c,
+        onFocus: i,
+        onClearButtonPress: m,
+        isReadOnly: r,
+        isDisabled: d,
+        isInvalid: s,
+        "aria-labelledby": t.labelId
+      }
+    )
+  );
+}, b = p(
+  // @ts-expect-error - forwardRef struggles with generic components
+  S
+);
+b.displayName = "TanstackMultiSelect";
+export {
+  b as TanstackMultiSelect
+};

package/dist/esm/components/multi-select/hooks/use-combobox-filter.d.ts

@@ -0,0 +1,12 @@
+export interface UseComboboxFilterProps<T> {
+    items?: T[];
+    extractSearchableText?: (item: T) => string[];
+    enabled?: boolean;
+    searchOptions?: Intl.CollatorOptions;
+}
+export interface UseComboboxFilterReturn<T> {
+    searchQuery: string;
+    setSearchQuery: (value: string) => void;
+    matchingItems: T[];
+}
+export declare function useComboboxFilter<T>({ items, extractSearchableText, enabled, searchOptions, }: UseComboboxFilterProps<T>): UseComboboxFilterReturn<T>;

package/dist/esm/components/multi-select/hooks/use-combobox-filter.js

@@ -0,0 +1,22 @@
+import { useState as m, useMemo as l, startTransition as y } from "react";
+import { useFilter as b } from "react-aria-components/Autocomplete";
+function p({
+  items: e = [],
+  extractSearchableText: s = (t) => [String(t)],
+  enabled: n = !1,
+  searchOptions: c = { sensitivity: "base" }
+}) {
+  const [t, a] = m(""), o = b(c), i = o.contains.bind(o), u = (r) => {
+    y(() => {
+      a(r);
+    });
+  }, h = l(() => !n || t.length === 0 ? e : e.filter((r) => s(r).some((f) => i(f, t))), [n, e, t, s, i]);
+  return {
+    searchQuery: t,
+    setSearchQuery: u,
+    matchingItems: h
+  };
+}
+export {
+  p as useComboboxFilter
+};

package/dist/esm/components/multi-select/hooks/use-multiselection-state.d.ts

@@ -0,0 +1,14 @@
+interface UseMultiSelectionStateProps<V extends string | number = string> {
+    selectedKeys?: Set<V>;
+    defaultSelectedKeys?: Set<V>;
+    onSelectionChange?: (keys: Set<V>) => void;
+}
+interface UseMultiSelectionStateReturn<V extends string | number = string> {
+    selectedKeys: Set<V>;
+    isSelected: (key: V) => boolean;
+    selectKey: (key: V) => void;
+    unselectKey: (key: V) => void;
+    toggleKey: (key: V) => void;
+}
+export declare function useMultiSelectionState<V extends string | number = string>({ selectedKeys: controlledKeys, defaultSelectedKeys, onSelectionChange, }: UseMultiSelectionStateProps<V>): UseMultiSelectionStateReturn<V>;
+export {};