@skdx/vue 0.27.0 → 0.29.0

package/dist/utils/useCheckable.cjs

@@ -0,0 +1 @@
+const n=require("./useFormReset.cjs");let r=require("vue");function l(e){const t=(0,r.ref)(e.defaultChecked()),a=()=>e.checked()!==void 0,u=(0,r.computed)(()=>e.checked()??t.value);function c(d){a()||(t.value=d),e.onChange(d)}return n.useFormReset(e.resetTarget,()=>c(e.defaultChecked())),{checked:u,state:(0,r.computed)(()=>u.value==="indeterminate"?"indeterminate":u.value?"checked":"unchecked"),ariaChecked:(0,r.computed)(()=>u.value==="indeterminate"?"mixed":u.value?"true":"false"),hiddenChecked:(0,r.computed)(()=>u.value===!0),toggle(){e.disabled()||e.readOnly()||c(u.value==="indeterminate"?!0:!u.value)}}}exports.useCheckable=l;

package/dist/utils/useCheckable.d.cts

@@ -0,0 +1,38 @@
+import { type ComputedRef } from 'vue';
+/** @internal Checked state of a two- or three-state control; only a checkbox reaches `indeterminate`. */
+export type CheckedState = boolean | 'indeterminate';
+/** @internal What a checkable control hands the shared engine. */
+export interface UseCheckableOptions {
+    /** The consumer's controlled state; `undefined` leaves the control holding its own. */
+    checked: () => CheckedState | undefined;
+    /** The state an uncontrolled control starts at and a form reset restores. */
+    defaultChecked: () => CheckedState;
+    /** Whether toggling is refused; a read-only control keeps its tab stop. */
+    readOnly: () => boolean;
+    /** Whether toggling is refused because the control is out of use entirely. */
+    disabled: () => boolean;
+    /** Called with the state in force after a toggle or a form reset. */
+    onChange: (next: CheckedState) => void;
+    /** The element a form reset is observed through — the hidden input, or the control itself. */
+    resetTarget: () => HTMLElement | null;
+}
+/** @internal The checked state, its rendered spellings, and the toggle every checkable control shares. */
+export interface Checkable {
+    /** The state in force: the controlled one when there is one, the control's own otherwise. */
+    checked: ComputedRef<CheckedState>;
+    /** `data-state`: `checked`, `unchecked` or `indeterminate`. */
+    state: ComputedRef<'checked' | 'unchecked' | 'indeterminate'>;
+    /** `aria-checked`, where an indeterminate box announces as `mixed`. */
+    ariaChecked: ComputedRef<'true' | 'false' | 'mixed'>;
+    /** What the hidden form input carries, where indeterminate submits as unchecked. */
+    hiddenChecked: ComputedRef<boolean>;
+    /** Flips the state unless the control is disabled or read-only; indeterminate resolves to checked. */
+    toggle: () => void;
+}
+/**
+ * Shared checked-state engine for `role="checkbox"` and `role="switch"`: the
+ * controlled/uncontrolled split, the toggle, and the form-reset commit that
+ * keeps the button from drifting from the hidden input the browser restores.
+ * @internal
+ */
+export declare function useCheckable(options: UseCheckableOptions): Checkable;

package/dist/utils/useCheckable.d.ts

@@ -0,0 +1,38 @@
+import { type ComputedRef } from 'vue';
+/** @internal Checked state of a two- or three-state control; only a checkbox reaches `indeterminate`. */
+export type CheckedState = boolean | 'indeterminate';
+/** @internal What a checkable control hands the shared engine. */
+export interface UseCheckableOptions {
+    /** The consumer's controlled state; `undefined` leaves the control holding its own. */
+    checked: () => CheckedState | undefined;
+    /** The state an uncontrolled control starts at and a form reset restores. */
+    defaultChecked: () => CheckedState;
+    /** Whether toggling is refused; a read-only control keeps its tab stop. */
+    readOnly: () => boolean;
+    /** Whether toggling is refused because the control is out of use entirely. */
+    disabled: () => boolean;
+    /** Called with the state in force after a toggle or a form reset. */
+    onChange: (next: CheckedState) => void;
+    /** The element a form reset is observed through — the hidden input, or the control itself. */
+    resetTarget: () => HTMLElement | null;
+}
+/** @internal The checked state, its rendered spellings, and the toggle every checkable control shares. */
+export interface Checkable {
+    /** The state in force: the controlled one when there is one, the control's own otherwise. */
+    checked: ComputedRef<CheckedState>;
+    /** `data-state`: `checked`, `unchecked` or `indeterminate`. */
+    state: ComputedRef<'checked' | 'unchecked' | 'indeterminate'>;
+    /** `aria-checked`, where an indeterminate box announces as `mixed`. */
+    ariaChecked: ComputedRef<'true' | 'false' | 'mixed'>;
+    /** What the hidden form input carries, where indeterminate submits as unchecked. */
+    hiddenChecked: ComputedRef<boolean>;
+    /** Flips the state unless the control is disabled or read-only; indeterminate resolves to checked. */
+    toggle: () => void;
+}
+/**
+ * Shared checked-state engine for `role="checkbox"` and `role="switch"`: the
+ * controlled/uncontrolled split, the toggle, and the form-reset commit that
+ * keeps the button from drifting from the hidden input the browser restores.
+ * @internal
+ */
+export declare function useCheckable(options: UseCheckableOptions): Checkable;

package/dist/utils/useCheckable.js

@@ -0,0 +1 @@
+import{useFormReset as e}from"./useFormReset.js";import{computed as a,ref as t}from"vue";function d(d){const u=t(d.defaultChecked()),c=a(()=>d.checked()??u.value);function n(e){void 0!==d.checked()||(u.value=e),d.onChange(e)}return e(d.resetTarget,()=>n(d.defaultChecked())),{checked:c,state:a(()=>"indeterminate"===c.value?"indeterminate":c.value?"checked":"unchecked"),ariaChecked:a(()=>"indeterminate"===c.value?"mixed":c.value?"true":"false"),hiddenChecked:a(()=>!0===c.value),toggle(){d.disabled()||d.readOnly()||n("indeterminate"===c.value||!c.value)}}}export{d as useCheckable};

package/dist/utils/useControllable.cjs

@@ -0,0 +1 @@
+const l=require("./controllable.cjs");let i=require("vue");function b({controlled:s,defaultValue:n,onChange:a}){const r=(0,i.ref)(n?.()),o=()=>({controlled:s(),uncontrolled:r.value}),d=(0,i.computed)(()=>l.controllableValue(o()));function u(t){const c=o(),v=l.controllableValue(c),e=l.decideControllable(c,t);return e.write&&(r.value=e.value),e.emit&&a?.(e.value,v),e.emit}return{value:d,set:t=>u(t),reset:()=>u(l.decideReset(o(),n?.()).value)}}exports.useControllable=b;

package/dist/utils/useControllable.d.cts

@@ -0,0 +1,28 @@
+import { type ComputedRef } from 'vue';
+/** @internal What a controllable value needs from its component: the two props, and where a real change goes. */
+export interface UseControllableOptions<T> {
+    /** Reads the controlled prop; `undefined` means the control owns its own value. */
+    controlled: () => T | undefined;
+    /** Reads the `defaultValue` prop, live, so a reset restores the current one rather than the one captured at mount. */
+    defaultValue?: () => T | undefined;
+    /** Runs once per actual change, after the value in force has moved; a no-op write never reaches it. */
+    onChange?: (value: T, previous: T | undefined) => void;
+}
+/** @internal A controlled/uncontrolled value and the two ways it moves. */
+export interface Controllable<T> {
+    /** The value in force: the controlled prop when there is one, the control's own otherwise. */
+    value: ComputedRef<T | undefined>;
+    /** Proposes a value; returns whether it was an actual change, so the caller can pair extra work with the event. */
+    set: (next: T) => boolean;
+    /** Restores the `defaultValue` prop as it reads now; returns whether that changed anything. */
+    reset: () => boolean;
+}
+/**
+ * One controlled/uncontrolled value: the controlled prop always wins, a
+ * controlled control never writes its own state, and the change callback runs
+ * exactly once per actual change.
+ *
+ * @param options the two props and the change callback
+ * @internal
+ */
+export declare function useControllable<T>({ controlled, defaultValue, onChange, }: UseControllableOptions<T>): Controllable<T>;

package/dist/utils/useControllable.d.ts

@@ -0,0 +1,28 @@
+import { type ComputedRef } from 'vue';
+/** @internal What a controllable value needs from its component: the two props, and where a real change goes. */
+export interface UseControllableOptions<T> {
+    /** Reads the controlled prop; `undefined` means the control owns its own value. */
+    controlled: () => T | undefined;
+    /** Reads the `defaultValue` prop, live, so a reset restores the current one rather than the one captured at mount. */
+    defaultValue?: () => T | undefined;
+    /** Runs once per actual change, after the value in force has moved; a no-op write never reaches it. */
+    onChange?: (value: T, previous: T | undefined) => void;
+}
+/** @internal A controlled/uncontrolled value and the two ways it moves. */
+export interface Controllable<T> {
+    /** The value in force: the controlled prop when there is one, the control's own otherwise. */
+    value: ComputedRef<T | undefined>;
+    /** Proposes a value; returns whether it was an actual change, so the caller can pair extra work with the event. */
+    set: (next: T) => boolean;
+    /** Restores the `defaultValue` prop as it reads now; returns whether that changed anything. */
+    reset: () => boolean;
+}
+/**
+ * One controlled/uncontrolled value: the controlled prop always wins, a
+ * controlled control never writes its own state, and the change callback runs
+ * exactly once per actual change.
+ *
+ * @param options the two props and the change callback
+ * @internal
+ */
+export declare function useControllable<T>({ controlled, defaultValue, onChange, }: UseControllableOptions<T>): Controllable<T>;

package/dist/utils/useControllable.js

@@ -0,0 +1 @@
+import{controllableValue as e,decideControllable as l,decideReset as o}from"./controllable.js";import{computed as t,ref as a}from"vue";function r({controlled:r,defaultValue:n,onChange:u}){const s=a(n?.()),c=()=>({controlled:r(),uncontrolled:s.value});function d(o){const t=c(),a=e(t),r=l(t,o);return r.write&&(s.value=r.value),r.emit&&u?.(r.value,a),r.emit}return{value:t(()=>e(c())),set:e=>d(e),reset:()=>d(o(c(),n?.()).value)}}export{r as useControllable};

package/dist/utils/useDismiss.cjs

@@ -1 +1 @@
-let m=require("vue");function y({enabled:a,onEscapeKeyDown:f,onPointerDownOutside:v,onFocusOutside:E,onInteractOutside:n},w){if(typeof document>"u")return;let o;const u=e=>!w.some(t=>t.value?.contains(e)),i=e=>{e.key==="Escape"&&f?.(e)},r=e=>{const t=e.target;t&&u(t)&&(n?.(e),v?.(e))},s=e=>{const t=e.target;if(!t||t===document.body||!u(t))return;const d=new CustomEvent("focus-outside",{detail:e,cancelable:!0});n?.(d),E?.(d)};function l(){document.addEventListener("keydown",i),o=setTimeout(()=>{document.addEventListener("pointerdown",r,!0),document.addEventListener("focusin",s,!0)},0)}function c(){document.removeEventListener("keydown",i),clearTimeout(o),document.removeEventListener("pointerdown",r,!0),document.removeEventListener("focusin",s,!0)}(0,m.watch)(a,e=>{c(),e&&l()},{immediate:!0}),(0,m.onBeforeUnmount)(c)}exports.useDismiss=y;
+const n=require("./dismissal.cjs");let l=require("vue");function L({enabled:w,onEscapeKeyDown:E,onPointerDownOutside:p,onFocusOutside:y,onInteractOutside:r},i){if(typeof document>"u")return;let s,o;const u={insideElements:()=>i.map(e=>e.value)},c=e=>!i.some(t=>t.value?.contains(e)),d=e=>{n.handleEscapeKeyDown(e,u,E)},a=e=>{const t=e.target;t&&c(t)&&(r?.(e),p?.(e))},m=e=>{const t=n.focusOutsideTarget(e);if(!t||!c(t))return;const v=n.focusOutsideEvent(e);r?.(v),y?.(v)};function D(){o=n.pushDismissLayer(u),document.addEventListener("keydown",d),s=setTimeout(()=>{document.addEventListener("pointerdown",a,!0),document.addEventListener("focusin",m,!0)},0)}function f(){o?.(),o=void 0,document.removeEventListener("keydown",d),clearTimeout(s),document.removeEventListener("pointerdown",a,!0),document.removeEventListener("focusin",m,!0)}(0,l.watch)(w,e=>{f(),e&&D()},{immediate:!0}),(0,l.onBeforeUnmount)(f)}exports.backdropPointerDown=n.backdropPointerDown;exports.useDismiss=L;

package/dist/utils/useDismiss.d.cts

@@ -1,12 +1,6 @@
 import { type Ref } from 'vue';
-/**
- * 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;
+import { type FocusOutsideEvent, type InteractOutsideEvent } from './dismissal.cjs';
+export { backdropPointerDown, type FocusOutsideEvent, type InteractOutsideEvent, } from './dismissal.cjs';
 /** @internal Options for useDismiss: whether it is active and the Escape / outside-interaction callbacks. */
 export interface UseDismissOptions {
     /** Whether dismiss listeners are active (usually the open state). */
@@ -17,22 +11,8 @@ export interface UseDismissOptions {
     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.
-     */
+    /** Called for either interaction type before the specific handler, on the same event object; `preventDefault()` here vetoes dismissal either way. */
     onInteractOutside?: (event: InteractOutsideEvent) => void;
 }
-/**
- * Layer dismissal behavior shared by Dialog-like floating content (Popover,
- * Tooltip, HoverCard, and future menu/select-style overlays). Consumers
- * pass refs of elements that count as "inside".
- *
- * This composable 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. Mirrors
- * `packages/react/src/utils/useDismiss.ts`. @internal
- */
-export declare function useDismiss({ enabled, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside }: UseDismissOptions, insideRefs: Array<Ref<Element | null>>): void;
+/** Dismissal behavior for Dialog-like content; reports Escape/outside interaction, and the caller decides strategy via `defaultPrevented`. @internal */
+export declare function useDismiss({ enabled, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, }: UseDismissOptions, insideRefs: Array<Ref<Element | null>>): void;

package/dist/utils/useDismiss.d.ts

@@ -1,12 +1,6 @@
 import { type Ref } from 'vue';
-/**
- * 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;
+import { type FocusOutsideEvent, type InteractOutsideEvent } from './dismissal.js';
+export { backdropPointerDown, type FocusOutsideEvent, type InteractOutsideEvent, } from './dismissal.js';
 /** @internal Options for useDismiss: whether it is active and the Escape / outside-interaction callbacks. */
 export interface UseDismissOptions {
     /** Whether dismiss listeners are active (usually the open state). */
@@ -17,22 +11,8 @@ export interface UseDismissOptions {
     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.
-     */
+    /** Called for either interaction type before the specific handler, on the same event object; `preventDefault()` here vetoes dismissal either way. */
     onInteractOutside?: (event: InteractOutsideEvent) => void;
 }
-/**
- * Layer dismissal behavior shared by Dialog-like floating content (Popover,
- * Tooltip, HoverCard, and future menu/select-style overlays). Consumers
- * pass refs of elements that count as "inside".
- *
- * This composable 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. Mirrors
- * `packages/react/src/utils/useDismiss.ts`. @internal
- */
-export declare function useDismiss({ enabled, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside }: UseDismissOptions, insideRefs: Array<Ref<Element | null>>): void;
+/** Dismissal behavior for Dialog-like content; reports Escape/outside interaction, and the caller decides strategy via `defaultPrevented`. @internal */
+export declare function useDismiss({ enabled, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, }: UseDismissOptions, insideRefs: Array<Ref<Element | null>>): void;

package/dist/utils/useDismiss.js

@@ -1 +1 @@
-import{onBeforeUnmount as e,watch as n}from"vue";function t({enabled:t,onEscapeKeyDown:o,onPointerDownOutside:s,onFocusOutside:i,onInteractOutside:u},c){if(typeof document>"u")return;let d;const r=e=>!c.some(n=>n.value?.contains(e)),m=e=>{"Escape"===e.key&&o?.(e)},a=e=>{const n=e.target;n&&r(n)&&(u?.(e),s?.(e))},v=e=>{const n=e.target;if(!n||n===document.body||!r(n))return;const t=new CustomEvent("focus-outside",{detail:e,cancelable:!0});u?.(t),i?.(t)};function f(){document.removeEventListener("keydown",m),clearTimeout(d),document.removeEventListener("pointerdown",a,!0),document.removeEventListener("focusin",v,!0)}n(t,e=>{f(),e&&(document.addEventListener("keydown",m),d=setTimeout(()=>{document.addEventListener("pointerdown",a,!0),document.addEventListener("focusin",v,!0)},0))},{immediate:!0}),e(f)}export{t as useDismiss};
+import{backdropPointerDown as e,focusOutsideEvent as n,focusOutsideTarget as t,handleEscapeKeyDown as o,pushDismissLayer as s}from"./dismissal.js";import{onBeforeUnmount as i,watch as r}from"vue";function a({enabled:e,onEscapeKeyDown:a,onPointerDownOutside:d,onFocusOutside:u,onInteractOutside:c},m){if(typeof document>"u")return;let v,f;const p={insideElements:()=>m.map(e=>e.value)},w=e=>!m.some(n=>n.value?.contains(e)),E=e=>{o(e,p,a)},l=e=>{const n=e.target;n&&w(n)&&(c?.(e),d?.(e))},D=e=>{const o=t(e);if(!o||!w(o))return;const s=n(e);c?.(s),u?.(s)};function L(){f?.(),f=void 0,document.removeEventListener("keydown",E),clearTimeout(v),document.removeEventListener("pointerdown",l,!0),document.removeEventListener("focusin",D,!0)}r(e,e=>{L(),e&&(f=s(p),document.addEventListener("keydown",E),v=setTimeout(()=>{document.addEventListener("pointerdown",l,!0),document.addEventListener("focusin",D,!0)},0))},{immediate:!0}),i(L)}export{e as backdropPointerDown,a as useDismiss};

package/dist/utils/useFocusFirstItemOnOpen.cjs

@@ -1 +1 @@
-let i=require("vue");function o(n,t,u){let e;(0,i.watch)(t,r=>{e!==void 0&&cancelAnimationFrame(e),!(!r||typeof document>"u")&&(e=requestAnimationFrame(()=>{(n.value?.querySelector(u)??n.value)?.focus()}))},{immediate:!0}),(0,i.onBeforeUnmount)(()=>{e!==void 0&&cancelAnimationFrame(e)})}exports.useFocusFirstItemOnOpen=o;
+const l=require("./dismissal.cjs");let i=require("vue");function f(r,o,u,c,s){let e;(0,i.watch)([o,s??(()=>0)],([a])=>{e!==void 0&&cancelAnimationFrame(e),!(!a||typeof document>"u")&&(e=requestAnimationFrame(()=>{const n=r.value;if(!n||n.contains(document.activeElement))return;const t=n.querySelectorAll(u),m=c?.()==="last"?t[t.length-1]:t[0];l.focusOnOpen(()=>(m??n).focus({preventScroll:!0}))}))},{immediate:!0}),(0,i.onBeforeUnmount)(()=>{e!==void 0&&cancelAnimationFrame(e)})}exports.useFocusFirstItemOnOpen=f;

package/dist/utils/useFocusFirstItemOnOpen.d.cts

@@ -1,13 +1,8 @@
 import { type Ref } from 'vue';
 /**
- * Moves focus into a panel one frame after it opens: to the first `selector`
- * match inside `contentRef`, or to the container itself when it has no items
- * yet. The frame is what lets the panel mount and position before focus lands.
- *
- * Shared verbatim by `DropdownMenuContent`, `MenubarContent` and
- * `SpeedDialContent`. `ContextMenuContent`, `SelectContent` and `Combobox`
- * deliberately keep their own versions — they skip when focus is already
- * inside, prefer the checked option, or move `aria-activedescendant` instead
- * of real focus. @internal
+ * Which end of the item list focus should land on when the panel opens.
+ * @internal
  */
-export declare function useFocusFirstItemOnOpen(contentRef: Ref<HTMLElement | null>, open: Readonly<Ref<boolean>>, selector: string): void;
+export type FocusOnOpenEnd = 'first' | 'last';
+/** Moves focus into a panel one frame after it opens (first item, or container if none); `end` picks last, `requestId` forces a re-fire. @internal */
+export declare function useFocusFirstItemOnOpen(contentRef: Ref<HTMLElement | null>, open: Readonly<Ref<boolean>>, selector: string, end?: () => FocusOnOpenEnd, requestId?: Readonly<Ref<number>>): void;

package/dist/utils/useFocusFirstItemOnOpen.d.ts

@@ -1,13 +1,8 @@
 import { type Ref } from 'vue';
 /**
- * Moves focus into a panel one frame after it opens: to the first `selector`
- * match inside `contentRef`, or to the container itself when it has no items
- * yet. The frame is what lets the panel mount and position before focus lands.
- *
- * Shared verbatim by `DropdownMenuContent`, `MenubarContent` and
- * `SpeedDialContent`. `ContextMenuContent`, `SelectContent` and `Combobox`
- * deliberately keep their own versions — they skip when focus is already
- * inside, prefer the checked option, or move `aria-activedescendant` instead
- * of real focus. @internal
+ * Which end of the item list focus should land on when the panel opens.
+ * @internal
  */
-export declare function useFocusFirstItemOnOpen(contentRef: Ref<HTMLElement | null>, open: Readonly<Ref<boolean>>, selector: string): void;
+export type FocusOnOpenEnd = 'first' | 'last';
+/** Moves focus into a panel one frame after it opens (first item, or container if none); `end` picks last, `requestId` forces a re-fire. @internal */
+export declare function useFocusFirstItemOnOpen(contentRef: Ref<HTMLElement | null>, open: Readonly<Ref<boolean>>, selector: string, end?: () => FocusOnOpenEnd, requestId?: Readonly<Ref<number>>): void;

package/dist/utils/useFocusFirstItemOnOpen.js

@@ -1 +1 @@
-import{onBeforeUnmount as e,watch as o}from"vue";function n(n,t,a){let i;o(t,e=>{void 0!==i&&cancelAnimationFrame(i),e&&!(typeof document>"u")&&(i=requestAnimationFrame(()=>{(n.value?.querySelector(a)??n.value)?.focus()}))},{immediate:!0}),e(()=>{void 0!==i&&cancelAnimationFrame(i)})}export{n as useFocusFirstItemOnOpen};
+import{focusOnOpen as e}from"./dismissal.js";import{onBeforeUnmount as n,watch as t}from"vue";function o(o,a,i,m,s){let c;t([a,s??(()=>0)],([n])=>{void 0!==c&&cancelAnimationFrame(c),n&&!(typeof document>"u")&&(c=requestAnimationFrame(()=>{const n=o.value;if(!n||n.contains(document.activeElement))return;const t=n.querySelectorAll(i),a="last"===m?.()?t[t.length-1]:t[0];e(()=>(a??n).focus({preventScroll:!0}))}))},{immediate:!0}),n(()=>{void 0!==c&&cancelAnimationFrame(c)})}export{o as useFocusFirstItemOnOpen};

package/dist/utils/useFocusTrap.cjs

@@ -1 +1 @@
-let s=require("vue");var y=["a[href]","button:not([disabled])",'input:not([disabled]):not([type="hidden"])',"select:not([disabled])","textarea:not([disabled])",'[tabindex]:not([tabindex="-1"])'].join(", ");function E(n){return Array.from(n.querySelectorAll(y)).filter(t=>t.offsetParent!==null||t===document.activeElement)}function f(n,t){if(!t)return!0;const u=new CustomEvent(n,{cancelable:!0,detail:null});return t(u),!u.defaultPrevented}function A(n,t,u={}){let o=null,c,i=!1;const d=e=>{if(e.key!=="Tab")return;const a=n.value;if(!a)return;const r=E(a);if(r.length===0){e.preventDefault();return}const b=r[0],p=r[r.length-1],l=document.activeElement;e.shiftKey&&(l===b||l===a)?(e.preventDefault(),p.focus()):!e.shiftKey&&l===p&&(e.preventDefault(),b.focus())};function v(){const e=n.value;e&&(i=!0,o=document.activeElement,c=requestAnimationFrame(()=>{if(!f("open-auto-focus",u.onOpenAutoFocus))return;const a=E(e)[0]??e;e.contains(document.activeElement)||(e.tabIndex=e.tabIndex>=0?e.tabIndex:-1,a.focus({preventScroll:!0}))}),e.addEventListener("keydown",d))}function m(){if(!i)return;i=!1;const e=n.value;if(c!==void 0&&cancelAnimationFrame(c),e?.removeEventListener("keydown",d),!f("close-auto-focus",u.onCloseAutoFocus)){o=null;return}o&&o!==document.body&&document.contains(o)&&o.focus({preventScroll:!0}),o=null}(0,s.watch)(t,e=>{e?v():m()},{flush:"post"}),(0,s.onMounted)(()=>{t.value&&v()}),(0,s.onBeforeUnmount)(m)}exports.autoFocusEvent=f;exports.useFocusTrap=A;
+const A=require("./tabbable.cjs"),y=require("./dismissal.cjs"),b=require("./focus-targets.cjs");let l=require("vue");function E(n){return Array.from(n.querySelectorAll(A.TABBABLE_SELECTOR)).filter(u=>u.offsetParent!==null||u===document.activeElement)}function p(n,u,t={}){let o=null,a,c=!1;const f=e=>{if(e.key!=="Tab")return;const i=n.value;if(!i)return;const r=E(i);if(r.length===0){e.preventDefault();return}const d=r[0],F=r[r.length-1],s=document.activeElement;e.shiftKey&&(s===d||s===i)?(e.preventDefault(),F.focus()):!e.shiftKey&&s===F&&(e.preventDefault(),d.focus())};function v(){const e=n.value;e&&(c=!0,o=document.activeElement,a=requestAnimationFrame(()=>{e.tabIndex=e.tabIndex>=0?e.tabIndex:-1,y.focusOnOpen(()=>b.applyOpenAutoFocus(e,t.initialFocus,t.family??"Popover",t.onOpenAutoFocus))}),e.addEventListener("keydown",f))}function m(){if(!c)return;c=!1;const e=n.value;a!==void 0&&cancelAnimationFrame(a),e?.removeEventListener("keydown",f),b.returnFocus(t.finalFocus,t.family??"Popover",o,t.onCloseAutoFocus),o=null}(0,l.watch)(u,e=>{e?v():m()},{flush:"post"}),(0,l.onMounted)(()=>{u.value&&v()}),(0,l.onBeforeUnmount)(m)}exports.autoFocusEvent=y.autoFocusEvent;exports.useFocusTrap=p;

package/dist/utils/useFocusTrap.d.cts

@@ -1,28 +1,19 @@
 import { type Ref } from 'vue';
-/** 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.
- * Mirrors `autoFocusEvent` in `packages/react/src/utils/useFocusTrap.ts`. @internal
- */
-export declare function autoFocusEvent(type: 'open-auto-focus' | 'close-auto-focus', handler?: (event: AutoFocusEvent) => void): boolean;
-/** @internal Consumer overrides for the two focus moves the trap makes on the overlay's behalf. */
+import { type AutoFocusEvent } from './dismissal.cjs';
+import { type FocusTargetFamily } from './focus-targets.cjs';
+export { autoFocusEvent, type AutoFocusEvent } from './dismissal.cjs';
+/** @internal Consumer overrides for the two auto-focus moves the trap makes. */
 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;
+    /** CSS selector for the element inside the container that takes initial focus, ahead of the first tabbable one. */
+    initialFocus?: string | undefined;
+    /** CSS selector, resolved against the document, for the element focus returns to instead of the opener. */
+    finalFocus?: string | undefined;
+    /** Which overlay family the trap serves, for the console warning a missed selector prints. */
+    family?: FocusTargetFamily | undefined;
 }
-/**
- * Traps Tab focus inside `containerRef` while `enabled`. Focuses the first
- * tabbable element (or the container) once mounted/positioned, and restores
- * focus to the previously-focused element when disabled/unmounted — 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). Mirrors
- * `packages/react/src/utils/useFocusTrap.ts`. @internal
- */
+/** Traps Tab inside `containerRef` while enabled, focusing the first tabbable and restoring focus on disable/unmount. @internal */
 export declare function useFocusTrap(containerRef: Ref<HTMLElement | null>, enabled: Ref<boolean>, options?: FocusTrapOptions): void;

package/dist/utils/useFocusTrap.d.ts

@@ -1,28 +1,19 @@
 import { type Ref } from 'vue';
-/** 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.
- * Mirrors `autoFocusEvent` in `packages/react/src/utils/useFocusTrap.ts`. @internal
- */
-export declare function autoFocusEvent(type: 'open-auto-focus' | 'close-auto-focus', handler?: (event: AutoFocusEvent) => void): boolean;
-/** @internal Consumer overrides for the two focus moves the trap makes on the overlay's behalf. */
+import { type AutoFocusEvent } from './dismissal.js';
+import { type FocusTargetFamily } from './focus-targets.js';
+export { autoFocusEvent, type AutoFocusEvent } from './dismissal.js';
+/** @internal Consumer overrides for the two auto-focus moves the trap makes. */
 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;
+    /** CSS selector for the element inside the container that takes initial focus, ahead of the first tabbable one. */
+    initialFocus?: string | undefined;
+    /** CSS selector, resolved against the document, for the element focus returns to instead of the opener. */
+    finalFocus?: string | undefined;
+    /** Which overlay family the trap serves, for the console warning a missed selector prints. */
+    family?: FocusTargetFamily | undefined;
 }
-/**
- * Traps Tab focus inside `containerRef` while `enabled`. Focuses the first
- * tabbable element (or the container) once mounted/positioned, and restores
- * focus to the previously-focused element when disabled/unmounted — 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). Mirrors
- * `packages/react/src/utils/useFocusTrap.ts`. @internal
- */
+/** Traps Tab inside `containerRef` while enabled, focusing the first tabbable and restoring focus on disable/unmount. @internal */
 export declare function useFocusTrap(containerRef: Ref<HTMLElement | null>, enabled: Ref<boolean>, options?: FocusTrapOptions): void;

package/dist/utils/useFocusTrap.js

@@ -1 +1 @@
-import{onBeforeUnmount as e,onMounted as t,watch as n}from"vue";var o=["a[href]","button:not([disabled])",'input:not([disabled]):not([type="hidden"])',"select:not([disabled])","textarea:not([disabled])",'[tabindex]:not([tabindex="-1"])'].join(", ");function u(e){return Array.from(e.querySelectorAll(o)).filter(e=>null!==e.offsetParent||e===document.activeElement)}function a(e,t){if(!t)return!0;const n=new CustomEvent(e,{cancelable:!0,detail:null});return t(n),!n.defaultPrevented}function c(o,c,l={}){let r,s=null,i=!1;const d=e=>{if("Tab"!==e.key)return;const t=o.value;if(!t)return;const n=u(t);if(0===n.length)return void e.preventDefault();const a=n[0],c=n[n.length-1],l=document.activeElement;!e.shiftKey||l!==a&&l!==t?!e.shiftKey&&l===c&&(e.preventDefault(),a.focus()):(e.preventDefault(),c.focus())};function f(){const e=o.value;e&&(i=!0,s=document.activeElement,r=requestAnimationFrame(()=>{if(!a("open-auto-focus",l.onOpenAutoFocus))return;const t=u(e)[0]??e;e.contains(document.activeElement)||(e.tabIndex=e.tabIndex>=0?e.tabIndex:-1,t.focus({preventScroll:!0}))}),e.addEventListener("keydown",d))}function v(){if(!i)return;i=!1;const e=o.value;void 0!==r&&cancelAnimationFrame(r),e?.removeEventListener("keydown",d),a("close-auto-focus",l.onCloseAutoFocus)?(s&&s!==document.body&&document.contains(s)&&s.focus({preventScroll:!0}),s=null):s=null}n(c,e=>{e?f():v()},{flush:"post"}),t(()=>{c.value&&f()}),e(v)}export{a as autoFocusEvent,c as useFocusTrap};
+import{TABBABLE_SELECTOR as e}from"./tabbable.js";import{autoFocusEvent as t,focusOnOpen as n}from"./dismissal.js";import{applyOpenAutoFocus as o,returnFocus as u}from"./focus-targets.js";import{onBeforeUnmount as s,onMounted as a,watch as r}from"vue";function i(t,i,c={}){let l,f=null,m=!1;const v=n=>{if("Tab"!==n.key)return;const o=t.value;if(!o)return;const u=function(t){return Array.from(t.querySelectorAll(e)).filter(e=>null!==e.offsetParent||e===document.activeElement)}(o);if(0===u.length)return void n.preventDefault();const s=u[0],a=u[u.length-1],r=document.activeElement;!n.shiftKey||r!==s&&r!==o?!n.shiftKey&&r===a&&(n.preventDefault(),s.focus()):(n.preventDefault(),a.focus())};function p(){const e=t.value;e&&(m=!0,f=document.activeElement,l=requestAnimationFrame(()=>{e.tabIndex=e.tabIndex>=0?e.tabIndex:-1,n(()=>o(e,c.initialFocus,c.family??"Popover",c.onOpenAutoFocus))}),e.addEventListener("keydown",v))}function d(){if(!m)return;m=!1;const e=t.value;void 0!==l&&cancelAnimationFrame(l),e?.removeEventListener("keydown",v),u(c.finalFocus,c.family??"Popover",f,c.onCloseAutoFocus),f=null}r(i,e=>{e?p():d()},{flush:"post"}),a(()=>{i.value&&p()}),s(d)}export{t as autoFocusEvent,i as useFocusTrap};

package/dist/utils/useFormReset.cjs

@@ -1 +1 @@
-let r=require("vue");function u(n,s){let e=null;const t=()=>s();(0,r.watch)(n,o=>{e?.removeEventListener("reset",t),e=o?.form??null,e?.addEventListener("reset",t)},{immediate:!0,flush:"post"}),(0,r.onBeforeUnmount)(()=>e?.removeEventListener("reset",t))}exports.useFormReset=u;
+let n=require("vue");function u(e){return e?e.form??e.closest("form"):null}function m(e,o){let t=null;const r=()=>o();(0,n.watch)(e,s=>{t?.removeEventListener("reset",r),t=u(s),t?.addEventListener("reset",r)},{immediate:!0,flush:"post"}),(0,n.onBeforeUnmount)(()=>t?.removeEventListener("reset",r))}exports.useFormReset=m;

package/dist/utils/useFormReset.d.cts

@@ -1,19 +1,2 @@
-/**
- * @internal Runs `restore` whenever the `<form>` owning `control` is reset.
- *
- * A native input resets itself, but a value Vue owns does not: the component
- * has to put its declared default back by hand. `control` is whatever element
- * actually carries the value into the form — the wrapped native input, or the
- * first hidden one — which is also how the form is found, since
- * `HTMLInputElement.form` follows a `form=""` attribute as well as an
- * enclosing `<form>`. It is read through a getter because that element only
- * exists after mount, and can be replaced (or removed with `name`) later.
- *
- * `restore` runs from the `reset` event, i.e. *before* the browser resets the
- * form's native controls. Components restoring a value Vue re-renders from
- * (a hidden input bound with `:value.attr`, whose reset default is the
- * attribute Vue keeps up to date) need nothing else; one writing into a native
- * input's `value` property has to write it again on `nextTick`, after the
- * browser's own reset has run.
- */
-export declare function useFormReset(control: () => HTMLInputElement | null | undefined, restore: () => void): void;
+/** @internal Runs `restore` on form reset, before the browser resets native controls. */
+export declare function useFormReset(control: () => HTMLElement | null | undefined, restore: () => void): void;

package/dist/utils/useFormReset.d.ts

@@ -1,19 +1,2 @@
-/**
- * @internal Runs `restore` whenever the `<form>` owning `control` is reset.
- *
- * A native input resets itself, but a value Vue owns does not: the component
- * has to put its declared default back by hand. `control` is whatever element
- * actually carries the value into the form — the wrapped native input, or the
- * first hidden one — which is also how the form is found, since
- * `HTMLInputElement.form` follows a `form=""` attribute as well as an
- * enclosing `<form>`. It is read through a getter because that element only
- * exists after mount, and can be replaced (or removed with `name`) later.
- *
- * `restore` runs from the `reset` event, i.e. *before* the browser resets the
- * form's native controls. Components restoring a value Vue re-renders from
- * (a hidden input bound with `:value.attr`, whose reset default is the
- * attribute Vue keeps up to date) need nothing else; one writing into a native
- * input's `value` property has to write it again on `nextTick`, after the
- * browser's own reset has run.
- */
-export declare function useFormReset(control: () => HTMLInputElement | null | undefined, restore: () => void): void;
+/** @internal Runs `restore` on form reset, before the browser resets native controls. */
+export declare function useFormReset(control: () => HTMLElement | null | undefined, restore: () => void): void;

package/dist/utils/useFormReset.js

@@ -1 +1 @@
-import{onBeforeUnmount as e,watch as t}from"vue";function n(n,r){let s=null;const o=()=>r();t(n,e=>{s?.removeEventListener("reset",o),s=e?.form??null,s?.addEventListener("reset",o)},{immediate:!0,flush:"post"}),e(()=>s?.removeEventListener("reset",o))}export{n as useFormReset};
+import{onBeforeUnmount as e,watch as t}from"vue";function n(n,r){let o=null;const s=()=>r();t(n,e=>{o?.removeEventListener("reset",s),o=function(e){return e?e.form??e.closest("form"):null}(e),o?.addEventListener("reset",s)},{immediate:!0,flush:"post"}),e(()=>o?.removeEventListener("reset",s))}export{n as useFormReset};

package/dist/utils/useMenuItem.cjs

@@ -1 +1 @@
-let i=require("vue");function o({disabled:t,onSelect:u,onSelected:r,contentRef:a}){function n(){if(t.value)return;const e=new CustomEvent("skdx-menu-item-select",{cancelable:!0});u?.(e),e.defaultPrevented||r()}return{itemAttrs:(0,i.computed)(()=>({"data-disabled":t.value?"":void 0,"aria-disabled":t.value||void 0,tabindex:t.value?void 0:-1})),onItemClick(){n()},onItemKeydown(e){[" ","Enter"].includes(e.key)&&(e.preventDefault(),n())},onItemPointerenter(e){t.value||e.currentTarget?.focus()},onItemPointerleave(e){e.currentTarget===document.activeElement&&a.value?.focus()}}}exports.useMenuItem=o;
+let c=require("vue");function o({disabled:t,textValue:u,onSelect:a,onSelected:l,closeOnSelect:r,contentRef:i}){function n(){if(t.value)return;const e=new CustomEvent("skdx-menu-item-select",{cancelable:!0});a?.(e),!e.defaultPrevented&&r?.value!==!1&&l()}return{itemAttrs:(0,c.computed)(()=>({"data-disabled":t.value?"":void 0,"data-text-value":u?.value,"aria-disabled":t.value||void 0,tabindex:-1})),onItemClick(){n()},onItemKeydown(e){[" ","Enter"].includes(e.key)&&(e.preventDefault(),n())},onItemPointerenter(e){t.value||e.currentTarget?.focus()},onItemPointerleave(e){e.currentTarget===document.activeElement&&i.value?.focus()}}}exports.useMenuItem=o;

package/dist/utils/useMenuItem.d.cts

@@ -2,10 +2,17 @@ import { type ComputedRef, type Ref } from 'vue';
 /** @internal Options for useMenuItem: disabled state, select callbacks, and the container to refocus on pointer-leave. */
 export interface UseMenuItemOptions {
     disabled: Ref<boolean | undefined>;
+    /** Typeahead override, reflected to `data-text-value`. Falls back to the item's rendered text. */
+    textValue?: Ref<string | undefined>;
     /** 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;
+    /**
+     * Whether an un-prevented select runs {@link UseMenuItemOptions.onSelected} — in practice, whether it closes the menu.
+     * @default undefined — treated as true.
+     */
+    closeOnSelect?: Ref<boolean | undefined>;
     /** Where focus returns to on pointer-leave, so keyboard nav resumes at the container. */
     contentRef: Ref<HTMLElement | null>;
 }
@@ -13,19 +20,14 @@ export interface UseMenuItemOptions {
 export interface MenuItemBindings {
     itemAttrs: ComputedRef<{
         'data-disabled': string | undefined;
+        'data-text-value': string | undefined;
         'aria-disabled': true | undefined;
-        tabindex: number | undefined;
+        tabindex: number;
     }>;
-    onItemClick(): void;
-    onItemKeydown(event: KeyboardEvent): void;
-    onItemPointerenter(event: PointerEvent): void;
-    onItemPointerleave(event: PointerEvent): void;
+    onItemClick: () => void;
+    onItemKeydown: (event: KeyboardEvent) => void;
+    onItemPointerenter: (event: PointerEvent) => void;
+    onItemPointerleave: (event: PointerEvent) => void;
 }
-/**
- * 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. Mirrors `packages/react/src/utils/useMenuItem.ts`.
- * @internal
- */
-export declare function useMenuItem({ disabled, onSelect, onSelected, contentRef, }: UseMenuItemOptions): MenuItemBindings;
+/** Shared interaction wiring for menuitem families: identical click/keyboard/hover behavior across all. @internal */
+export declare function useMenuItem({ disabled, textValue, onSelect, onSelected, closeOnSelect, contentRef, }: UseMenuItemOptions): MenuItemBindings;

package/dist/utils/useMenuItem.d.ts

@@ -2,10 +2,17 @@ import { type ComputedRef, type Ref } from 'vue';
 /** @internal Options for useMenuItem: disabled state, select callbacks, and the container to refocus on pointer-leave. */
 export interface UseMenuItemOptions {
     disabled: Ref<boolean | undefined>;
+    /** Typeahead override, reflected to `data-text-value`. Falls back to the item's rendered text. */
+    textValue?: Ref<string | undefined>;
     /** 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;
+    /**
+     * Whether an un-prevented select runs {@link UseMenuItemOptions.onSelected} — in practice, whether it closes the menu.
+     * @default undefined — treated as true.
+     */
+    closeOnSelect?: Ref<boolean | undefined>;
     /** Where focus returns to on pointer-leave, so keyboard nav resumes at the container. */
     contentRef: Ref<HTMLElement | null>;
 }
@@ -13,19 +20,14 @@ export interface UseMenuItemOptions {
 export interface MenuItemBindings {
     itemAttrs: ComputedRef<{
         'data-disabled': string | undefined;
+        'data-text-value': string | undefined;
         'aria-disabled': true | undefined;
-        tabindex: number | undefined;
+        tabindex: number;
     }>;
-    onItemClick(): void;
-    onItemKeydown(event: KeyboardEvent): void;
-    onItemPointerenter(event: PointerEvent): void;
-    onItemPointerleave(event: PointerEvent): void;
+    onItemClick: () => void;
+    onItemKeydown: (event: KeyboardEvent) => void;
+    onItemPointerenter: (event: PointerEvent) => void;
+    onItemPointerleave: (event: PointerEvent) => void;
 }
-/**
- * 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. Mirrors `packages/react/src/utils/useMenuItem.ts`.
- * @internal
- */
-export declare function useMenuItem({ disabled, onSelect, onSelected, contentRef, }: UseMenuItemOptions): MenuItemBindings;
+/** Shared interaction wiring for menuitem families: identical click/keyboard/hover behavior across all. @internal */
+export declare function useMenuItem({ disabled, textValue, onSelect, onSelected, closeOnSelect, contentRef, }: UseMenuItemOptions): MenuItemBindings;

package/dist/utils/useMenuItem.js

@@ -1 +1 @@
-import{computed as e}from"vue";function t({disabled:t,onSelect:n,onSelected:a,contentRef:o}){function u(){if(t.value)return;const e=new CustomEvent("skdx-menu-item-select",{cancelable:!0});n?.(e),e.defaultPrevented||a()}return{itemAttrs:e(()=>({"data-disabled":t.value?"":void 0,"aria-disabled":t.value||void 0,tabindex:t.value?void 0:-1})),onItemClick(){u()},onItemKeydown(e){[" ","Enter"].includes(e.key)&&(e.preventDefault(),u())},onItemPointerenter(e){t.value||e.currentTarget?.focus()},onItemPointerleave(e){e.currentTarget===document.activeElement&&o.value?.focus()}}}export{t as useMenuItem};
+import{computed as e}from"vue";function t({disabled:t,textValue:n,onSelect:a,onSelected:u,closeOnSelect:l,contentRef:o}){function r(){if(t.value)return;const e=new CustomEvent("skdx-menu-item-select",{cancelable:!0});a?.(e),!e.defaultPrevented&&!1!==l?.value&&u()}return{itemAttrs:e(()=>({"data-disabled":t.value?"":void 0,"data-text-value":n?.value,"aria-disabled":t.value||void 0,tabindex:-1})),onItemClick(){r()},onItemKeydown(e){[" ","Enter"].includes(e.key)&&(e.preventDefault(),r())},onItemPointerenter(e){t.value||e.currentTarget?.focus()},onItemPointerleave(e){e.currentTarget===document.activeElement&&o.value?.focus()}}}export{t as useMenuItem};