@viasat/beam-react 2.0.0

package/lib/FloatingUI/FloatingUI.context.d.ts

@@ -0,0 +1,232 @@
+import { default as React } from 'react';
+import { MiddlewareModifier } from '@viasat/beam-shared/components/floatingui';
+import { Placement, AutoPlacementOptions, FlipOptions, ShiftOptions, HideOptions, OffsetOptions, UseHoverProps, UseClickProps, UseFocusProps, FloatingPortalProps, UseTransitionStylesProps, UseFloatingOptions, UseRoleProps, FloatingRootContext, UseListNavigationProps, UseTypeaheadProps } from '@floating-ui/react';
+import { FocusManagerProps } from '../FloatingUI/FloatingUI.content';
+import { ArrowOptions } from '../FloatingUI/FloatingUI.arrow';
+import { UseSelectedProps } from './useSelected';
+export interface FloatingUIProps {
+    /**
+     * Specify the location of the floating content
+     *
+     * @default 'top'
+     *
+     */
+    placement?: Placement;
+    /**
+     * Specify if the floating content should automatically choose the placement that has the most space.
+     * [AutoPlacementOptions](https://floating-ui.com/docs/autoplacement#options)
+     *
+     */
+    autoPlacement?: boolean | AutoPlacementOptions;
+    /**
+     * Specify if the floating content should flip to the opposite side if there is not enough space.
+     * [FlipOptions](https://floating-ui.com/docs/flip#options)
+     *
+     * Cannot be used with `autoPlacement`
+     */
+    flip?: boolean | FlipOptions;
+    /**
+     * Allow shifting of the floating content.
+     * [ShiftOptions](https://floating-ui.com/docs/shift#options)
+     *
+     */
+    shift?: boolean | ShiftOptions;
+    /**
+     *  Specify if the floating content should auto-hide when the anchor is not in view
+     *  [HideOptions](https://floating-ui.com/docs/hide#options)
+     */
+    autoHiding?: boolean | HideOptions;
+    /**
+     * Middleware functions to modify the behavior of the floating element
+     */
+    middleware?: MiddlewareModifier;
+    /**
+     * Specify the options for the arrow
+     */
+    arrow?: ArrowOptions;
+    /**
+     * Specify the offset
+     *
+     * @link https://floating-ui.com/docs/offset | Offset Options
+     */
+    offset?: OffsetOptions;
+    /**
+     * Specify the display state
+     */
+    open?: boolean;
+    /**
+     * Specify the default open state
+     */
+    defaultOpen?: boolean;
+    /**
+     * Enable hover interaction
+     */
+    openOnHover?: boolean | UseHoverProps;
+    /**
+     * Enable click interaction
+     */
+    openOnClick?: boolean | UseClickProps;
+    /**
+     * Enable focus interaction
+     */
+    openOnFocus?: boolean | UseFocusProps;
+    /**
+     * Enable selection interaction
+     */
+    openOnSelected?: boolean | UseSelectedProps;
+    /**
+     * Specify if the floating element is portalled
+     */
+    portalled?: boolean | FloatingPortalProps;
+    /**
+     * Configure the focus manager
+     *
+     * If nothing is specified, the focus manager will not be rendered
+     *
+     * [FloatingFocusManagerProps](https://floating-ui.com/docs/floatingfocusmanager#props)
+     */
+    focusConfiguration?: boolean | FocusManagerProps;
+    /**
+     * Callback function that receives change in visibility state of the FloatingUI
+     *
+     * <a href="https://floating-ui.com/docs/react#open-event-callback" target="_blank" rel="noopener noreferrer">
+     *     onOpenChange
+     * </a>
+     *
+     */
+    onOpenChange?: UseFloatingOptions['onOpenChange'];
+    /**
+     * Transition configuration
+     */
+    transitionConfig?: UseTransitionStylesProps;
+    /**
+     * Adds base screen reader props to the reference and floating elements for a given `role`
+     */
+    role?: UseRoleProps;
+    /**
+     * Specify the floating ui root context, if any
+     */
+    rootContext?: FloatingRootContext;
+    /**
+     * Adds list navigation support to the floating list, if any
+     */
+    listNavigation?: UseListNavigationProps;
+    /**
+     * Adds typeahead support to the floating list, if any
+     */
+    typeahead?: UseTypeaheadProps;
+}
+export declare const useBmFloatingUI: ({ defaultOpen, open: controlledOpen, placement, offset: _offset, onOpenChange: setControlledOpen, openOnClick, openOnHover, openOnFocus, openOnSelected, focusConfiguration, listNavigation, typeahead, middleware, autoPlacement, flip, shift, autoHiding, arrow, transitionConfig, portalled, role, rootContext, }: FloatingUIProps) => {
+    portalled: boolean | FloatingPortalProps | undefined;
+    focusConfiguration: boolean | FocusManagerProps | undefined;
+    transitionConfig: UseTransitionStylesProps | undefined;
+    labelId: string | undefined;
+    descriptionId: string | undefined;
+    arrow: ArrowOptions | undefined;
+    setLabelId: React.Dispatch<React.SetStateAction<string | undefined>>;
+    setDescriptionId: React.Dispatch<React.SetStateAction<string | undefined>>;
+    setArrowEl: React.Dispatch<React.SetStateAction<null>>;
+    nodeId: string;
+    placement: Placement;
+    strategy: import('@floating-ui/utils').Strategy;
+    middlewareData: import('@floating-ui/core').MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: React.CSSProperties;
+    refs: {
+        reference: React.MutableRefObject<import('@floating-ui/react-dom').ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import('@floating-ui/react-dom').ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+    elements: {
+        reference: import('@floating-ui/react-dom').ReferenceType | null;
+        floating: HTMLElement | null;
+    } & import('@floating-ui/react').ExtendedElements<import('@floating-ui/react').ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: Placement;
+        strategy: import('@floating-ui/utils').Strategy;
+        middlewareData: import('@floating-ui/core').MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event, reason?: import('@floating-ui/react').OpenChangeReason) => void;
+        events: import('@floating-ui/react').FloatingEvents;
+        dataRef: React.MutableRefObject<import('@floating-ui/react').ContextData>;
+        nodeId: string | undefined;
+        floatingId: string;
+        refs: import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+        elements: import('@floating-ui/react').ExtendedElements<import('@floating-ui/react').ReferenceType>;
+    };
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    getItemProps: (userProps?: Omit<React.HTMLProps<HTMLElement>, "selected" | "active"> & {
+        active?: boolean;
+        selected?: boolean;
+    }) => Record<string, unknown>;
+    open: boolean;
+    setOpen: (open: boolean, event?: Event, reason?: import('@floating-ui/react').OpenChangeReason) => void;
+};
+export type BmFloatingContext = ReturnType<typeof useBmFloatingUI> | null;
+export declare const BmFloatingUIContext: React.Context<BmFloatingContext>;
+export declare const useBmFloatingUIContext: () => {
+    portalled: boolean | FloatingPortalProps | undefined;
+    focusConfiguration: boolean | FocusManagerProps | undefined;
+    transitionConfig: UseTransitionStylesProps | undefined;
+    labelId: string | undefined;
+    descriptionId: string | undefined;
+    arrow: ArrowOptions | undefined;
+    setLabelId: React.Dispatch<React.SetStateAction<string | undefined>>;
+    setDescriptionId: React.Dispatch<React.SetStateAction<string | undefined>>;
+    setArrowEl: React.Dispatch<React.SetStateAction<null>>;
+    nodeId: string;
+    placement: Placement;
+    strategy: import('@floating-ui/utils').Strategy;
+    middlewareData: import('@floating-ui/core').MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: React.CSSProperties;
+    refs: {
+        reference: React.MutableRefObject<import('@floating-ui/react-dom').ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import('@floating-ui/react-dom').ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+    elements: {
+        reference: import('@floating-ui/react-dom').ReferenceType | null;
+        floating: HTMLElement | null;
+    } & import('@floating-ui/react').ExtendedElements<import('@floating-ui/react').ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: Placement;
+        strategy: import('@floating-ui/utils').Strategy;
+        middlewareData: import('@floating-ui/core').MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event, reason?: import('@floating-ui/react').OpenChangeReason) => void;
+        events: import('@floating-ui/react').FloatingEvents;
+        dataRef: React.MutableRefObject<import('@floating-ui/react').ContextData>;
+        nodeId: string | undefined;
+        floatingId: string;
+        refs: import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+        elements: import('@floating-ui/react').ExtendedElements<import('@floating-ui/react').ReferenceType>;
+    };
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    getItemProps: (userProps?: Omit<React.HTMLProps<HTMLElement>, "selected" | "active"> & {
+        active?: boolean;
+        selected?: boolean;
+    }) => Record<string, unknown>;
+    open: boolean;
+    setOpen: (open: boolean, event?: Event, reason?: import('@floating-ui/react').OpenChangeReason) => void;
+};

package/lib/FloatingUI/FloatingUI.context.es.js

@@ -0,0 +1,9 @@
+import "react";
+import { B as e, u as n, a as r } from "../../chunks/FloatingUI.context.2kPXcTvi.js";
+import "@floating-ui/react";
+import "./FloatingUI.interactions.es.js";
+export {
+  e as BmFloatingUIContext,
+  n as useBmFloatingUI,
+  r as useBmFloatingUIContext
+};

package/lib/FloatingUI/FloatingUI.interactions.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("@floating-ui/react"),r=require("react"),N=require("./useSelected.cjs.js"),T=({context:s,openOnClick:t,openOnHover:n,openOnFocus:u,openOnSelected:a,role:l,listNavigation:o,typeahead:i})=>{const f=r.useMemo(()=>n?n===!0?{enabled:!0,handleClose:e.safePolygon()}:{enabled:!0,handleClose:e.safePolygon(),...n}:{enabled:!1},[n]),c=r.useMemo(()=>typeof t=="boolean"?{enabled:t}:t??{enabled:!1},[t]),d=r.useMemo(()=>typeof u=="boolean"?{enabled:u}:u??{enabled:!1},[u]),b=r.useMemo(()=>typeof a=="boolean"?{enabled:a}:a??{enabled:!1},[a]),g=r.useMemo(()=>typeof l=="boolean"?{enabled:l}:l??{enabled:!1},[l]),m=r.useMemo(()=>o||{activeIndex:null,listRef:{current:[]},enabled:!1},[o]),y=r.useMemo(()=>i||{activeIndex:null,listRef:{current:[]},enabled:!1},[i]),C=e.useHover(s,f),M=e.useClick(s,c),h=e.useDismiss(s),I=e.useFocus(s,d),v=N.useSelected(s,b),R=e.useRole(s,g),q=e.useListNavigation(s,m),P=e.useTypeahead(s,y);return e.useInteractions([C,M,h,I,v,R,q,P])};exports.useConfigurableInteractions=T;

package/lib/FloatingUI/FloatingUI.interactions.d.ts

@@ -0,0 +1,19 @@
+import { FloatingContext, UseClickProps, UseFocusProps, UseHoverProps, UseListNavigationProps, UseRoleProps, UseTypeaheadProps } from '@floating-ui/react';
+import { UseSelectedProps } from './useSelected';
+interface InteractionsWrapperArg {
+    context: FloatingContext;
+    openOnClick?: boolean | UseClickProps;
+    openOnHover?: boolean | UseHoverProps;
+    openOnFocus?: boolean | UseFocusProps;
+    openOnSelected?: boolean | UseSelectedProps;
+    role?: boolean | UseRoleProps;
+    listNavigation?: UseListNavigationProps;
+    typeahead?: UseTypeaheadProps;
+}
+/**
+ * Allows boolean or object configuration for interactions
+ *
+ * @param arg
+ */
+export declare const useConfigurableInteractions: ({ context, openOnClick, openOnHover, openOnFocus, openOnSelected, role: _role, listNavigation: _listNavigation, typeahead: _typeahead, }: InteractionsWrapperArg) => import('@floating-ui/react').UseInteractionsReturn;
+export {};

package/lib/FloatingUI/FloatingUI.interactions.es.js

@@ -0,0 +1,47 @@
+import { safePolygon as f, useHover as L, useClick as P, useDismiss as T, useFocus as j, useRole as k, useListNavigation as q, useTypeahead as w, useInteractions as z } from "@floating-ui/react";
+import s from "react";
+import { useSelected as A } from "./useSelected.es.js";
+const J = ({
+  context: e,
+  openOnClick: r,
+  openOnHover: t,
+  openOnFocus: a,
+  openOnSelected: u,
+  role: n,
+  listNavigation: o,
+  typeahead: l
+}) => {
+  const i = s.useMemo(() => t ? t === !0 ? {
+    enabled: !0,
+    handleClose: f()
+  } : {
+    enabled: !0,
+    handleClose: f(),
+    ...t
+  } : {
+    enabled: !1
+  }, [t]), d = s.useMemo(() => typeof r == "boolean" ? {
+    enabled: r
+  } : r ?? { enabled: !1 }, [r]), b = s.useMemo(() => typeof a == "boolean" ? { enabled: a } : a ?? { enabled: !1 }, [a]), c = s.useMemo(() => typeof u == "boolean" ? { enabled: u } : u ?? { enabled: !1 }, [u]), m = s.useMemo(() => typeof n == "boolean" ? { enabled: n } : n ?? { enabled: !1 }, [n]), g = s.useMemo(() => o || {
+    activeIndex: null,
+    listRef: { current: [] },
+    enabled: !1
+  }, [o]), C = s.useMemo(() => l || {
+    activeIndex: null,
+    listRef: { current: [] },
+    enabled: !1
+  }, [l]), y = L(e, i), M = P(e, d), h = T(e), v = j(e, b), I = A(e, c), R = k(e, m), N = q(e, g), D = w(e, C);
+  return z([
+    y,
+    M,
+    h,
+    v,
+    I,
+    R,
+    N,
+    D
+  ]);
+};
+export {
+  J as useConfigurableInteractions
+};

package/lib/FloatingUI/FloatingUI.root.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const l=require("react/jsx-runtime"),t=require("../../chunks/FloatingUI.context.BULqADss.js");function e({children:o,...i}){const n=t.useBmFloatingUI({...i});return l.jsx(t.BmFloatingUIContext.Provider,{value:n,children:o})}exports.FloatingUIRoot=e;exports.default=e;

package/lib/FloatingUI/FloatingUI.root.d.ts

@@ -0,0 +1,5 @@
+import { FloatingUIProps } from './FloatingUI.context';
+export declare function FloatingUIRoot({ children, ...restOptions }: {
+    children: React.ReactNode;
+} & FloatingUIProps): import("react/jsx-runtime").JSX.Element;
+export default FloatingUIRoot;

package/lib/FloatingUI/FloatingUI.root.es.js

@@ -0,0 +1,13 @@
+import { jsx as i } from "react/jsx-runtime";
+import { u as n, B as r } from "../../chunks/FloatingUI.context.2kPXcTvi.js";
+function m({
+  children: o,
+  ...t
+}) {
+  const a = n({ ...t });
+  return /* @__PURE__ */ i(r.Provider, { value: a, children: o });
+}
+export {
+  m as FloatingUIRoot,
+  m as default
+};

package/lib/FloatingUI/FloatingUI.treeWrapper.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("react/jsx-runtime"),t=require("@floating-ui/react"),n=({children:r})=>t.useFloatingParentNodeId()?e.jsx(e.Fragment,{children:r}):e.jsx(t.FloatingTree,{children:r});exports.FloatingUITreeWrapper=n;exports.default=n;

package/lib/FloatingUI/FloatingUI.treeWrapper.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export declare const FloatingUITreeWrapper: ({ children, }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export default FloatingUITreeWrapper;

package/lib/FloatingUI/FloatingUI.treeWrapper.es.js

@@ -0,0 +1,9 @@
+import { jsx as r, Fragment as t } from "react/jsx-runtime";
+import { useFloatingParentNodeId as o, FloatingTree as a } from "@floating-ui/react";
+const i = ({
+  children: e
+}) => o() ? /* @__PURE__ */ r(t, { children: e }) : /* @__PURE__ */ r(a, { children: e });
+export {
+  i as FloatingUITreeWrapper,
+  i as default
+};

package/lib/FloatingUI/FloatingUI.trigger.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const o=require("react"),u=require("../../chunks/FloatingUI.context.BULqADss.js"),l=require("@floating-ui/react"),g=require("../../utils/functions.cjs.js"),n=({children:t,...s})=>{try{const r=u.useBmFloatingUIContext(),e=o.useMemo(()=>g.ensureSingularRef(t),[t]),c=l.useMergeRefs([r.refs.setReference,e.props.ref??e.ref]),i=r.getReferenceProps({...s,...e.props,ref:c});return o.cloneElement(e,i)}catch{throw new Error("Expected a single child element with a ref for the FloatingUI trigger")}};exports.Trigger=n;exports.default=n;

package/lib/FloatingUI/FloatingUI.trigger.close.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const a=require("react/jsx-runtime"),o=require("react"),d=require("../../utils/functions.cjs.js"),m=require("../../chunks/FloatingUI.context.BULqADss.js"),g=({children:l,...n})=>{const{setOpen:s}=m.useBmFloatingUIContext(),e=o.useMemo(()=>d.ensureSingularRef(l),[l]),r=o.useCallback(t=>{s==null||s(!1,t,"click")},[s]),c=o.useCallback(t=>{var i,u;r(t),(u=(i=e.props).onClick)==null||u.call(i,t)},[r,e.props]),C=o.useMemo(()=>({...n,...e.props,onClick:c}),[c,n,e.props]);return a.jsx(a.Fragment,{children:o.cloneElement(e,C)})};exports.CloseTrigger=g;exports.default=g;

package/lib/FloatingUI/FloatingUI.trigger.close.d.ts

@@ -0,0 +1,9 @@
+import { default as React, FC } from 'react';
+export interface TriggerProps {
+    /**
+     * The content that will close the FloatingUI.
+     */
+    children: React.ReactNode;
+}
+export declare const CloseTrigger: FC<TriggerProps>;
+export default CloseTrigger;

package/lib/FloatingUI/FloatingUI.trigger.close.es.js

@@ -0,0 +1,30 @@
+import { jsx as f, Fragment as u } from "react/jsx-runtime";
+import { useMemo as a, useCallback as m, cloneElement as C } from "react";
+import { ensureSingularRef as d } from "../../utils/functions.es.js";
+import { a as g } from "../../chunks/FloatingUI.context.2kPXcTvi.js";
+const b = ({ children: e, ...l }) => {
+  const { setOpen: r } = g(), o = a(() => d(e), [e]), n = m(
+    (s) => {
+      r == null || r(!1, s, "click");
+    },
+    [r]
+  ), t = m(
+    (s) => {
+      var c, i;
+      n(s), (i = (c = o.props).onClick) == null || i.call(c, s);
+    },
+    [n, o.props]
+  ), p = a(
+    () => ({
+      ...l,
+      ...o.props,
+      onClick: t
+    }),
+    [t, l, o.props]
+  );
+  return /* @__PURE__ */ f(u, { children: C(o, p) });
+};
+export {
+  b as CloseTrigger,
+  b as default
+};

package/lib/FloatingUI/FloatingUI.trigger.d.ts

@@ -0,0 +1,9 @@
+import { default as React, FC } from 'react';
+export interface TriggerProps {
+    /**
+     * The content that will trigger the FloatingUI.
+     */
+    children: React.ReactNode;
+}
+export declare const Trigger: FC<TriggerProps>;
+export default Trigger;

package/lib/FloatingUI/FloatingUI.trigger.es.js

@@ -0,0 +1,25 @@
+import f, { useMemo as c } from "react";
+import { a } from "../../chunks/FloatingUI.context.2kPXcTvi.js";
+import { useMergeRefs as i } from "@floating-ui/react";
+import { ensureSingularRef as m } from "../../utils/functions.es.js";
+const h = ({ children: r, ...o }) => {
+  try {
+    const t = a(), e = c(() => m(r), [r]), n = i([
+      t.refs.setReference,
+      e.props.ref ?? e.ref
+    ]), s = t.getReferenceProps({
+      ...o,
+      ...e.props,
+      ref: n
+    });
+    return f.cloneElement(e, s);
+  } catch {
+    throw new Error(
+      "Expected a single child element with a ref for the FloatingUI trigger"
+    );
+  }
+};
+export {
+  h as Trigger,
+  h as default
+};

package/lib/FloatingUI/index.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./FloatingUI.root.cjs.js"),o=require("./FloatingUI.trigger.cjs.js"),e=require("./FloatingUI.trigger.close.cjs.js"),i=require("./FloatingUI.content.cjs.js");exports.Root=t.FloatingUIRoot;exports.Trigger=o.Trigger;exports.CloseTrigger=e.CloseTrigger;exports.Content=i.Content;

package/lib/FloatingUI/index.d.ts

@@ -0,0 +1,5 @@
+import { default as Root } from './FloatingUI.root';
+import { default as Trigger } from './FloatingUI.trigger';
+import { default as CloseTrigger } from './FloatingUI.trigger.close';
+import { default as Content } from './FloatingUI.content';
+export { Root, Trigger, CloseTrigger, Content };

package/lib/FloatingUI/index.es.js

@@ -0,0 +1,10 @@
+import { FloatingUIRoot as t } from "./FloatingUI.root.es.js";
+import { Trigger as g } from "./FloatingUI.trigger.es.js";
+import { CloseTrigger as m } from "./FloatingUI.trigger.close.es.js";
+import { Content as x } from "./FloatingUI.content.es.js";
+export {
+  m as CloseTrigger,
+  x as Content,
+  t as Root,
+  g as Trigger
+};

package/lib/FloatingUI/useSelected.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("react"),o={},b=(c,i)=>{const e=c.refs.domReference.current,u=(i==null?void 0:i.enabled)??!0,[n,l]=r.useState(()=>(e==null?void 0:e.getAttribute("aria-selected"))==="true"),a=r.useRef(n);a.current=n;const s=r.useRef(c.onOpenChange);return s.current=c.onOpenChange,r.useEffect(()=>{if(!e||!u)return;const t=new MutationObserver(()=>{requestAnimationFrame(()=>{const d=(e==null?void 0:e.getAttribute("aria-selected"))==="true";a.current!==d&&l(d)})});return t.observe(e,{attributes:!0,attributeFilter:["aria-selected"]}),()=>t.disconnect()},[u,e]),r.useEffect(()=>{var t;u&&((t=s.current)==null||t.call(s,n))},[u,n]),o};exports.useSelected=b;

package/lib/FloatingUI/useSelected.d.ts

@@ -0,0 +1,9 @@
+import { ElementProps, FloatingContext } from '@floating-ui/react';
+export interface UseSelectedProps {
+    enabled: boolean;
+}
+/**
+ * Opens the floating element while the reference element has been selected (has attribute `aria-selected` set to true).
+ * This is useful for elements getting a virtual focus (ie. parent has an aria-activedescendant set to this element).
+ */
+export declare const useSelected: (context: FloatingContext, props?: UseSelectedProps) => ElementProps;

package/lib/FloatingUI/useSelected.es.js

@@ -0,0 +1,22 @@
+import { useState as b, useRef as o, useEffect as d } from "react";
+const f = {}, S = (s, c) => {
+  const e = s.refs.domReference.current, r = (c == null ? void 0 : c.enabled) ?? !0, [n, l] = b(() => (e == null ? void 0 : e.getAttribute("aria-selected")) === "true"), i = o(n);
+  i.current = n;
+  const u = o(s.onOpenChange);
+  return u.current = s.onOpenChange, d(() => {
+    if (!e || !r) return;
+    const t = new MutationObserver(() => {
+      requestAnimationFrame(() => {
+        const a = (e == null ? void 0 : e.getAttribute("aria-selected")) === "true";
+        i.current !== a && l(a);
+      });
+    });
+    return t.observe(e, { attributes: !0, attributeFilter: ["aria-selected"] }), () => t.disconnect();
+  }, [r, e]), d(() => {
+    var t;
+    r && ((t = u.current) == null || t.call(u, n));
+  }, [r, n]), f;
+};
+export {
+  S as useSelected
+};

package/lib/Form/Form.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const p=require("react/jsx-runtime"),P=require("react"),T=require("../../chunks/form.context.B1PXIJNq.js");require("./contexts/label.context.cjs.js");require("./contexts/helperText.context.cjs.js");const A=require("./hooks/useUniversalRef.hook.cjs.js");require("../../chunks/constants.hwjHOsvT.js");const f=require("../../chunks/useFormValidator.hook.BtP4A6XY.js"),M=require("./hooks/useActionValidator.hook.cjs.js");function C(t){const n=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(t){for(const r in t)if(r!=="default"){const s=Object.getOwnPropertyDescriptor(t,r);Object.defineProperty(n,r,s.get?s:{enumerable:!0,get:()=>t[r]})}}return n.default=t,Object.freeze(n)}const H=C(P),b=H.forwardRef(function({disabled:t=!1,readOnly:n=!1,required:r=!1,initialValues:s={},validationMode:m="onBlur",...g},F){const{children:R,onSubmit:i,onChange:l,onReset:c,onBlur:u,...q}=g,{refFn:x,ref:d}=A.useUniversalRef(F),{handleAction:k,shouldSkipValidation:V}=M.useActionValidator(),{register:j,validateField:_,validateForm:y,reset:h}=f.useFormValidator(),v=e=>{h(),c==null||c(e)},O=async e=>{u==null||u(e);const{current:a}=d,{target:{name:o}}=e,{skipField:B}=V(),{groupBlur:D}=f.isGroupBlurEvent(e);!B&&!D&&m==="onBlur"&&await _(o,a)},w=async e=>{l==null||l(e);const{current:a}=d,{target:{name:o}}=e;m==="onChange"?await _(o,a):h(o)},S=async e=>{e.preventDefault();const{current:a}=d,{fail:o}=await y(a);!o&&(i==null||i(e))};return p.jsx("form",{noValidate:!0,ref:x,onBlur:O,onReset:v,onChange:w,onSubmit:S,onMouseDown:k,...q,children:p.jsx(T.FormProvider,{ctxDisabled:t,ctxReadOnly:n,ctxRequired:r,ctxRegister:j,ctxInitialValues:s,children:R})})});exports.validators=f.validators;exports.Form=b;exports.default=b;

package/lib/Form/Form.d.ts

@@ -0,0 +1,29 @@
+import { ValidationMode, FormValue, validators as sharedValidators } from '@viasat/beam-shared/components/form';
+import * as React from 'react';
+export { sharedValidators as validators };
+export interface FormProps extends React.ComponentPropsWithRef<'form'> {
+    /**
+     * Specify if validation runs on change or when loosing focus
+     *
+     * @default onBlur
+     */
+    validationMode?: ValidationMode;
+    /**
+     * Specify initial values on Form controls based on their names
+     */
+    initialValues?: Record<string, FormValue>;
+    /**
+     * Specify if form is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Specify if form is read only
+     */
+    readOnly?: boolean;
+    /**
+     * Specify if form is required
+     */
+    required?: boolean;
+}
+export declare const Form: React.ForwardRefExoticComponent<Omit<FormProps, "ref"> & React.RefAttributes<HTMLFormElement>>;
+export default Form;

package/lib/Form/Form.es.js

@@ -0,0 +1,67 @@
+import { jsx as d } from "react/jsx-runtime";
+import * as D from "react";
+import { a as S } from "../../chunks/form.context.CNWjF5qA.js";
+import "./contexts/label.context.es.js";
+import "./contexts/helperText.context.es.js";
+import { useUniversalRef as k } from "./hooks/useUniversalRef.hook.es.js";
+import "../../chunks/constants.BBi77pmH.js";
+import { u as A, i as P } from "../../chunks/useFormValidator.hook.CSmddwEt.js";
+import { v as X } from "../../chunks/useFormValidator.hook.CSmddwEt.js";
+import { useActionValidator as j } from "./hooks/useActionValidator.hook.es.js";
+const Q = D.forwardRef(function({
+  disabled: u = !1,
+  readOnly: f = !1,
+  required: h = !1,
+  initialValues: p = {},
+  validationMode: l = "onBlur",
+  ...R
+}, g) {
+  const { children: x, onSubmit: a, onChange: e, onReset: n, onBlur: s, ...F } = R, { refFn: V, ref: i } = k(g), { handleAction: B, shouldSkipValidation: w } = j(), { register: y, validateField: c, validateForm: b, reset: m } = A();
+  return /* @__PURE__ */ d(
+    "form",
+    {
+      noValidate: !0,
+      ref: V,
+      onBlur: async (r) => {
+        s == null || s(r);
+        const { current: t } = i, {
+          target: { name: o }
+        } = r, { skipField: v } = w(), { groupBlur: C } = P(r);
+        !v && !C && l === "onBlur" && await c(o, t);
+      },
+      onReset: (r) => {
+        m(), n == null || n(r);
+      },
+      onChange: async (r) => {
+        e == null || e(r);
+        const { current: t } = i, {
+          target: { name: o }
+        } = r;
+        l === "onChange" ? await c(o, t) : m(o);
+      },
+      onSubmit: async (r) => {
+        r.preventDefault();
+        const { current: t } = i, { fail: o } = await b(t);
+        !o && (a == null || a(r));
+      },
+      onMouseDown: B,
+      ...F,
+      children: /* @__PURE__ */ d(
+        S,
+        {
+          ctxDisabled: u,
+          ctxReadOnly: f,
+          ctxRequired: h,
+          ctxRegister: y,
+          ctxInitialValues: p,
+          children: x
+        }
+      )
+    }
+  );
+});
+export {
+  Q as Form,
+  Q as default,
+  X as validators
+};

package/lib/Form/contexts/form.context.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("react/jsx-runtime");require("react");require("../../../chunks/constants.hwjHOsvT.js");const e=require("../../../chunks/form.context.B1PXIJNq.js");exports.FormContext=e.FormContext;exports.FormProvider=e.FormProvider;exports.useFormField=e.useFormField;

package/lib/Form/contexts/form.context.d.ts

@@ -0,0 +1,30 @@
+import { ValidationHelpers } from '../hooks';
+import { FormValidator, FormValue } from '@viasat/beam-shared/components/form';
+import * as React from 'react';
+export interface FormContextProps {
+    ctxDisabled: boolean;
+    ctxReadOnly: boolean;
+    ctxRequired: boolean;
+    ctxRegister: ValidationHelpers['register'];
+    ctxInitialValues: Record<string, FormValue>;
+}
+export interface FormProviderProps extends FormContextProps {
+    children: React.ReactNode;
+}
+export declare const FormContext: React.Context<FormContextProps>;
+export declare const FormProvider: (props: FormProviderProps) => import("react/jsx-runtime").JSX.Element;
+export interface UseFormFieldOptions {
+    name: string | undefined;
+    validationRules: FormValidator[];
+    disabledProp: boolean;
+    readOnlyProp: boolean;
+    requiredProp: boolean;
+}
+export declare function useFormField({ name, validationRules, disabledProp, readOnlyProp, requiredProp, }: UseFormFieldOptions): {
+    showErrors: (id: import('@viasat/beam-shared/utils/types').Optional<string>) => import('@viasat/beam-shared/utils/types').Nullable<React.ReactElement>;
+    isInvalid: boolean;
+    errorShown: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    required: boolean;
+};