@skdx/react 0.26.0

package/dist/utils/useCallbackRef.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Returns a function with a stable identity across renders that always
+ * invokes the *latest* `callback` passed in — avoids re-subscribing effects
+ * or event listeners just because an inline callback prop changed identity.
+ *
+ * @example
+ * ```tsx
+ * const handleChange = useCallbackRef(onChange);
+ * React.useEffect(() => {
+ *   document.addEventListener('keydown', handleChange);
+ *   return () => document.removeEventListener('keydown', handleChange);
+ * }, [handleChange]); // stable — effect doesn't re-run when `onChange` changes
+ * ```
+ */
+export declare function useCallbackRef<T extends (...args: never[]) => unknown>(callback: T | undefined): T;

package/dist/utils/useCallbackRef.js

@@ -0,0 +1 @@
+import*as e from"react";function c(n){let t=e.useRef(n);return e.useEffect(()=>{t.current=n}),e.useMemo(()=>((...r)=>t.current?.(...r)),[])}export{c as useCallbackRef};

package/dist/utils/useControllableState.cjs

@@ -0,0 +1 @@
+"use strict";var p=Object.create;var l=Object.defineProperty;var S=Object.getOwnPropertyDescriptor;var b=Object.getOwnPropertyNames;var v=Object.getPrototypeOf,P=Object.prototype.hasOwnProperty;var h=(e,t)=>{for(var n in t)l(e,n,{get:t[n],enumerable:!0})},T=(e,t,n,c)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of b(t))!P.call(e,o)&&o!==n&&l(e,o,{get:()=>t[o],enumerable:!(c=S(t,o))||c.enumerable});return e};var U=(e,t,n)=>(n=e!=null?p(v(e)):{},T(t||!e||!e.__esModule?l(n,"default",{value:e,enumerable:!0}):n,e)),g=e=>T(l({},"__esModule",{value:!0}),e);var y={};h(y,{useControllableState:()=>k});module.exports=g(y);var a=U(require("react"),1),C=require("./useCallbackRef.cjs");function k({prop:e,defaultProp:t,onChange:n=()=>{}}){let[c,o]=a.useState(t),s=e!==void 0,r=s?e:c,i=(0,C.useCallbackRef)(n),f=a.useRef(r);a.useLayoutEffect(()=>{f.current=r},[r]);let m=a.useCallback(d=>{let R=s?e:f.current,u=typeof d=="function"?d(R):d;u!==R&&(s||(f.current=u,o(u)),i(u))},[s,e,i]);return[r,m]}0&&(module.exports={useControllableState});

package/dist/utils/useControllableState.d.cts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+interface UseControllableStateParams<T> {
+    /** The controlled value. When defined, the hook is controlled and only ever reflects this prop. */
+    prop?: T | undefined;
+    /** Initial value for uncontrolled usage; ignored once `prop` is defined. */
+    defaultProp?: T | undefined;
+    /** Called with the next value whenever it changes, in both controlled and uncontrolled modes. */
+    onChange?: (state: T) => void;
+}
+/**
+ * The controlled/uncontrolled pattern shared by every stateful primitive
+ * (`Checkbox`'s `checked`, `Tabs`'s `value`, `Dialog`'s `open`, …). Behaves
+ * like `useState` when `prop` is `undefined`; once `prop` is defined, the
+ * returned value always mirrors it and `setValue` only calls `onChange`
+ * instead of storing internal state.
+ *
+ * @returns A `[value, setValue]` tuple, same shape as `useState`.
+ *
+ * @example
+ * ```tsx
+ * function MyCheckbox({ checked: checkedProp, defaultChecked, onCheckedChange }: Props) {
+ *   const [checked, setChecked] = useControllableState({
+ *     prop: checkedProp,
+ *     defaultProp: defaultChecked,
+ *     onChange: onCheckedChange,
+ *   });
+ *   // `checked` works whether the consumer passed `checked` or `defaultChecked`.
+ * }
+ * ```
+ */
+export declare function useControllableState<T>({ prop, defaultProp, onChange, }: UseControllableStateParams<T>): readonly [T | undefined, React.Dispatch<React.SetStateAction<T | undefined>>];
+export {};

package/dist/utils/useControllableState.d.ts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+interface UseControllableStateParams<T> {
+    /** The controlled value. When defined, the hook is controlled and only ever reflects this prop. */
+    prop?: T | undefined;
+    /** Initial value for uncontrolled usage; ignored once `prop` is defined. */
+    defaultProp?: T | undefined;
+    /** Called with the next value whenever it changes, in both controlled and uncontrolled modes. */
+    onChange?: (state: T) => void;
+}
+/**
+ * The controlled/uncontrolled pattern shared by every stateful primitive
+ * (`Checkbox`'s `checked`, `Tabs`'s `value`, `Dialog`'s `open`, …). Behaves
+ * like `useState` when `prop` is `undefined`; once `prop` is defined, the
+ * returned value always mirrors it and `setValue` only calls `onChange`
+ * instead of storing internal state.
+ *
+ * @returns A `[value, setValue]` tuple, same shape as `useState`.
+ *
+ * @example
+ * ```tsx
+ * function MyCheckbox({ checked: checkedProp, defaultChecked, onCheckedChange }: Props) {
+ *   const [checked, setChecked] = useControllableState({
+ *     prop: checkedProp,
+ *     defaultProp: defaultChecked,
+ *     onChange: onCheckedChange,
+ *   });
+ *   // `checked` works whether the consumer passed `checked` or `defaultChecked`.
+ * }
+ * ```
+ */
+export declare function useControllableState<T>({ prop, defaultProp, onChange, }: UseControllableStateParams<T>): readonly [T | undefined, React.Dispatch<React.SetStateAction<T | undefined>>];
+export {};

package/dist/utils/useControllableState.js

@@ -0,0 +1 @@
+import*as e from"react";import{useCallbackRef as T}from"./useCallbackRef.js";function m({prop:t,defaultProp:l,onChange:f=()=>{}}){let[d,i]=e.useState(l),n=t!==void 0,a=n?t:d,r=T(f),c=e.useRef(a);e.useLayoutEffect(()=>{c.current=a},[a]);let R=e.useCallback(s=>{let u=n?t:c.current,o=typeof s=="function"?s(u):s;o!==u&&(n||(c.current=o,i(o)),r(o))},[n,t,r]);return[a,R]}export{m as useControllableState};

package/dist/utils/useDismiss.cjs

@@ -0,0 +1 @@
+"use strict";var N=Object.create;var E=Object.defineProperty;var P=Object.getOwnPropertyDescriptor;var k=Object.getOwnPropertyNames;var R=Object.getPrototypeOf,T=Object.prototype.hasOwnProperty;var g=(e,n)=>{for(var o in n)E(e,o,{get:n[o],enumerable:!0})},F=(e,n,o,d)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of k(n))!T.call(e,r)&&r!==o&&E(e,r,{get:()=>n[r],enumerable:!(d=P(n,r))||d.enumerable});return e};var x=(e,n,o)=>(o=e!=null?N(R(e)):{},F(n||!e||!e.__esModule?E(o,"default",{value:e,enumerable:!0}):o,e)),K=e=>F(E({},"__esModule",{value:!0}),e);var j={};g(j,{useDismiss:()=>C});module.exports=K(j);var h=x(require("react"),1),c=require("./useCallbackRef.cjs"),u=[];function C({enabled:e,onEscapeKeyDown:n,onPointerDownOutside:o,onFocusOutside:d,onInteractOutside:r,insideSelector:l},L){let m=(0,c.useCallbackRef)(n),p=(0,c.useCallbackRef)(o),O=(0,c.useCallbackRef)(d),v=(0,c.useCallbackRef)(r);h.useEffect(()=>{if(!e)return;let i=globalThis.document,f={};u.push(f);let w=t=>{if(L.some(a=>a.current?.contains(t)))return!1;let s=t.nodeType===Node.ELEMENT_NODE?t:t.parentElement;return!(l&&s?.closest(l))},y=t=>{t.key==="Escape"&&u[u.length-1]===f&&m(t)},b=t=>{let s=t.target;s&&w(s)&&(v(t),p(t))},D=t=>{let s=t.target;if(!s||s===i.body||!w(s))return;let a=new CustomEvent("focus-outside",{detail:t,cancelable:!0});v(a),O(a)};i.addEventListener("keydown",y);let I=window.setTimeout(()=>{i.addEventListener("pointerdown",b,!0),i.addEventListener("focusin",D,!0)},0);return()=>{let t=u.indexOf(f);t!==-1&&u.splice(t,1),i.removeEventListener("keydown",y),window.clearTimeout(I),i.removeEventListener("pointerdown",b,!0),i.removeEventListener("focusin",D,!0)}},[e,m,p,O,v,l])}0&&(module.exports={useDismiss});

package/dist/utils/useDismiss.d.cts

@@ -0,0 +1,47 @@
+import * as React from 'react';
+/**
+ * What `onFocusOutside` receives. `focusin` is not cancelable, so there would
+ * be nothing to `preventDefault()` on the real event — the handler gets a
+ * cancelable stand-in carrying the original as its `detail` instead.
+ */
+export type FocusOutsideEvent = CustomEvent<FocusEvent>;
+/** Either flavour of outside interaction, as `onInteractOutside` sees it. */
+export type InteractOutsideEvent = PointerEvent | FocusOutsideEvent;
+interface UseDismissOptions {
+    /** Whether dismiss listeners are active (usually the open state). */
+    enabled: boolean;
+    /** Called on Escape keydown. */
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    /** Called on pointerdown outside every element in `insideRefs`. */
+    onPointerDownOutside?: (event: PointerEvent) => void;
+    /** Called when focus moves to an element outside every element in `insideRefs`. */
+    onFocusOutside?: (event: FocusOutsideEvent) => void;
+    /**
+     * Called for *either* kind of outside interaction, immediately **before**
+     * the specific handler above and with the same event object — so a single
+     * `preventDefault()` here is already visible to that handler and vetoes the
+     * dismissal whichever way it was triggered.
+     */
+    onInteractOutside?: (event: InteractOutsideEvent) => void;
+    /**
+     * Extra "inside" region, as a selector the target is matched against with
+     * `closest()`. `insideRefs` covers the elements the layer holds a ref to; this
+     * covers the ones it does not — a submenu panel portalled out of the menu it
+     * belongs to is not `contains()`-reachable from the menu's content ref, yet a
+     * pointer-down or a focus landing in it is unambiguously inside the menu.
+     */
+    insideSelector?: string;
+}
+/**
+ * Layer dismissal behavior shared by every dismissible overlay. Consumers pass
+ * refs of elements that count as "inside" — which for the input-driven
+ * families (Combobox, Autocomplete, MultiSelect, TreeSelect) includes the
+ * input and any toggle button, not just the floating panel: real DOM focus
+ * lives out there for the whole interaction.
+ *
+ * This hook only *reports*: the caller decides what dismissal means (Dialog
+ * ignores outside interaction unless modal, AlertDialog ignores it entirely)
+ * by checking `event.defaultPrevented` in its own handler.
+ */
+export declare function useDismiss({ enabled, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, insideSelector, }: UseDismissOptions, insideRefs: Array<React.RefObject<Element | null>>): void;
+export {};

package/dist/utils/useDismiss.d.ts

@@ -0,0 +1,47 @@
+import * as React from 'react';
+/**
+ * What `onFocusOutside` receives. `focusin` is not cancelable, so there would
+ * be nothing to `preventDefault()` on the real event — the handler gets a
+ * cancelable stand-in carrying the original as its `detail` instead.
+ */
+export type FocusOutsideEvent = CustomEvent<FocusEvent>;
+/** Either flavour of outside interaction, as `onInteractOutside` sees it. */
+export type InteractOutsideEvent = PointerEvent | FocusOutsideEvent;
+interface UseDismissOptions {
+    /** Whether dismiss listeners are active (usually the open state). */
+    enabled: boolean;
+    /** Called on Escape keydown. */
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    /** Called on pointerdown outside every element in `insideRefs`. */
+    onPointerDownOutside?: (event: PointerEvent) => void;
+    /** Called when focus moves to an element outside every element in `insideRefs`. */
+    onFocusOutside?: (event: FocusOutsideEvent) => void;
+    /**
+     * Called for *either* kind of outside interaction, immediately **before**
+     * the specific handler above and with the same event object — so a single
+     * `preventDefault()` here is already visible to that handler and vetoes the
+     * dismissal whichever way it was triggered.
+     */
+    onInteractOutside?: (event: InteractOutsideEvent) => void;
+    /**
+     * Extra "inside" region, as a selector the target is matched against with
+     * `closest()`. `insideRefs` covers the elements the layer holds a ref to; this
+     * covers the ones it does not — a submenu panel portalled out of the menu it
+     * belongs to is not `contains()`-reachable from the menu's content ref, yet a
+     * pointer-down or a focus landing in it is unambiguously inside the menu.
+     */
+    insideSelector?: string;
+}
+/**
+ * Layer dismissal behavior shared by every dismissible overlay. Consumers pass
+ * refs of elements that count as "inside" — which for the input-driven
+ * families (Combobox, Autocomplete, MultiSelect, TreeSelect) includes the
+ * input and any toggle button, not just the floating panel: real DOM focus
+ * lives out there for the whole interaction.
+ *
+ * This hook only *reports*: the caller decides what dismissal means (Dialog
+ * ignores outside interaction unless modal, AlertDialog ignores it entirely)
+ * by checking `event.defaultPrevented` in its own handler.
+ */
+export declare function useDismiss({ enabled, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, insideSelector, }: UseDismissOptions, insideRefs: Array<React.RefObject<Element | null>>): void;
+export {};

package/dist/utils/useDismiss.js

@@ -0,0 +1 @@
+import*as O from"react";import{useCallbackRef as r}from"./useCallbackRef.js";var o=[];function I({enabled:d,onEscapeKeyDown:w,onPointerDownOutside:y,onFocusOutside:b,onInteractOutside:D,insideSelector:i},F){let a=r(w),E=r(y),l=r(b),u=r(D);O.useEffect(()=>{if(!d)return;let n=globalThis.document,c={};o.push(c);let v=e=>{if(F.some(s=>s.current?.contains(e)))return!1;let t=e.nodeType===Node.ELEMENT_NODE?e:e.parentElement;return!(i&&t?.closest(i))},f=e=>{e.key==="Escape"&&o[o.length-1]===c&&a(e)},m=e=>{let t=e.target;t&&v(t)&&(u(e),E(e))},p=e=>{let t=e.target;if(!t||t===n.body||!v(t))return;let s=new CustomEvent("focus-outside",{detail:e,cancelable:!0});u(s),l(s)};n.addEventListener("keydown",f);let h=window.setTimeout(()=>{n.addEventListener("pointerdown",m,!0),n.addEventListener("focusin",p,!0)},0);return()=>{let e=o.indexOf(c);e!==-1&&o.splice(e,1),n.removeEventListener("keydown",f),window.clearTimeout(h),n.removeEventListener("pointerdown",m,!0),n.removeEventListener("focusin",p,!0)}},[d,a,E,l,u,i])}export{I as useDismiss};

package/dist/utils/useFocusTrap.cjs

@@ -0,0 +1 @@
+"use strict";var F=Object.create;var a=Object.defineProperty;var A=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var T=Object.getPrototypeOf,x=Object.prototype.hasOwnProperty;var L=(e,t)=>{for(var o in t)a(e,o,{get:t[o],enumerable:!0})},m=(e,t,o,c)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of y(t))!x.call(e,n)&&n!==o&&a(e,n,{get:()=>t[n],enumerable:!(c=A(t,n))||c.enumerable});return e};var R=(e,t,o)=>(o=e!=null?F(T(e)):{},m(t||!e||!e.__esModule?a(o,"default",{value:e,enumerable:!0}):o,e)),O=e=>m(a({},"__esModule",{value:!0}),e);var H={};L(H,{autoFocusEvent:()=>f,useFocusTrap:()=>C});module.exports=O(H);var s=R(require("react"),1),h=["a[href]","button:not([disabled])",'input:not([disabled]):not([type="hidden"])',"select:not([disabled])","textarea:not([disabled])",'[tabindex]:not([tabindex="-1"])'].join(", ");function E(e){return Array.from(e.querySelectorAll(h)).filter(t=>t.offsetParent!==null||t===document.activeElement)}function f(e,t){if(!t)return!0;let o=new CustomEvent(e,{cancelable:!0,detail:null});return t(o),!o.defaultPrevented}function C(e,t,o={}){let c=s.useRef(o);s.useEffect(()=>{c.current=o}),s.useEffect(()=>{if(!t)return;let n=e.current;if(!n)return;let l=document.activeElement,p=requestAnimationFrame(()=>{if(n.contains(document.activeElement)||!f("open-auto-focus",c.current.onOpenAutoFocus))return;let r=E(n)[0]??n;n.tabIndex=n.tabIndex>=0?n.tabIndex:-1,r.focus({preventScroll:!0})}),d=u=>{if(u.key!=="Tab")return;let r=E(n);if(r.length===0){u.preventDefault();return}let b=r[0],v=r[r.length-1],i=document.activeElement;u.shiftKey&&(i===b||i===n)?(u.preventDefault(),v.focus()):!u.shiftKey&&i===v&&(u.preventDefault(),b.focus())};return n.addEventListener("keydown",d),()=>{cancelAnimationFrame(p),n.removeEventListener("keydown",d),f("close-auto-focus",c.current.onCloseAutoFocus)&&l&&document.contains(l)&&l.focus?.({preventScroll:!0})}},[e,t])}0&&(module.exports={autoFocusEvent,useFocusTrap});

package/dist/utils/useFocusTrap.d.cts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+/** The cancelable stand-in an auto-focus handler receives — there is no native event for "I am about to move focus". */
+export type AutoFocusEvent = CustomEvent<null>;
+/**
+ * Announces an automatic focus move as a cancelable event and reports whether
+ * it may go ahead. Shared by the focus trap and by the overlays that return
+ * focus to their trigger by hand, so the veto means the same thing in both.
+ */
+export declare function autoFocusEvent(type: 'open-auto-focus' | 'close-auto-focus', handler?: (event: AutoFocusEvent) => void): boolean;
+/** Consumer overrides for the two focus moves the trap makes on the overlay's behalf. */
+export interface FocusTrapOptions {
+    /** Fired before focus moves into the container; `preventDefault()` leaves focus where it is. */
+    onOpenAutoFocus?: (event: AutoFocusEvent) => void;
+    /** Fired before focus returns to the previously focused element; `preventDefault()` suppresses the return. */
+    onCloseAutoFocus?: (event: AutoFocusEvent) => void;
+}
+/**
+ * Traps Tab focus inside `containerRef` while `enabled`. Focuses the first
+ * tabbable element (or the container) on mount and restores focus to the
+ * previously focused element on unmount — each of those two moves first
+ * announced as a cancelable `open-auto-focus` / `close-auto-focus` event, so
+ * a consumer can redirect initial focus or take over the return when the
+ * trigger no longer exists (the WAI-ARIA modal pattern's two escape hatches).
+ */
+export declare function useFocusTrap(containerRef: React.RefObject<HTMLElement | null>, enabled: boolean, options?: FocusTrapOptions): void;

package/dist/utils/useFocusTrap.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+/** The cancelable stand-in an auto-focus handler receives — there is no native event for "I am about to move focus". */
+export type AutoFocusEvent = CustomEvent<null>;
+/**
+ * Announces an automatic focus move as a cancelable event and reports whether
+ * it may go ahead. Shared by the focus trap and by the overlays that return
+ * focus to their trigger by hand, so the veto means the same thing in both.
+ */
+export declare function autoFocusEvent(type: 'open-auto-focus' | 'close-auto-focus', handler?: (event: AutoFocusEvent) => void): boolean;
+/** Consumer overrides for the two focus moves the trap makes on the overlay's behalf. */
+export interface FocusTrapOptions {
+    /** Fired before focus moves into the container; `preventDefault()` leaves focus where it is. */
+    onOpenAutoFocus?: (event: AutoFocusEvent) => void;
+    /** Fired before focus returns to the previously focused element; `preventDefault()` suppresses the return. */
+    onCloseAutoFocus?: (event: AutoFocusEvent) => void;
+}
+/**
+ * Traps Tab focus inside `containerRef` while `enabled`. Focuses the first
+ * tabbable element (or the container) on mount and restores focus to the
+ * previously focused element on unmount — each of those two moves first
+ * announced as a cancelable `open-auto-focus` / `close-auto-focus` event, so
+ * a consumer can redirect initial focus or take over the return when the
+ * trigger no longer exists (the WAI-ARIA modal pattern's two escape hatches).
+ */
+export declare function useFocusTrap(containerRef: React.RefObject<HTMLElement | null>, enabled: boolean, options?: FocusTrapOptions): void;

package/dist/utils/useFocusTrap.js

@@ -0,0 +1 @@
+import*as r from"react";var E=["a[href]","button:not([disabled])",'input:not([disabled]):not([type="hidden"])',"select:not([disabled])","textarea:not([disabled])",'[tabindex]:not([tabindex="-1"])'].join(", ");function b(o){return Array.from(o.querySelectorAll(E)).filter(t=>t.offsetParent!==null||t===document.activeElement)}function v(o,t){if(!t)return!0;let c=new CustomEvent(o,{cancelable:!0,detail:null});return t(c),!c.defaultPrevented}function p(o,t,c={}){let s=r.useRef(c);r.useEffect(()=>{s.current=c}),r.useEffect(()=>{if(!t)return;let e=o.current;if(!e)return;let a=document.activeElement,m=requestAnimationFrame(()=>{if(e.contains(document.activeElement)||!v("open-auto-focus",s.current.onOpenAutoFocus))return;let u=b(e)[0]??e;e.tabIndex=e.tabIndex>=0?e.tabIndex:-1,u.focus({preventScroll:!0})}),i=n=>{if(n.key!=="Tab")return;let u=b(e);if(u.length===0){n.preventDefault();return}let f=u[0],d=u[u.length-1],l=document.activeElement;n.shiftKey&&(l===f||l===e)?(n.preventDefault(),d.focus()):!n.shiftKey&&l===d&&(n.preventDefault(),f.focus())};return e.addEventListener("keydown",i),()=>{cancelAnimationFrame(m),e.removeEventListener("keydown",i),v("close-auto-focus",s.current.onCloseAutoFocus)&&a&&document.contains(a)&&a.focus?.({preventScroll:!0})}},[o,t])}export{v as autoFocusEvent,p as useFocusTrap};

package/dist/utils/useMenuItem.cjs

@@ -0,0 +1 @@
+"use strict";var a=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var m=(e,n)=>{for(var r in n)a(e,r,{get:n[r],enumerable:!0})},s=(e,n,r,i)=>{if(n&&typeof n=="object"||typeof n=="function")for(let t of f(n))!d.call(e,t)&&t!==r&&a(e,t,{get:()=>n[t],enumerable:!(i=l(n,t))||i.enumerable});return e};var v=e=>s(a({},"__esModule",{value:!0}),e);var P={};m(P,{useMenuItem:()=>E});module.exports=v(P);var c=require("./primitive.cjs");function E({disabled:e,onSelect:n,onSelected:r,contentRef:i,props:t}){let u=()=>{if(e)return;let o=new CustomEvent("skdx-menu-item-select",{cancelable:!0});n?.(o),o.defaultPrevented||r()};return{"data-disabled":e?"":void 0,"aria-disabled":e||void 0,tabIndex:e?void 0:-1,onClick:(0,c.composeEventHandlers)(t.onClick,u),onKeyDown:(0,c.composeEventHandlers)(t.onKeyDown,o=>{[" ","Enter"].includes(o.key)&&(o.preventDefault(),u())}),onPointerEnter:(0,c.composeEventHandlers)(t.onPointerEnter,o=>{e||o.currentTarget.focus()}),onPointerLeave:(0,c.composeEventHandlers)(t.onPointerLeave,o=>{o.currentTarget===document.activeElement&&i.current?.focus()})}}0&&(module.exports={useMenuItem});

package/dist/utils/useMenuItem.d.cts

@@ -0,0 +1,27 @@
+import type * as React from 'react';
+/** @internal Options for {@link useMenuItem}, the shared menu-item interaction hook. */
+export interface UseMenuItemOptions {
+    disabled?: boolean;
+    /** Called when the item is activated. `event.preventDefault()` keeps the menu open. */
+    onSelect?: (event: Event) => void;
+    /** Called after a select that wasn't prevented — typically closes the menu (and may refocus its trigger). */
+    onSelected: () => void;
+    /** Where focus returns to on pointer-leave, so keyboard nav resumes at the container. */
+    contentRef: React.RefObject<HTMLElement | null>;
+    props: Pick<React.ComponentPropsWithRef<'div'>, 'onClick' | 'onKeyDown' | 'onPointerEnter' | 'onPointerLeave'>;
+}
+/**
+ * Shared interaction wiring for DropdownMenuItem, ContextMenuItem, and
+ * MenubarItem — the three menu families differ in how a menu opens and
+ * closes, but a `menuitem`'s own click/keyboard/hover behavior is identical
+ * across all of them.
+ */
+export declare function useMenuItem({ disabled, onSelect, onSelected, contentRef, props }: UseMenuItemOptions): {
+    'data-disabled': string | undefined;
+    'aria-disabled': true | undefined;
+    tabIndex: number | undefined;
+    onClick: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    onKeyDown: (event: React.KeyboardEvent<HTMLDivElement>) => void;
+    onPointerEnter: (event: React.PointerEvent<HTMLDivElement>) => void;
+    onPointerLeave: (event: React.PointerEvent<HTMLDivElement>) => void;
+};

package/dist/utils/useMenuItem.d.ts

@@ -0,0 +1,27 @@
+import type * as React from 'react';
+/** @internal Options for {@link useMenuItem}, the shared menu-item interaction hook. */
+export interface UseMenuItemOptions {
+    disabled?: boolean;
+    /** Called when the item is activated. `event.preventDefault()` keeps the menu open. */
+    onSelect?: (event: Event) => void;
+    /** Called after a select that wasn't prevented — typically closes the menu (and may refocus its trigger). */
+    onSelected: () => void;
+    /** Where focus returns to on pointer-leave, so keyboard nav resumes at the container. */
+    contentRef: React.RefObject<HTMLElement | null>;
+    props: Pick<React.ComponentPropsWithRef<'div'>, 'onClick' | 'onKeyDown' | 'onPointerEnter' | 'onPointerLeave'>;
+}
+/**
+ * Shared interaction wiring for DropdownMenuItem, ContextMenuItem, and
+ * MenubarItem — the three menu families differ in how a menu opens and
+ * closes, but a `menuitem`'s own click/keyboard/hover behavior is identical
+ * across all of them.
+ */
+export declare function useMenuItem({ disabled, onSelect, onSelected, contentRef, props }: UseMenuItemOptions): {
+    'data-disabled': string | undefined;
+    'aria-disabled': true | undefined;
+    tabIndex: number | undefined;
+    onClick: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    onKeyDown: (event: React.KeyboardEvent<HTMLDivElement>) => void;
+    onPointerEnter: (event: React.PointerEvent<HTMLDivElement>) => void;
+    onPointerLeave: (event: React.PointerEvent<HTMLDivElement>) => void;
+};

package/dist/utils/useMenuItem.js

@@ -0,0 +1 @@
+import{composeEventHandlers as o}from"./primitive.js";function l({disabled:n,onSelect:c,onSelected:i,contentRef:a,props:t}){let r=()=>{if(n)return;let e=new CustomEvent("skdx-menu-item-select",{cancelable:!0});c?.(e),e.defaultPrevented||i()};return{"data-disabled":n?"":void 0,"aria-disabled":n||void 0,tabIndex:n?void 0:-1,onClick:o(t.onClick,r),onKeyDown:o(t.onKeyDown,e=>{[" ","Enter"].includes(e.key)&&(e.preventDefault(),r())}),onPointerEnter:o(t.onPointerEnter,e=>{n||e.currentTarget.focus()}),onPointerLeave:o(t.onPointerLeave,e=>{e.currentTarget===document.activeElement&&a.current?.focus()})}}export{l as useMenuItem};

package/dist/utils/useOpenChangeComplete.cjs

@@ -0,0 +1 @@
+"use strict";var E=Object.create;var s=Object.defineProperty;var b=Object.getOwnPropertyDescriptor;var C=Object.getOwnPropertyNames;var L=Object.getPrototypeOf,h=Object.prototype.hasOwnProperty;var R=(e,n)=>{for(var t in n)s(e,t,{get:n[t],enumerable:!0})},v=(e,n,t,r)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of C(n))!h.call(e,o)&&o!==t&&s(e,o,{get:()=>n[o],enumerable:!(r=b(n,o))||r.enumerable});return e};var g=(e,n,t)=>(t=e!=null?E(L(e)):{},v(n||!e||!e.__esModule?s(t,"default",{value:e,enumerable:!0}):t,e)),y=e=>v(s({},"__esModule",{value:!0}),e);var M={};R(M,{useOpenChangeComplete:()=>F});module.exports=y(M);var c=g(require("react"),1),p=require("./useCallbackRef.cjs");function A(e){let{animationName:n,transitionDuration:t,display:r}=getComputedStyle(e);return r==="none"?!1:n!==""&&n!=="none"?!0:t.split(",").some(o=>Number.parseFloat(o)>0)}function F(e,n,t){let r=(0,p.useCallbackRef)(t),o=c.useRef(!0);c.useEffect(()=>{if(o.current){o.current=!1;return}let l=["animationend","animationcancel","transitionend","transitioncancel"],u,m=()=>{let a=n.current;if(!a||!a.isConnected||!A(a)){r(e);return}let d=i=>{i.target===a&&r(e)};for(let i of l)a.addEventListener(i,d);u=()=>{for(let i of l)a.removeEventListener(i,d)}},f=0;return e&&!n.current?f=requestAnimationFrame(m):m(),()=>{cancelAnimationFrame(f),u?.()}},[e,n,r])}0&&(module.exports={useOpenChangeComplete});

package/dist/utils/useOpenChangeComplete.d.cts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+/**
+ * Calls `onOpenChangeComplete` with the new open state once the change has
+ * finished on screen — after the content's enter or exit animation ends, or
+ * as soon as the content has settled when there is no motion declared (the
+ * same task on close, the next frame on open, where the portal needs a second
+ * commit to put the element in the DOM).
+ *
+ * The settled counterpart to `onOpenChange`, which fires the instant the state
+ * flips. Use it for work that must not race the transition: measuring the
+ * panel, moving focus after an entrance, or tearing down an expensive child
+ * once the exit has played.
+ *
+ * Pass the ref the content element is attached to. On close without
+ * `forceMount` React has already cleared it, which is itself the signal that
+ * nothing is animating and the close is complete.
+ *
+ * @example
+ * ```tsx
+ * const contentRef = React.useRef<HTMLDivElement>(null);
+ * useOpenChangeComplete(open, contentRef, onOpenChangeComplete);
+ * ```
+ */
+export declare function useOpenChangeComplete(open: boolean, nodeRef: React.RefObject<HTMLElement | null>, onOpenChangeComplete?: (open: boolean) => void): void;

package/dist/utils/useOpenChangeComplete.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+/**
+ * Calls `onOpenChangeComplete` with the new open state once the change has
+ * finished on screen — after the content's enter or exit animation ends, or
+ * as soon as the content has settled when there is no motion declared (the
+ * same task on close, the next frame on open, where the portal needs a second
+ * commit to put the element in the DOM).
+ *
+ * The settled counterpart to `onOpenChange`, which fires the instant the state
+ * flips. Use it for work that must not race the transition: measuring the
+ * panel, moving focus after an entrance, or tearing down an expensive child
+ * once the exit has played.
+ *
+ * Pass the ref the content element is attached to. On close without
+ * `forceMount` React has already cleared it, which is itself the signal that
+ * nothing is animating and the close is complete.
+ *
+ * @example
+ * ```tsx
+ * const contentRef = React.useRef<HTMLDivElement>(null);
+ * useOpenChangeComplete(open, contentRef, onOpenChangeComplete);
+ * ```
+ */
+export declare function useOpenChangeComplete(open: boolean, nodeRef: React.RefObject<HTMLElement | null>, onOpenChangeComplete?: (open: boolean) => void): void;

package/dist/utils/useOpenChangeComplete.js

@@ -0,0 +1 @@
+import*as i from"react";import{useCallbackRef as d}from"./useCallbackRef.js";function v(e){let{animationName:n,transitionDuration:s,display:o}=getComputedStyle(e);return o==="none"?!1:n!==""&&n!=="none"?!0:s.split(",").some(a=>Number.parseFloat(a)>0)}function E(e,n,s){let o=d(s),a=i.useRef(!0);i.useEffect(()=>{if(a.current){a.current=!1;return}let c=["animationend","animationcancel","transitionend","transitioncancel"],l,u=()=>{let t=n.current;if(!t||!t.isConnected||!v(t)){o(e);return}let f=r=>{r.target===t&&o(e)};for(let r of c)t.addEventListener(r,f);l=()=>{for(let r of c)t.removeEventListener(r,f)}},m=0;return e&&!n.current?m=requestAnimationFrame(u):u(),()=>{cancelAnimationFrame(m),l?.()}},[e,n,o])}export{E as useOpenChangeComplete};

package/dist/utils/useOptionCollection.cjs

@@ -0,0 +1 @@
+"use strict";var C=Object.create;var O=Object.defineProperty;var A=Object.getOwnPropertyDescriptor;var M=Object.getOwnPropertyNames;var H=Object.getPrototypeOf,L=Object.prototype.hasOwnProperty;var S=(t,i)=>{for(var r in i)O(t,r,{get:i[r],enumerable:!0})},E=(t,i,r,c)=>{if(i&&typeof i=="object"||typeof i=="function")for(let l of M(i))!L.call(t,l)&&l!==r&&O(t,l,{get:()=>i[l],enumerable:!(c=A(i,l))||c.enumerable});return t};var T=(t,i,r)=>(r=t!=null?C(H(t)):{},E(i||!t||!t.__esModule?O(r,"default",{value:t,enumerable:!0}):r,t)),k=t=>E(O({},"__esModule",{value:!0}),t);var U={};S(U,{useOptionCollection:()=>q,useOptionEntry:()=>w});module.exports=k(U);var e=T(require("react"),1),R='[role="option"]:not([data-disabled])';function q({open:t,setOpen:i,contentRef:r}){let[c,l]=e.useState(null),[g,p]=e.useState(()=>new Map),u=e.useRef(null),[x,f]=e.useState(t);t!==x&&(f(t),t||l(null)),e.useEffect(()=>{if(!t)return;let s=requestAnimationFrame(()=>{let o=u.current;if(u.current=null,!o)return;let n=r.current?.querySelectorAll(R);if(!n||n.length===0)return;let m=o==="last"?n[n.length-1]:n[0];l(a=>a??m.id)});return()=>cancelAnimationFrame(s)},[t,r]),e.useLayoutEffect(()=>{if(c===null)return;let s=Array.from(r.current?.querySelectorAll(R)??[]);s.some(o=>o.id===c)||l(s[0]?.id??null)});let d=e.useCallback((s,o)=>{p(n=>{let m=n.get(s);if(m?.value===o.value&&m.text===o.text)return n;let a=new Map(n);return a.set(s,o),a})},[]),v=e.useCallback(s=>{p(o=>{if(!o.has(s))return o;let n=new Map(o);return n.delete(s),n})},[]),I=e.useCallback(s=>g.get(s),[g]),y=e.useCallback(s=>{u.current=s,i(!0)},[i]),b=e.useCallback(s=>{let o=r.current;if(!o)return;let n=Array.from(o.querySelectorAll(R));if(n.length===0)return;let a=n.findIndex(h=>h.id===c)+s;a<0&&(a=0),a>=n.length&&(a=n.length-1),l(n[a].id)},[c,r]);return{activeId:c,setActiveId:l,itemCount:g.size,registerItem:d,unregisterItem:v,getItem:I,openWithHighlight:y,moveActive:b}}function w({id:t,value:i,textValue:r,itemRef:c,matchesFilter:l,registerItem:g,unregisterItem:p}){let[u,x]=e.useState(r??null);e.useLayoutEffect(()=>{let d=r??c.current?.textContent;d!=null&&d!==u&&x(d)});let f=u===null||l(u);return e.useEffect(()=>{if(f)return g(t,{value:i,text:u??""}),()=>p(t)},[t,f,i,u]),{text:u,visible:f}}0&&(module.exports={useOptionCollection,useOptionEntry});

package/dist/utils/useOptionCollection.d.cts

@@ -0,0 +1,90 @@
+import * as React from 'react';
+/**
+ * The virtual-focus option collection behind every listbox-with-a-textbox in
+ * this package — `Combobox`, `Autocomplete`, `MultiSelect`.
+ *
+ * All three face the identical set of problems: real DOM focus never leaves
+ * the input, so the highlighted option is tracked as an id and mirrored into
+ * `aria-activedescendant`; the highlighted option can be filtered out from
+ * under the highlight; opening with Arrow Down has to wait for the popup's
+ * items to mount before "first" means anything; and moving the highlight is a
+ * DOM question, not a state question, because items register in a passive
+ * effect one commit behind the DOM they describe.
+ *
+ * Extracted here rather than copied into each family: the answers are the
+ * same in all three, and the two-pass convergence in the layout effect below
+ * is exactly the kind of thing that rots when it exists three times.
+ *
+ * @internal
+ */
+/** @internal What one registered option contributes to a {@link useOptionCollection} collection. */
+export interface OptionEntry {
+    /** Identifier committed to the owning root's value when this option is chosen. */
+    value: string;
+    /** The option's `textValue`, or its rendered text — matched by `filter` and written back into the input. */
+    text: string;
+}
+/** @internal Parameters for {@link useOptionCollection}. */
+export interface UseOptionCollectionOptions {
+    /** Whether the popup listing the options is currently open. */
+    open: boolean;
+    /** Opens/closes that popup — used by {@link OptionCollection.openWithHighlight}. */
+    setOpen: (open: boolean) => void;
+    /** The popup element the options are rendered inside; read directly for highlight moves. */
+    contentRef: React.RefObject<HTMLDivElement | null>;
+}
+/** @internal What {@link useOptionCollection} hands back to a root's context. */
+export interface OptionCollection {
+    /** Element id of the virtually-focused option, mirrored into the input's `aria-activedescendant`. */
+    activeId: string | null;
+    /** Moves the virtual focus, or clears it with `null`. */
+    setActiveId: (id: string | null) => void;
+    /** How many options are currently registered (i.e. rendered and surviving the filter). */
+    itemCount: number;
+    /** Adds an option to the collection under its element id. */
+    registerItem: (id: string, entry: OptionEntry) => void;
+    /** Removes an option from the collection. */
+    unregisterItem: (id: string) => void;
+    /** The registered entry behind an option id, for committing the virtually-focused option. */
+    getItem: (id: string) => OptionEntry | undefined;
+    /** Opens the popup and, once its options are mounted, highlights the first (or last) one. */
+    openWithHighlight: (edge: 'first' | 'last') => void;
+    /** Moves the highlight one option forward (`1`) or back (`-1`), clamped at both ends. */
+    moveActive: (direction: 1 | -1) => void;
+}
+export declare function useOptionCollection({ open, setOpen, contentRef, }: UseOptionCollectionOptions): OptionCollection;
+/** @internal Parameters for {@link useOptionEntry}. */
+export interface UseOptionEntryOptions {
+    /** This option's element id — the value the input's `aria-activedescendant` carries while it is highlighted. */
+    id: string;
+    /** The value committed to the root when this option is chosen. */
+    value: string;
+    /** Explicit text for matching, when the option renders more than its label. */
+    textValue: string | undefined;
+    /** The element rendering this option, measured for its text when `textValue` is absent. */
+    itemRef: React.RefObject<HTMLElement | null>;
+    /** Whether an option with this text survives the root's current filter and draft text. */
+    matchesFilter: (text: string) => boolean;
+    /** The root's collection registration, from {@link useOptionCollection}. */
+    registerItem: (id: string, entry: OptionEntry) => void;
+    /** The root's collection de-registration, from {@link useOptionCollection}. */
+    unregisterItem: (id: string) => void;
+}
+/**
+ * The measure-then-filter-then-register cycle every `*Item` part runs, shared
+ * by `Autocomplete` and `MultiSelect`.
+ *
+ * The ordering is the whole point and is easy to get wrong: an option's text
+ * has to exist in the DOM before the filter can measure it, so an unmeasured
+ * option always renders; a rejected option renders *nothing at all* rather
+ * than hiding, because a hidden option is still reachable through
+ * `aria-activedescendant` and would still be counted as a result.
+ *
+ * @returns The option's measured text (or `null` before the first measurement)
+ * and whether it should render.
+ * @internal
+ */
+export declare function useOptionEntry({ id, value, textValue, itemRef, matchesFilter, registerItem, unregisterItem, }: UseOptionEntryOptions): {
+    text: string | null;
+    visible: boolean;
+};

package/dist/utils/useOptionCollection.d.ts

@@ -0,0 +1,90 @@
+import * as React from 'react';
+/**
+ * The virtual-focus option collection behind every listbox-with-a-textbox in
+ * this package — `Combobox`, `Autocomplete`, `MultiSelect`.
+ *
+ * All three face the identical set of problems: real DOM focus never leaves
+ * the input, so the highlighted option is tracked as an id and mirrored into
+ * `aria-activedescendant`; the highlighted option can be filtered out from
+ * under the highlight; opening with Arrow Down has to wait for the popup's
+ * items to mount before "first" means anything; and moving the highlight is a
+ * DOM question, not a state question, because items register in a passive
+ * effect one commit behind the DOM they describe.
+ *
+ * Extracted here rather than copied into each family: the answers are the
+ * same in all three, and the two-pass convergence in the layout effect below
+ * is exactly the kind of thing that rots when it exists three times.
+ *
+ * @internal
+ */
+/** @internal What one registered option contributes to a {@link useOptionCollection} collection. */
+export interface OptionEntry {
+    /** Identifier committed to the owning root's value when this option is chosen. */
+    value: string;
+    /** The option's `textValue`, or its rendered text — matched by `filter` and written back into the input. */
+    text: string;
+}
+/** @internal Parameters for {@link useOptionCollection}. */
+export interface UseOptionCollectionOptions {
+    /** Whether the popup listing the options is currently open. */
+    open: boolean;
+    /** Opens/closes that popup — used by {@link OptionCollection.openWithHighlight}. */
+    setOpen: (open: boolean) => void;
+    /** The popup element the options are rendered inside; read directly for highlight moves. */
+    contentRef: React.RefObject<HTMLDivElement | null>;
+}
+/** @internal What {@link useOptionCollection} hands back to a root's context. */
+export interface OptionCollection {
+    /** Element id of the virtually-focused option, mirrored into the input's `aria-activedescendant`. */
+    activeId: string | null;
+    /** Moves the virtual focus, or clears it with `null`. */
+    setActiveId: (id: string | null) => void;
+    /** How many options are currently registered (i.e. rendered and surviving the filter). */
+    itemCount: number;
+    /** Adds an option to the collection under its element id. */
+    registerItem: (id: string, entry: OptionEntry) => void;
+    /** Removes an option from the collection. */
+    unregisterItem: (id: string) => void;
+    /** The registered entry behind an option id, for committing the virtually-focused option. */
+    getItem: (id: string) => OptionEntry | undefined;
+    /** Opens the popup and, once its options are mounted, highlights the first (or last) one. */
+    openWithHighlight: (edge: 'first' | 'last') => void;
+    /** Moves the highlight one option forward (`1`) or back (`-1`), clamped at both ends. */
+    moveActive: (direction: 1 | -1) => void;
+}
+export declare function useOptionCollection({ open, setOpen, contentRef, }: UseOptionCollectionOptions): OptionCollection;
+/** @internal Parameters for {@link useOptionEntry}. */
+export interface UseOptionEntryOptions {
+    /** This option's element id — the value the input's `aria-activedescendant` carries while it is highlighted. */
+    id: string;
+    /** The value committed to the root when this option is chosen. */
+    value: string;
+    /** Explicit text for matching, when the option renders more than its label. */
+    textValue: string | undefined;
+    /** The element rendering this option, measured for its text when `textValue` is absent. */
+    itemRef: React.RefObject<HTMLElement | null>;
+    /** Whether an option with this text survives the root's current filter and draft text. */
+    matchesFilter: (text: string) => boolean;
+    /** The root's collection registration, from {@link useOptionCollection}. */
+    registerItem: (id: string, entry: OptionEntry) => void;
+    /** The root's collection de-registration, from {@link useOptionCollection}. */
+    unregisterItem: (id: string) => void;
+}
+/**
+ * The measure-then-filter-then-register cycle every `*Item` part runs, shared
+ * by `Autocomplete` and `MultiSelect`.
+ *
+ * The ordering is the whole point and is easy to get wrong: an option's text
+ * has to exist in the DOM before the filter can measure it, so an unmeasured
+ * option always renders; a rejected option renders *nothing at all* rather
+ * than hiding, because a hidden option is still reachable through
+ * `aria-activedescendant` and would still be counted as a result.
+ *
+ * @returns The option's measured text (or `null` before the first measurement)
+ * and whether it should render.
+ * @internal
+ */
+export declare function useOptionEntry({ id, value, textValue, itemRef, matchesFilter, registerItem, unregisterItem, }: UseOptionEntryOptions): {
+    text: string | null;
+    visible: boolean;
+};

package/dist/utils/useOptionCollection.js

@@ -0,0 +1 @@
+import*as t from"react";var x='[role="option"]:not([data-disabled])';function b({open:r,setOpen:a,contentRef:l}){let[c,u]=t.useState(null),[g,p]=t.useState(()=>new Map),s=t.useRef(null),[O,f]=t.useState(r);r!==O&&(f(r),r||u(null)),t.useEffect(()=>{if(!r)return;let n=requestAnimationFrame(()=>{let i=s.current;if(s.current=null,!i)return;let e=l.current?.querySelectorAll(x);if(!e||e.length===0)return;let m=i==="last"?e[e.length-1]:e[0];u(o=>o??m.id)});return()=>cancelAnimationFrame(n)},[r,l]),t.useLayoutEffect(()=>{if(c===null)return;let n=Array.from(l.current?.querySelectorAll(x)??[]);n.some(i=>i.id===c)||u(n[0]?.id??null)});let d=t.useCallback((n,i)=>{p(e=>{let m=e.get(n);if(m?.value===i.value&&m.text===i.text)return e;let o=new Map(e);return o.set(n,i),o})},[]),R=t.useCallback(n=>{p(i=>{if(!i.has(n))return i;let e=new Map(i);return e.delete(n),e})},[]),E=t.useCallback(n=>g.get(n),[g]),v=t.useCallback(n=>{s.current=n,a(!0)},[a]),I=t.useCallback(n=>{let i=l.current;if(!i)return;let e=Array.from(i.querySelectorAll(x));if(e.length===0)return;let o=e.findIndex(y=>y.id===c)+n;o<0&&(o=0),o>=e.length&&(o=e.length-1),u(e[o].id)},[c,l]);return{activeId:c,setActiveId:u,itemCount:g.size,registerItem:d,unregisterItem:R,getItem:E,openWithHighlight:v,moveActive:I}}function h({id:r,value:a,textValue:l,itemRef:c,matchesFilter:u,registerItem:g,unregisterItem:p}){let[s,O]=t.useState(l??null);t.useLayoutEffect(()=>{let d=l??c.current?.textContent;d!=null&&d!==s&&O(d)});let f=s===null||u(s);return t.useEffect(()=>{if(f)return g(r,{value:a,text:s??""}),()=>p(r)},[r,f,a,s]),{text:s,visible:f}}export{b as useOptionCollection,h as useOptionEntry};

package/dist/utils/usePointerAngle.cjs

@@ -0,0 +1 @@
+"use strict";var R=Object.create;var f=Object.defineProperty;var b=Object.getOwnPropertyDescriptor;var h=Object.getOwnPropertyNames;var A=Object.getPrototypeOf,C=Object.prototype.hasOwnProperty;var L=(n,e)=>{for(var r in e)f(n,r,{get:e[r],enumerable:!0})},E=(n,e,r,g)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of h(e))!C.call(n,t)&&t!==r&&f(n,t,{get:()=>e[t],enumerable:!(g=b(e,t))||g.enumerable});return n};var w=(n,e,r)=>(r=n!=null?R(A(n)):{},E(e||!n||!n.__esModule?f(r,"default",{value:n,enumerable:!0}):r,n)),x=n=>E(f({},"__esModule",{value:!0}),n);var U={};L(U,{usePointerAngle:()=>M});module.exports=x(U);var i=w(require("react"),1);function D(n,e){return(Math.atan2(n,-e)*180/Math.PI+360)%360}function I(n,e){return e?Math.round(Math.round(n/e)*e*1e6)/1e6%360:n}function M(n){let e=i.useRef(n);i.useEffect(()=>{e.current=n});let[r,g]=i.useState(!1),t=i.useRef(null),v=(u,c)=>{let o=c.getBoundingClientRect(),s=u.clientX-(o.left+o.width/2),d=u.clientY-(o.top+o.height/2);return I(D(s,d),e.current.step??0)},P=u=>{if(t.current)return;let c=u.currentTarget,{pointerId:o}=u;c.setPointerCapture?.(o);let s=v(u,c);g(!0),e.current.onAngleChange(s,u.nativeEvent);let d=l=>{if(l.pointerId!==o)return;let p=v(l,c);p!==s&&(s=p,e.current.onAngleChange(p,l))},m=l=>{l.pointerId===o&&(t.current?.(),g(!1),e.current.onAngleChangeEnd?.(s,l))},a=c.ownerDocument;a.addEventListener("pointermove",d),a.addEventListener("pointerup",m),a.addEventListener("pointercancel",m),t.current=()=>{a.removeEventListener("pointermove",d),a.removeEventListener("pointerup",m),a.removeEventListener("pointercancel",m),t.current=null}};return i.useEffect(()=>()=>t.current?.(),[]),{onPointerDown:P,dragging:r}}0&&(module.exports={usePointerAngle});