@viasat/beam-react 2.0.0

package/lib/Autocomplete/Autocomplete.es.js

@@ -0,0 +1,308 @@
+import { jsxs as C, jsx as i } from "react/jsx-runtime";
+import Je, { useCallback as Qe, useState as Ue, useMemo as O, useRef as Xe, createElement as Ye } from "react";
+import { g as Ze } from "../../chunks/classNames.DNsS4J__.js";
+import { t as et } from "../../chunks/constants.BBi77pmH.js";
+import { s as r } from "../../chunks/combobox.module.DNJ3sGlK.js";
+import L from "clsx";
+import { b as tt, H as ot } from "../../chunks/form.context.CNWjF5qA.js";
+import { LabelProvider as st } from "../Form/contexts/label.context.es.js";
+import { HelperTextProvider as rt } from "../Form/contexts/helperText.context.es.js";
+import { ActionList as T } from "../ActionList/ActionList.es.js";
+import { useCreateOptionsContext as lt, OptionsProvider as it } from "../_Options/Option.context.es.js";
+import { Option as at } from "../_Options/Option.es.js";
+import { useSelectValue as nt } from "../_Options/useSelectValue.es.js";
+import { useAutocompleteDropdown as dt } from "./useAutocompleteDropdown.es.js";
+import { AutocompleteDropdown as ct } from "./AutocompleteDropdown.es.js";
+import { useAutocompleteChips as pt } from "./useAutocompleteChips.es.js";
+import { useAutocompleteKeyboardManager as ut } from "./useAutocompleteKeyboardManager.es.js";
+import { shouldFilterOption as mt } from "./utils/filterOptions.es.js";
+import { useClearSelection as ft } from "./useClearSelection.es.js";
+import { AutocompleteField as bt } from "./AutocompleteField.es.js";
+import { useAutocompleteA11y as ht } from "./useAutocompleteA11y.es.js";
+import { useAutocompleteInteractions as xt } from "./useAutocompleteInteractions.es.js";
+import { createSelectionStrategy as yt } from "../_Options/strategies/SelectionStrategy.es.js";
+import { OptionChips as vt } from "../_Options/OptionChips.es.js";
+const { baseClassNamePrefix: Ct, subElementClassPrefix: R, classModifierPrefix: a } = Ze("combobox"), Ot = Je.forwardRef(
+  ({
+    theme: P,
+    width: K,
+    error: d,
+    children: G,
+    label: W = null,
+    contentBefore: _,
+    contentAfter: z,
+    fluid: J = !1,
+    helperText: k = null,
+    validationRules: Q = [],
+    className: U,
+    hideRequiredMarker: X = !1,
+    disabled: Y = !1,
+    readOnly: Z = !1,
+    required: ee = !1,
+    placeholder: te = "",
+    onChange: f,
+    noResultsText: oe = "No results found",
+    optionFilter: g,
+    ...b
+  }, se) => {
+    const {
+      id: w,
+      name: re,
+      "aria-describedby": le,
+      multiple: o = !1,
+      clearable: ie = o,
+      ...ae
+    } = b, { showErrors: ne, isInvalid: de, errorShown: ce, disabled: s, readOnly: l, required: I } = tt({
+      name: re,
+      validationRules: Q,
+      disabledProp: Y,
+      readOnlyProp: Z,
+      requiredProp: ee
+    }), { aria: h, ids: pe } = ht({
+      helperText: k,
+      externalDescribedBy: le,
+      error: d,
+      errorShown: ce,
+      invalid: !!d || de
+    }), { helperTextId: ue, errorId: me, validationErrorsId: fe, labelId: A } = pe, be = !!(d != null && d.length), he = Qe(
+      (t) => {
+        f == null || f(t);
+      },
+      [f]
+    ), {
+      value: c,
+      setValue: E,
+      selectProps: xe,
+      handleBlur: ye,
+      singleValue: S
+    } = nt({ onChange: he, ...b }, se), [p, $] = Ue(null), N = !p && (!c || Array.isArray(c) && !c.length), {
+      optionsContext: ve,
+      optionIds: n,
+      optionsProps: u,
+      selectedOptionsProps: B,
+      deselectOptionValue: M,
+      getOptionByIndex: Ce
+    } = lt(c, E, o), Oe = O(() => {
+      if (!S) return;
+      const t = n.map((e) => u.get(e)).findIndex((e) => (e == null ? void 0 : e.value) === S);
+      return t !== -1 ? t : void 0;
+    }, [n, u, S]), D = Xe(null), {
+      getFieldProps: Pe,
+      getInputProps: ge,
+      dropdownProps: Ie,
+      refs: Ae,
+      open: V,
+      setOpen: x,
+      status: Se,
+      setDisplayActiveIndex: $e
+    } = dt({
+      disabled: s,
+      readOnly: l,
+      lastSelectedOptionIndex: Oe,
+      fieldRef: D
+    }), y = Ae.domReference, Ne = L(
+      r[Ct],
+      P && et(P),
+      J && r[`${a}fluid`],
+      h.invalid && r[`${a}error`],
+      s && r[`${a}disabled`],
+      l && r[`${a}read-only`],
+      N && r[`${a}empty`],
+      o && r[`${a}multiple`],
+      r[`${a}autocomplete`],
+      r[`${a}dropdown-${Se}`],
+      U
+    ), { canClear: Be, handleClear: De } = ft({
+      multiple: o,
+      clearable: ie,
+      isEmpty: N,
+      disabled: s,
+      readOnly: l,
+      setValue: E,
+      setSearchText: $,
+      inputRef: y,
+      setOpen: x
+    }), {
+      chipGroupProps: Fe,
+      handleBlur: Re,
+      selectedChip: ke,
+      setSelectedChip: we,
+      enabled: Ee,
+      selectPreviousChip: Me,
+      selectNextChip: Ve,
+      options: qe,
+      deselectOptionValue: He
+    } = pt({
+      multiple: o,
+      disabled: s,
+      readOnly: l,
+      open: V,
+      setOpen: x,
+      options: B,
+      deselectOptionValue: M,
+      fieldRef: D,
+      inputRef: y
+    }), { getKeyboardProps: q } = ut({
+      multiple: o,
+      disabled: s,
+      readOnly: l,
+      open: V,
+      setOpen: x,
+      inputRef: y,
+      fieldRef: D,
+      chips: {
+        enabled: Ee,
+        selectedChip: ke,
+        setSelectedChip: we,
+        selectPreviousChip: Me,
+        selectNextChip: Ve,
+        options: qe,
+        deselectOptionValue: He
+      }
+    }), H = O(
+      () => yt(o),
+      [o]
+    ), { handleBlur: Le, handleFocus: Te, handleItemClick: je } = xt({
+      selectionStrategy: H,
+      selectedOptions: B,
+      inputRef: y,
+      blurSelect: ye,
+      blurChips: Re,
+      setSearchText: $,
+      setOpen: x,
+      searchText: p,
+      getOptionByIndex: Ce,
+      setDisplayActiveIndex: $e
+    }), F = O(
+      () => n.reduce((t, e) => {
+        const m = u.get(e);
+        if (!m) return t;
+        const v = g ? g(m, p) : mt(m, p);
+        return t[e] = v, t;
+      }, {}),
+      [n, u, p, g]
+    ), Ke = O(() => n.every((t) => F[t]), [n, F]), { ref: Ge, ...We } = q(Pe()), _e = q(ge());
+    return /* @__PURE__ */ C(it, { value: ve, children: [
+      /* @__PURE__ */ C("div", { className: Ne, style: { maxWidth: K }, children: [
+        /* @__PURE__ */ i(
+          st,
+          {
+            ctxHtmlFor: w,
+            ctxDisabled: s,
+            ctxRequired: I && !X,
+            ctxId: A,
+            children: W
+          }
+        ),
+        /* @__PURE__ */ i(
+          bt,
+          {
+            id: w,
+            disabled: s,
+            readOnly: l,
+            required: I,
+            contentBefore: _,
+            contentAfter: z,
+            chips: /* @__PURE__ */ i(
+              vt,
+              {
+                multiple: o,
+                disabled: s,
+                readOnly: l,
+                selectedOptions: B,
+                deselectOptionValue: M,
+                chipGroupProps: Fe,
+                input: /* @__PURE__ */ i(
+                  "input",
+                  {
+                    className: r[`${R}field__input`],
+                    "aria-readonly": l,
+                    "aria-disabled": s,
+                    "aria-required": I,
+                    "aria-invalid": h.invalid,
+                    "aria-errormessage": h.errorMessage || void 0,
+                    "aria-labelledby": !b.ariaLabel && A ? A : void 0,
+                    "aria-label": b.ariaLabel,
+                    "aria-describedby": h.describedBy,
+                    placeholder: o && !N ? "" : te,
+                    onChange: (t) => $(t.target.value),
+                    disabled: s,
+                    readOnly: l,
+                    autoComplete: "off",
+                    tabIndex: s ? -1 : 0,
+                    autoFocus: !1,
+                    ..._e
+                  }
+                )
+              }
+            ),
+            hasClearButton: Be,
+            onClear: De,
+            onBlur: Le,
+            onFocusCapture: Te,
+            ...We,
+            ref: Ge
+          }
+        ),
+        /* @__PURE__ */ C(rt, { ctxId: ue, ctxDisabled: s, children: [
+          k,
+          be && /* @__PURE__ */ i(ot, { id: me, appearance: "negative", children: d })
+        ] }),
+        ne(fe)
+      ] }),
+      /* @__PURE__ */ C("select", { ...ae, ...xe, hidden: !0, multiple: o, children: [
+        /* @__PURE__ */ i("option", { value: "", children: "empty" }),
+        G
+      ] }),
+      /* @__PURE__ */ i(
+        ct,
+        {
+          ...Ie,
+          className: r[`${R}dropdown`],
+          disabled: s,
+          readOnly: l,
+          theme: P,
+          multiple: o,
+          onItemClick: je,
+          children: /* @__PURE__ */ i(
+            T,
+            {
+              role: "listbox",
+              noResults: Ke ? oe : void 0,
+              children: n.map((t) => {
+                const e = u.get(t);
+                if (!e) return null;
+                const m = H.isSelected(
+                  e.value,
+                  c
+                ), v = F[t], ze = v || e.disabled;
+                return /* @__PURE__ */ Ye(
+                  T.Item,
+                  {
+                    ...e,
+                    className: L(
+                      r[`${R}option`],
+                      e.className
+                    ),
+                    disabled: ze,
+                    hidden: v,
+                    defaultSelected: m,
+                    key: `opt-${e.value ?? e.label}`,
+                    kind: o ? "checkbox" : "singleCheckMark",
+                    role: "option"
+                  }
+                );
+              })
+            }
+          )
+        }
+      )
+    ] });
+  }
+), j = Ot;
+j.Option = at;
+j.displayName = "Autocomplete";
+export {
+  j as Autocomplete,
+  j as default
+};

package/lib/Autocomplete/Autocomplete.types.cjs.js

@@ -0,0 +1 @@
+"use strict";

package/lib/Autocomplete/Autocomplete.types.d.ts

@@ -0,0 +1,24 @@
+import { FloatingContext, UseInteractionsReturn } from '@floating-ui/react';
+import { CSSProperties, MutableRefObject } from 'react';
+import { ThemeTypes } from '@viasat/beam-shared/utils';
+export interface AutocompleteDropdownProps {
+    isMounted: boolean;
+    status: string;
+    nodeId: string;
+    context: FloatingContext;
+    getFloatingProps: UseInteractionsReturn['getFloatingProps'];
+    floatingStyles: CSSProperties;
+    labelsRef: MutableRefObject<string[]>;
+    elementsRef: MutableRefObject<HTMLElement[]>;
+    getItemProps: UseInteractionsReturn['getItemProps'];
+    setOpen: (open: boolean) => void;
+    setFloating: (node: HTMLElement | null) => void;
+    activeIndex: number | null;
+    onItemClick?: (index: number) => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    theme?: ThemeTypes;
+    className?: string;
+    children?: React.ReactNode;
+    multiple?: boolean;
+}

package/lib/Autocomplete/Autocomplete.types.es.js

@@ -0,0 +1 @@
+

package/lib/Autocomplete/AutocompleteDropdown.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("react/jsx-runtime"),r=require("@floating-ui/react"),B=require("../Box/Box.cjs.js"),C=require("clsx"),a=require("../../chunks/classNames.DAeKwerT.js"),P=require("../../chunks/constants.hwjHOsvT.js"),v=require("../ActionList/ActionList.context.cjs.js"),y=require("react"),A=require("../../chunks/floatingui.module.D3Aw_aYe.js"),O=require("../../chunks/popover.module.Dum8SaSU.js");require("../_Options/Option.context.cjs.js");const M=require("../_Options/Option.cjs.js");require("../../chunks/form.context.B1PXIJNq.js");require("../Form/contexts/label.context.cjs.js");require("../Form/contexts/helperText.context.cjs.js");const{baseClassNamePrefix:S}=a.getBEMClassNames("floatingui"),{baseClassNamePrefix:w}=a.getBEMClassNames("popover"),L=[M.Option],T=({setOpen:o,isMounted:n,status:l,nodeId:u,context:c,getFloatingProps:d,floatingStyles:x,labelsRef:f,elementsRef:p,getItemProps:q,setFloating:g,disabled:m,readOnly:N,theme:t,className:b,children:F,multiple:i,activeIndex:_,onItemClick:s})=>{const j=y.useCallback(h=>{s==null||s(h),!i&&o(!1)},[i,s,o]);return n?e.jsx(r.FloatingTree,{children:e.jsx(r.FloatingNode,{id:u,children:e.jsx(r.FloatingPortal,{children:e.jsx(r.FloatingFocusManager,{context:c,modal:!1,initialFocus:0,disabled:m||N,closeOnFocusOut:!0,restoreFocus:!0,returnFocus:!0,guards:!0,order:["content","reference"],children:e.jsx(B.Box,{"data-status":l,className:C(t&&P.themeClassName(t),A.floatinguiStyles[S],O.popoverStyles[w],b),...d(),style:x,ref:g,children:e.jsx(v.ActionListContextProvider,{allowChildrenTypes:L,getItemProps:q,itemsFocusable:!1,onItemClick:j,labelsRef:f,elementsRef:p,activeIndex:_,children:F})})})})})}):null};exports.AutocompleteDropdown=T;

package/lib/Autocomplete/AutocompleteDropdown.d.ts

@@ -0,0 +1,25 @@
+import { FloatingContext, UseInteractionsReturn } from '@floating-ui/react';
+import { ThemeTypes } from '@viasat/beam-shared/utils';
+import { CSSProperties, MutableRefObject } from 'react';
+export interface AutocompleteDropdownProps {
+    isMounted: boolean;
+    status: string;
+    nodeId: string;
+    context: FloatingContext;
+    getFloatingProps: UseInteractionsReturn['getFloatingProps'];
+    floatingStyles: CSSProperties;
+    labelsRef: MutableRefObject<string[]>;
+    elementsRef: MutableRefObject<HTMLElement[]>;
+    getItemProps: UseInteractionsReturn['getItemProps'];
+    setOpen: (open: boolean) => void;
+    setFloating: (node: HTMLElement | null) => void;
+    activeIndex: number | null;
+    onItemClick?: (index: number) => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    theme?: ThemeTypes;
+    className?: string;
+    children?: React.ReactNode;
+    multiple?: boolean;
+}
+export declare const AutocompleteDropdown: ({ setOpen, isMounted, status, nodeId, context, getFloatingProps, floatingStyles, labelsRef, elementsRef, getItemProps, setFloating, disabled, readOnly, theme, className: _className, children, multiple, activeIndex, onItemClick, }: AutocompleteDropdownProps) => import("react/jsx-runtime").JSX.Element | null;

package/lib/Autocomplete/AutocompleteDropdown.es.js

@@ -0,0 +1,88 @@
+import { jsx as o } from "react/jsx-runtime";
+import { FloatingTree as v, FloatingNode as y, FloatingPortal as B, FloatingFocusManager as w } from "@floating-ui/react";
+import { Box as A } from "../Box/Box.es.js";
+import M from "clsx";
+import { g as a } from "../../chunks/classNames.DNsS4J__.js";
+import { t as O } from "../../chunks/constants.BBi77pmH.js";
+import { ActionListContextProvider as S } from "../ActionList/ActionList.context.es.js";
+import { useCallback as T } from "react";
+import { f as j } from "../../chunks/floatingui.module.BcBFebz0.js";
+import { p as D } from "../../chunks/popover.module.C6KFea25.js";
+import "../_Options/Option.context.es.js";
+import { Option as E } from "../_Options/Option.es.js";
+import "../../chunks/form.context.CNWjF5qA.js";
+import "../Form/contexts/label.context.es.js";
+import "../Form/contexts/helperText.context.es.js";
+const { baseClassNamePrefix: L } = a("floatingui"), { baseClassNamePrefix: q } = a("popover"), z = [E], I = ({
+  setOpen: e,
+  isMounted: i,
+  status: l,
+  nodeId: m,
+  context: n,
+  getFloatingProps: f,
+  floatingStyles: p,
+  labelsRef: c,
+  elementsRef: u,
+  getItemProps: d,
+  setFloating: g,
+  disabled: F,
+  readOnly: x,
+  theme: s,
+  className: N,
+  children: h,
+  multiple: t,
+  activeIndex: C,
+  onItemClick: r
+}) => {
+  const P = T(
+    (b) => {
+      r == null || r(b), !t && e(!1);
+    },
+    [t, r, e]
+  );
+  return i ? /* @__PURE__ */ o(v, { children: /* @__PURE__ */ o(y, { id: m, children: /* @__PURE__ */ o(B, { children: /* @__PURE__ */ o(
+    w,
+    {
+      context: n,
+      modal: !1,
+      initialFocus: 0,
+      disabled: F || x,
+      closeOnFocusOut: !0,
+      restoreFocus: !0,
+      returnFocus: !0,
+      guards: !0,
+      order: ["content", "reference"],
+      children: /* @__PURE__ */ o(
+        A,
+        {
+          "data-status": l,
+          className: M(
+            s && O(s),
+            j[L],
+            D[q],
+            N
+          ),
+          ...f(),
+          style: p,
+          ref: g,
+          children: /* @__PURE__ */ o(
+            S,
+            {
+              allowChildrenTypes: z,
+              getItemProps: d,
+              itemsFocusable: !1,
+              onItemClick: P,
+              labelsRef: c,
+              elementsRef: u,
+              activeIndex: C,
+              children: h
+            }
+          )
+        }
+      )
+    }
+  ) }) }) }) : null;
+};
+export {
+  I as AutocompleteDropdown
+};

package/lib/Autocomplete/AutocompleteField.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("react/jsx-runtime"),x=require("react"),N=require("../CloseButton/CloseButton.cjs.js"),s=require("../../chunks/combobox.module.XIDBRMf_.js"),j=require("../../chunks/classNames.DAeKwerT.js");require("../../chunks/constants.hwjHOsvT.js");const{subElementClassPrefix:l}=j.getBEMClassNames("combobox"),t=x.forwardRef(({id:a,contentBefore:i,contentAfter:o,chips:r,hasClearButton:c,onClear:d,onKeyDownCapture:n,onBlur:u,onKeyDown:m,onFocusCapture:_,...b},f)=>e.jsxs("div",{className:s.styles[`${l}field`],id:a,onBlur:u,onFocusCapture:_,onKeyDown:m,onKeyDownCapture:n,ref:f,...b,children:[i&&e.jsx("div",{className:s.styles[`${l}field__before`],children:e.jsx("div",{className:s.styles[`${l}field__content-before`],children:i})}),r,e.jsxs("div",{className:s.styles[`${l}field__after`],children:[o&&e.jsx("div",{className:s.styles[`${l}field__content-after`],children:o}),c&&e.jsx(N.CloseButton,{className:s.styles[`${l}field__clear`],"aria-label":"Clear selection",onClickCapture:d,tabIndex:-1,size:"sm"}),e.jsx("div",{className:s.styles[`${l}field__chevron`]})]})]}));t.displayName="ComboboxField";exports.AutocompleteField=t;exports.default=t;

package/lib/Autocomplete/AutocompleteField.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+export interface AutocompleteFieldProps {
+    id?: string;
+    contentBefore?: React.ReactNode;
+    contentAfter?: React.ReactNode;
+    chips: React.ReactNode;
+    hasClearButton: boolean;
+    onClear?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    onKeyDownCapture?: React.KeyboardEventHandler<HTMLDivElement>;
+    onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
+    onBlur?: React.FocusEventHandler<HTMLDivElement>;
+    onFocusCapture?: React.FocusEventHandler<HTMLDivElement>;
+}
+/**
+ * Structural field container for Autocomplete. Handles ARIA attributes and layout chrome.
+ * Pure presentational logic; all state is provided via props.
+ */
+export declare const AutocompleteField: React.ForwardRefExoticComponent<AutocompleteFieldProps & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export default AutocompleteField;

package/lib/Autocomplete/AutocompleteField.es.js

@@ -0,0 +1,56 @@
+import { jsxs as o, jsx as s } from "react/jsx-runtime";
+import N from "react";
+import { CloseButton as u } from "../CloseButton/CloseButton.es.js";
+import { s as e } from "../../chunks/combobox.module.DNJ3sGlK.js";
+import { g as v } from "../../chunks/classNames.DNsS4J__.js";
+import "../../chunks/constants.BBi77pmH.js";
+const { subElementClassPrefix: l } = v("combobox"), x = N.forwardRef(
+  ({
+    id: r,
+    contentBefore: a,
+    contentAfter: i,
+    chips: d,
+    hasClearButton: m,
+    onClear: t,
+    onKeyDownCapture: c,
+    onBlur: f,
+    onKeyDown: n,
+    onFocusCapture: _,
+    ...p
+  }, b) => /* @__PURE__ */ o(
+    "div",
+    {
+      className: e[`${l}field`],
+      id: r,
+      onBlur: f,
+      onFocusCapture: _,
+      onKeyDown: n,
+      onKeyDownCapture: c,
+      ref: b,
+      ...p,
+      children: [
+        a && /* @__PURE__ */ s("div", { className: e[`${l}field__before`], children: /* @__PURE__ */ s("div", { className: e[`${l}field__content-before`], children: a }) }),
+        d,
+        /* @__PURE__ */ o("div", { className: e[`${l}field__after`], children: [
+          i && /* @__PURE__ */ s("div", { className: e[`${l}field__content-after`], children: i }),
+          m && /* @__PURE__ */ s(
+            u,
+            {
+              className: e[`${l}field__clear`],
+              "aria-label": "Clear selection",
+              onClickCapture: t,
+              tabIndex: -1,
+              size: "sm"
+            }
+          ),
+          /* @__PURE__ */ s("div", { className: e[`${l}field__chevron`] })
+        ] })
+      ]
+    }
+  )
+);
+x.displayName = "ComboboxField";
+export {
+  x as AutocompleteField,
+  x as default
+};

package/lib/Autocomplete/index.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("./Autocomplete.cjs.js");exports.Autocomplete=e.Autocomplete;exports.default=e.Autocomplete;

package/lib/Autocomplete/index.d.ts

@@ -0,0 +1,3 @@
+import { Autocomplete } from './Autocomplete';
+export * from './Autocomplete';
+export default Autocomplete;

package/lib/Autocomplete/index.es.js

@@ -0,0 +1,5 @@
+import { Autocomplete as t } from "./Autocomplete.es.js";
+export {
+  t as Autocomplete,
+  t as default
+};

package/lib/Autocomplete/useAutocompleteA11y.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const _=require("react"),e=require("../Form/hooks/useAccessibleId.hook.cjs.js");require("react/jsx-runtime");require("../../chunks/form.context.B1PXIJNq.js");const l=require("clsx");function n({helperText:a,externalDescribedBy:b,error:s,errorShown:A,invalid:i}){const{id:o}=e.useAccessibleId(),{id:c}=e.useAccessibleId(),{id:t}=e.useAccessibleId(),{id:d}=e.useAccessibleId(),I=!!(s!=null&&s.length),u=l(a&&c,b)||void 0,r=l(I&&o,A&&t)||void 0;return _.useMemo(()=>({ids:{helperTextId:c,errorId:o,validationErrorsId:t,labelId:d},aria:{describedBy:u,errorMessage:r,invalid:i}}),[c,o,t,d,u,r,i])}exports.default=n;exports.useAutocompleteA11y=n;

package/lib/Autocomplete/useAutocompleteA11y.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+export interface UseAutocompleteA11yParams {
+    helperText: ReactNode;
+    externalDescribedBy?: string;
+    error?: boolean | string;
+    errorShown: boolean;
+    invalid: boolean;
+}
+export interface UseAutocompleteA11yResult {
+    ids: {
+        helperTextId: string;
+        errorId: string;
+        validationErrorsId: string;
+        labelId: string;
+    };
+    aria: {
+        describedBy?: string;
+        errorMessage?: string;
+        invalid: boolean;
+    };
+}
+/**
+ * Consolidates accessible ID generation and aria-* attribute composition for Autocomplete.
+ */
+export declare function useAutocompleteA11y({ helperText, externalDescribedBy, error, errorShown, invalid, }: UseAutocompleteA11yParams): UseAutocompleteA11yResult;
+export default useAutocompleteA11y;

package/lib/Autocomplete/useAutocompleteA11y.es.js

@@ -0,0 +1,28 @@
+import { useMemo as f } from "react";
+import { useAccessibleId as o } from "../Form/hooks/useAccessibleId.hook.es.js";
+import "react/jsx-runtime";
+import "../../chunks/form.context.CNWjF5qA.js";
+import m from "clsx";
+function A({
+  helperText: a,
+  externalDescribedBy: l,
+  error: e,
+  errorShown: p,
+  invalid: i
+}) {
+  const { id: s } = o(), { id: t } = o(), { id: d } = o(), { id: r } = o(), u = !!(e != null && e.length), c = m(a && t, l) || void 0, n = m(
+    u && s,
+    p && d
+  ) || void 0;
+  return f(
+    () => ({
+      ids: { helperTextId: t, errorId: s, validationErrorsId: d, labelId: r },
+      aria: { describedBy: c, errorMessage: n, invalid: i }
+    }),
+    [t, s, d, r, c, n, i]
+  );
+}
+export {
+  A as default,
+  A as useAutocompleteA11y
+};

package/lib/Autocomplete/useAutocompleteChipKeyboard.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const p=require("react");function P(b){const{multiple:D,open:t,setOpen:a,inputRef:h,fieldRef:d,chips:{enabled:g,selectedChip:l,setSelectedChip:u,selectPreviousChip:f,selectNextChip:C,options:n,deselectOptionValue:o}}=b,r=D&&g&&n.length>0,m=p.useCallback((e,i)=>{var k,y;if(!r)return!1;const{isInputFocused:c,caretPosition:s}=i;return e.key==="ArrowLeft"?s&&s>0?!1:(e.preventDefault(),t&&a(!1),c&&((k=h.current)==null||k.blur(),(y=d.current)==null||y.focus()),f(l),!0):e.key==="ArrowRight"?s!==null?!1:(e.preventDefault(),t&&a(!1),C(l),!0):!1},[r,t,a,f,l,h,d,C]),E=p.useCallback(e=>{if(!r)return!1;if(e.key==="Enter"&&l!==null&&!t){e.preventDefault();const i=n[l];return i&&o(i.value),u(null),!0}return!1},[r,l,t,n,o,u]),R=p.useCallback(e=>r&&e.key==="Escape"&&l!==null&&!t?(e.preventDefault(),u(null),!0):!1,[r,l,t,u]),A=p.useCallback((e,i)=>{if(!r||e.key!=="Backspace"&&e.key!=="Delete")return!1;const{caretPosition:c}=i;if(c&&c>0)return!1;if(e.preventDefault(),t&&a(!1),l===null)f(null);else{const s=n[l];s&&(o(s.value),e.key==="Backspace"?l===0?u(null):f(l):e.key==="Delete"&&l>=n.length-1&&u(null))}return!0},[r,t,a,l,f,n,o,u]);return{isChipMode:r,handleHorizontalChipNav:m,handleChipEnter:E,handleChipEscape:R,handleChipRemoval:A}}exports.useAutocompleteChipKeyboard=P;

package/lib/Autocomplete/useAutocompleteChipKeyboard.d.ts

@@ -0,0 +1,39 @@
+import { OptionProps } from '../_Options';
+export interface ChipKeyboardParams {
+    multiple: boolean;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    inputRef: React.RefObject<HTMLInputElement>;
+    fieldRef: React.RefObject<HTMLDivElement>;
+    chips: {
+        enabled: boolean;
+        selectedChip: number | null;
+        setSelectedChip: (index: number | null) => void;
+        selectPreviousChip: (prev: number | null) => void;
+        selectNextChip: (prev: number | null) => void;
+        options: OptionProps[];
+        deselectOptionValue: (value: string | undefined) => void;
+    };
+}
+/**
+ * Chip-specific keyboard behaviors extracted from the general keyboard manager.
+ * Responsibilities:
+ *  - Horizontal arrow navigation between chips (ArrowLeft/ArrowRight)
+ *  - Chip removal (Backspace/Delete) with focus shifting rules
+ *  - Enter on a focused chip to remove it (when dropdown closed)
+ *  - Determining whether we are in "chip mode" (multi + chips enabled + options present)
+ *
+ * Returns specific handler functions and an `isChipMode` flag consumed by the parent keyboard manager.
+ */
+export declare function useAutocompleteChipKeyboard(params: ChipKeyboardParams): {
+    isChipMode: boolean;
+    handleHorizontalChipNav: (event: React.KeyboardEvent, focusState: {
+        isInputFocused: boolean;
+        caretPosition: number | null;
+    }) => boolean;
+    handleChipEnter: (event: React.KeyboardEvent) => boolean;
+    handleChipEscape: (event: React.KeyboardEvent) => boolean;
+    handleChipRemoval: (event: React.KeyboardEvent, focusState: {
+        caretPosition: number | null;
+    }) => boolean;
+};