asheeui 0.6.8 → 0.6.9

package/dist/components/input/Input.js

@@ -1,138 +1,143 @@
 "use client";
-import { jsx as n, jsxs as X } from "react/jsx-runtime";
-import Y, { forwardRef as q, useRef as ee, useImperativeHandle as se, useId as re, useCallback as R } from "react";
+import { jsx as c, jsxs as q } from "react/jsx-runtime";
+import ee, { forwardRef as se, useRef as re, useImperativeHandle as oe, useId as le, useCallback as K } from "react";
 import { useAsheeConfig as ae } from "../../libs/context.js";
-import { resolveCascade as c, resolveRadiusKey as le, resolveClassKey as oe } from "../../utils/resolve-token.js";
-import { FieldShell as te } from "../field/FieldShell.js";
+import { resolveCascade as u, resolveRadiusKey as te, resolveClassKey as ie } from "../../utils/resolve-token.js";
+import { FieldShell as de } from "../field/FieldShell.js";
 import { FALLBACK_FIELD_CONFIG as r } from "../field/field-config.js";
-import { INPUT_STATUS_BORDER_CLASS as ie, INPUT_SIZE_CLASS as de } from "./input-styles.js";
-import { useKeyboardField as ne } from "../keyboard/use-keyboard-field.js";
-import { resolveVariantClass as ce } from "../../shared/variant.js";
-import { RADIUS_CLASS as ue } from "../../shared/radius.js";
-import { cn as x } from "../../utils/cn.js";
-const me = q(
+import { INPUT_STATUS_BORDER_CLASS as ne, INPUT_SIZE_CLASS as ce } from "./input-styles.js";
+import { useKeyboardField as ue } from "../keyboard/use-keyboard-field.js";
+import { resolveVariantClass as pe } from "../../shared/variant.js";
+import { RADIUS_CLASS as me } from "../../shared/radius.js";
+import { cn as N } from "../../utils/cn.js";
+const fe = se(
   ({
-    size: N,
-    radius: p,
-    variant: _,
-    color: L,
-    status: w,
-    label: z,
-    labelAlign: E,
-    description: f,
-    message: v,
+    size: _,
+    radius: f,
+    variant: L,
+    color: w,
+    status: z,
+    label: E,
+    labelAlign: j,
+    description: v,
+    message: y,
     required: b,
-    isLoading: y,
-    id: F,
-    className: T,
-    disabled: U,
-    startContent: u,
-    endContent: a,
-    style: V,
-    onFocus: o,
+    isLoading: h,
+    id: B,
+    className: F,
+    disabled: T,
+    startContent: p,
+    endContent: o,
+    style: U,
+    onFocus: a,
     onBlur: t,
-    enableVirtualKeyboard: j = !0,
-    ...B
+    enableVirtualKeyboard: i = !0,
+    ...k
   }, D) => {
-    var K;
-    const i = ae(), e = (K = i.components) == null ? void 0 : K.input, m = ee(null);
-    se(D, () => m.current);
-    const k = re(), l = F ?? k, h = f ? `${l}-description` : void 0, I = v ? `${l}-message` : void 0, O = [h, I].filter(Boolean).join(" ") || void 0, { handleFocus: S, handleBlur: A } = ne(l, m, j), P = R(
-      (d) => {
-        S(d), o == null || o(d);
+    var x;
+    const d = ae(), e = (x = d.components) == null ? void 0 : x.input, m = re(null);
+    oe(D, () => m.current);
+    const O = le(), l = B ?? O, I = v ? `${l}-description` : void 0, S = y ? `${l}-message` : void 0, P = [I, S].filter(Boolean).join(" ") || void 0, $ = !!i, C = typeof i == "object" && i !== null ? i : void 0, { handleFocus: A, handleBlur: g } = ue(
+      l,
+      m,
+      $,
+      C
+    ), G = K(
+      (n) => {
+        A(n), a == null || a(n);
       },
-      [S, o]
-    ), $ = R(
-      (d) => {
-        A(), t == null || t(d);
+      [A, a]
+    ), H = K(
+      (n) => {
+        g(), t == null || t(n);
       },
-      [A, t]
-    ), C = c(
-      N,
+      [g, t]
+    ), V = u(
+      _,
       e == null ? void 0 : e.size,
       void 0,
       r.size
-    ), g = c(
-      _,
+    ), R = u(
+      L,
       e == null ? void 0 : e.variant,
-      i.defaultVariant,
+      d.defaultVariant,
       r.variant
-    ), G = c(
-      L,
+    ), Z = u(
+      w,
       e == null ? void 0 : e.color,
-      i.defaultColor,
+      d.defaultColor,
       r.color
-    ), H = le(
-      typeof p == "string" ? p : void 0,
+    ), J = te(
+      typeof f == "string" ? f : void 0,
       typeof (e == null ? void 0 : e.radius) == "string" ? e.radius : void 0,
-      i.defaultRadius,
+      d.defaultRadius,
       r.radius
-    ), s = w ?? r.status, Z = s === "error" ? "danger" : s === "success" ? "success" : s === "warning" ? "warning" : G, J = c(
-      E,
+    ), s = z ?? r.status, M = s === "error" ? "danger" : s === "success" ? "success" : s === "warning" ? "warning" : Z, Q = u(
+      j,
       e == null ? void 0 : e.labelAlign,
       void 0,
       r.labelAlign
-    ), M = ce(
-      g,
-      Z
-    ), Q = s !== "default" ? ie[s] : "", W = g === "underlined" ? "rounded-none" : oe(
-      H,
-      ue,
+    ), W = pe(
+      R,
+      M
+    ), X = s !== "default" ? ne[s] : "", Y = R === "underlined" ? "rounded-none" : ie(
+      J,
+      me,
       r.radius
     );
-    return /* @__PURE__ */ n(
-      te,
+    return /* @__PURE__ */ c(
+      de,
       {
         id: l,
-        label: z,
-        labelAlign: J,
-        description: f,
-        descriptionId: h,
-        message: v,
-        messageId: I,
+        label: E,
+        labelAlign: Q,
+        description: v,
+        descriptionId: I,
+        message: y,
+        messageId: S,
         status: s,
         required: b,
-        isLoading: y,
-        children: /* @__PURE__ */ X("div", { className: "relative flex items-center w-full", children: [
-          u && /* @__PURE__ */ n("span", { className: "absolute left-3 z-10 flex items-center pointer-events-none text-foreground/50", children: u }),
-          /* @__PURE__ */ n(
+        isLoading: h,
+        children: /* @__PURE__ */ q("div", { className: "relative flex items-center w-full", children: [
+          p && /* @__PURE__ */ c("span", { className: "absolute left-3 z-10 flex items-center pointer-events-none text-foreground/50", children: p }),
+          /* @__PURE__ */ c(
             "input",
             {
               ref: m,
               id: l,
-              disabled: U,
+              disabled: T,
               required: b,
               autoComplete: "off",
               "aria-invalid": s === "error",
-              "aria-describedby": O,
-              "aria-busy": y,
-              onFocus: P,
-              onBlur: $,
-              className: x(
+              "aria-describedby": P,
+              "aria-busy": h,
+              onFocus: G,
+              onBlur: H,
+              className: N(
                 "w-full text-foreground outline-none transition-colors shrink-0",
                 "focus-visible:ring-2 focus-visible:ring-offset-2",
                 "disabled:pointer-events-none disabled:opacity-50",
-                de[C],
-                M,
-                Q,
+                ce[V],
                 W,
-                u && "pl-11",
-                a && "pr-11",
-                T
+                X,
+                Y,
+                p && "pl-11",
+                o && "pr-11",
+                F
               ),
-              style: V,
-              ...B
+              style: U,
+              ...k
             }
           ),
-          a && /* @__PURE__ */ n(
+          o && /* @__PURE__ */ c(
             "span",
             {
-              className: x(
+              className: N(
                 "absolute right-3 z-10 flex items-center",
-                typeof a == "string" || Y.isValidElement(a) && a.type === "span" ? "pointer-events-none" : "",
+                typeof o == "string" || ee.isValidElement(o) && o.type === "span" ? "pointer-events-none" : "",
                 "text-foreground/50"
               ),
-              children: a
+              children: o
             }
           )
         ] })
@@ -140,7 +145,7 @@ const me = q(
     );
   }
 );
-me.displayName = "Input";
+fe.displayName = "Input";
 export {
-  me as Input
+  fe as Input
 };

package/dist/components/keyboard/KeyboardContext.d.ts

@@ -0,0 +1,130 @@
+import { Color, Radius, Variant } from '../../shared';
+import { KeyboardConfig, KeyboardSizeKey, LayoutName } from './keyboard-config';
+/**
+ * Type for keyboard input elements.
+ * The keyboard can attach to input and textarea elements.
+ */
+export type KeyboardElement = HTMLInputElement | HTMLTextAreaElement;
+/**
+ * Options for opening the keyboard.
+ */
+export interface KeyboardOpenOptions {
+    /**
+     * The layout to show when the keyboard opens.
+     * Overrides the provider's default layout.
+     */
+    layout?: LayoutName;
+    /**
+     * Size for this keyboard instance.
+     * Overrides the provider's size setting.
+     */
+    size?: KeyboardSizeKey;
+    /**
+     * Variant for this keyboard instance.
+     * Overrides the provider's variant setting.
+     */
+    variant?: Variant;
+    /**
+     * Color for this keyboard instance.
+     * Overrides the provider's color setting.
+     */
+    color?: Color;
+    /**
+     * Radius for this keyboard instance.
+     * Overrides the provider's radius setting.
+     */
+    radius?: Radius;
+    /**
+     * Portal setting for this keyboard instance.
+     * Overrides the provider's portal setting.
+     */
+    portal?: boolean;
+}
+/**
+ * Context type for the keyboard state and controls.
+ */
+export interface KeyboardContextType {
+    /**
+     * Whether the keyboard is currently open.
+     */
+    isOpen: boolean;
+    /**
+     * ID of the currently active input element.
+     */
+    activeInputId: string | null;
+    /**
+     * The currently active input element reference.
+     */
+    activeElement: KeyboardElement | null;
+    /**
+     * The merged keyboard configuration.
+     */
+    config: KeyboardConfig;
+    /**
+     * The resolved size for the keyboard.
+     */
+    resolvedSize: KeyboardSizeKey;
+    /**
+     * The resolved variant for the keyboard.
+     */
+    resolvedVariant: Variant;
+    /**
+     * The resolved color for the keyboard.
+     */
+    resolvedColor: Color;
+    /**
+     * The resolved radius for the keyboard.
+     */
+    resolvedRadius: Radius;
+    /**
+     * The resolved portal setting for the keyboard.
+     */
+    resolvedPortal: boolean;
+    /**
+     * Opens the keyboard for a specific input element.
+     * @param id - The ID of the input element.
+     * @param el - The input element reference.
+     * @param options - Optional configuration overrides.
+     */
+    openKeyboard: (id: string, el: KeyboardElement, options?: KeyboardOpenOptions) => void;
+    /**
+     * Requests to close the keyboard for a specific input.
+     * Uses a delay to prevent accidental closing on focus transitions.
+     * @param id - The ID of the input element.
+     */
+    requestClose: (id: string) => void;
+    /**
+     * Immediately closes the keyboard regardless of state.
+     */
+    forceClose: () => void;
+    /**
+     * Sets the current layout of the keyboard.
+     */
+    setLayout: (layout: LayoutName) => void;
+    /**
+     * The current layout of the keyboard.
+     */
+    currentLayout: LayoutName;
+    /**
+     * Whether the keyboard system is globally disabled.
+     */
+    isDisabled: boolean;
+}
+/**
+ * React context for the keyboard state.
+ */
+export declare const KeyboardContext: import('react').Context<KeyboardContextType | null>;
+/**
+ * Hook for accessing the keyboard context.
+ * Must be used within a KeyboardProvider.
+ *
+ * @returns The keyboard context value.
+ * @throws {Error} When used outside of a KeyboardProvider.
+ *
+ * @example
+ * ```tsx
+ * const { isOpen, openKeyboard, forceClose } = useKeyboard();
+ * ```
+ */
+export declare function useKeyboard(): KeyboardContextType;
+//# sourceMappingURL=KeyboardContext.d.ts.map

package/dist/components/keyboard/KeyboardContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyboardContext.d.ts","sourceRoot":"","sources":["../../../src/components/keyboard/KeyboardContext.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,UAAU,EACX,MAAM,mBAAmB,CAAC;AAE3B;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IAEpB;;;OAGG;IACH,IAAI,CAAC,EAAE,eAAe,CAAC;IAEvB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAE7B;;OAEG;IACH,aAAa,EAAE,eAAe,GAAG,IAAI,CAAC;IAEtC;;OAEG;IACH,MAAM,EAAE,cAAc,CAAC;IAEvB;;OAEG;IACH,YAAY,EAAE,eAAe,CAAC;IAE9B;;OAEG;IACH,eAAe,EAAE,OAAO,CAAC;IAEzB;;OAEG;IACH,aAAa,EAAE,KAAK,CAAC;IAErB;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,cAAc,EAAE,OAAO,CAAC;IAExB;;;;;OAKG;IACH,YAAY,EAAE,CACZ,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,eAAe,EACnB,OAAO,CAAC,EAAE,mBAAmB,KAC1B,IAAI,CAAC;IAEV;;;;OAIG;IACH,YAAY,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAEnC;;OAEG;IACH,UAAU,EAAE,MAAM,IAAI,CAAC;IAEvB;;OAEG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;IAExC;;OAEG;IACH,aAAa,EAAE,UAAU,CAAC;IAE1B;;OAEG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,qDAAkD,CAAC;AAI/E;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,wBAM1B"}

package/dist/components/keyboard/KeyboardContext.js

@@ -0,0 +1,13 @@
+"use client";
+import { createContext as t, useContext as o } from "react";
+const r = t(null);
+function u() {
+  const e = o(r);
+  if (!e)
+    throw new Error("useKeyboard must be used within a <KeyboardProvider>");
+  return e;
+}
+export {
+  r as KeyboardContext,
+  u as useKeyboard
+};

package/dist/components/keyboard/KeyboardProvider.d.ts

@@ -0,0 +1,78 @@
+import { ReactNode } from 'react';
+import { KeyboardConfig } from './keyboard-config';
+/**
+ * Props for the KeyboardProvider component.
+ */
+export interface KeyboardProviderProps extends KeyboardConfig {
+    /**
+     * Child components that will have access to the keyboard context.
+     */
+    children: ReactNode;
+    /**
+     * Extra CSS classes for the keyboard container.
+     */
+    className?: string;
+    /**
+     * Extra CSS classes for individual keys.
+     */
+    keyClassName?: string;
+    /**
+     * Whether the keyboard system is globally disabled.
+     * @default false
+     */
+    disabled?: boolean;
+}
+/**
+ * Provider component for the virtual keyboard system.
+ *
+ * KeyboardProvider wraps your application or a section of it to provide
+ * keyboard context. It manages the open/close state, active input tracking,
+ * and configuration resolution. Input components using useKeyboardField or
+ * the KeyboardContext will automatically trigger the keyboard on focus.
+ *
+ * The provider automatically renders the OnScreenKeyboard component at the
+ * bottom of the DOM tree via React Portal. This ensures the keyboard appears
+ * at the bottom of the screen regardless of where the input is in the DOM.
+ *
+ * @param props - KeyboardProvider configuration options.
+ * @param props.children - Child components.
+ * @param props.layouts - Available keyboard layouts.
+ * @param props.display - Display mappings for special keys.
+ * @param props.defaultLayout - Default layout name. Defaults to "default".
+ * @param props.size - Size scale for keyboard keys. Defaults to "md".
+ * @param props.autoShiftBack - Auto switch back from shift. Defaults to true.
+ * @param props.closeDelay - Close delay in milliseconds. Defaults to 120.
+ * @param props.variant - Visual variant for keys.
+ * @param props.color - Theme color for keys.
+ * @param props.radius - Corner rounding for keys.
+ * @param props.portal - Whether to render the keyboard in a portal. Defaults to true.
+ * @param props.disabled - Whether the keyboard system is disabled. Defaults to false.
+ * @param props.className - Extra CSS classes for the keyboard container.
+ * @param props.keyClassName - Extra CSS classes for individual keys.
+ *
+ * @example
+ * ```tsx
+ * import { KeyboardProvider, Input } from "asheeui";
+ *
+ * export function App() {
+ *   return (
+ *     <KeyboardProvider size="lg">
+ *       <Input label="Search" enableVirtualKeyboard />
+ *     </KeyboardProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Disable keyboard globally
+ * <KeyboardProvider disabled>
+ *   <Input label="Disabled field" />
+ * </KeyboardProvider>
+ * ```
+ *
+ * @see useKeyboard - Hook for accessing the keyboard context.
+ * @see useKeyboardField - Hook for connecting inputs to the keyboard.
+ */
+export declare function KeyboardProvider({ children, layouts, display, defaultLayout, size, autoShiftBack, closeDelay: closeDelayProp, variant, color, radius, portal: portalProp, disabled: disabledProp, className, keyClassName, }: KeyboardProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=KeyboardProvider.d.ts.map

package/dist/components/keyboard/KeyboardProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyboardProvider.d.ts","sourceRoot":"","sources":["../../../src/components/keyboard/KeyboardProvider.tsx"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,SAAS,EAA0C,MAAM,OAAO,CAAC;AAU/E,OAAO,EAGL,KAAK,cAAc,EAIpB,MAAM,mBAAmB,CAAC;AAK3B;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IAC3D;;OAEG;IACH,QAAQ,EAAE,SAAS,CAAC;IAEpB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,QAAQ,EACR,OAAO,EACP,OAAO,EACP,aAAa,EACb,IAAI,EACJ,aAAa,EACb,UAAU,EAAE,cAAoB,EAChC,OAAO,EACP,KAAK,EACL,MAAM,EACN,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,YAAoB,EAC9B,SAAS,EACT,YAAY,GACb,EAAE,qBAAqB,+BA6PvB"}

package/dist/components/keyboard/KeyboardProvider.js

@@ -0,0 +1,183 @@
+"use client";
+import { jsxs as ot, jsx as et } from "react/jsx-runtime";
+import { useState as f, useRef as at, useMemo as M, useCallback as y } from "react";
+import { useAsheeConfig as ut } from "../../libs/context.js";
+import { resolveCascade as o, resolveRadiusKey as ct } from "../../utils/resolve-token.js";
+import { KeyboardContext as nt } from "./KeyboardContext.js";
+import { FALLBACK_KEYBOARD_CONFIG as l, defaultKeyboardConfig as N } from "./keyboard-config.js";
+import { OnScreenKeyboard as it } from "./OnScreenKeyboard.js";
+function Dt({
+  children: U,
+  layouts: P,
+  display: V,
+  defaultLayout: Y,
+  size: w,
+  autoShiftBack: H,
+  closeDelay: J = 120,
+  variant: Q,
+  color: W,
+  radius: X,
+  portal: Z,
+  disabled: $ = !1,
+  className: b,
+  keyClassName: C
+}) {
+  var G;
+  const e = ut(), t = (G = e == null ? void 0 : e.components) == null ? void 0 : G.keyboard, a = o(
+    w,
+    t == null ? void 0 : t.size,
+    void 0,
+    l.size
+  ), u = o(
+    Q,
+    t == null ? void 0 : t.variant,
+    e.defaultVariant,
+    l.variant
+  ), c = o(
+    W,
+    t == null ? void 0 : t.color,
+    e.defaultColor,
+    l.color
+  ), n = ct(
+    X,
+    t == null ? void 0 : t.radius,
+    e.defaultRadius,
+    l.radius
+  ), i = o(
+    Z,
+    t == null ? void 0 : t.portal,
+    void 0,
+    l.portal
+  ), r = o(
+    $,
+    t == null ? void 0 : t.disabled,
+    void 0,
+    l.disabled
+  ), d = o(
+    Y,
+    t == null ? void 0 : t.defaultLayout,
+    void 0,
+    l.defaultLayout
+  ), m = o(
+    H,
+    t == null ? void 0 : t.autoShiftBack,
+    void 0,
+    l.autoShiftBack
+  ), E = o(
+    J,
+    t == null ? void 0 : t.closeDelay,
+    void 0,
+    l.closeDelay
+  ), [D, O] = f(!1), [j, S] = f(null), [z, A] = f(
+    null
+  ), [R, F] = f(
+    d
+  ), [v, B] = f(
+    {}
+  ), s = at(null), I = M(
+    () => ({
+      layouts: P ?? (t == null ? void 0 : t.layouts) ?? N.layouts,
+      display: V ?? (t == null ? void 0 : t.display) ?? N.display,
+      defaultLayout: d,
+      size: a,
+      autoShiftBack: m,
+      variant: u,
+      color: c,
+      radius: n,
+      portal: i,
+      disabled: r
+    }),
+    [
+      P,
+      t,
+      V,
+      d,
+      a,
+      m,
+      u,
+      c,
+      n,
+      i,
+      r
+    ]
+  ), _ = y(
+    (p, k, L) => {
+      if (r) return;
+      s.current && (clearTimeout(s.current), s.current = null), S(p), A(k), B(L || {});
+      const lt = (L == null ? void 0 : L.layout) ?? d;
+      F(lt), O(!0);
+    },
+    [r, d]
+  ), q = y(
+    (p) => {
+      r || (s.current && clearTimeout(s.current), s.current = setTimeout(() => {
+        S((k) => (k === p && (O(!1), A(null), B({})), k)), s.current = null;
+      }, E));
+    },
+    [r, E]
+  ), T = y(() => {
+    s.current && (clearTimeout(s.current), s.current = null), O(!1), A(null), S(null), B({});
+  }, []), x = y((p) => {
+    F(p);
+  }, []), K = M(
+    () => ({
+      isOpen: D,
+      activeInputId: j,
+      activeElement: z,
+      config: I,
+      resolvedSize: a,
+      resolvedVariant: u,
+      resolvedColor: c,
+      resolvedRadius: n,
+      resolvedPortal: i,
+      openKeyboard: _,
+      requestClose: q,
+      forceClose: T,
+      setLayout: x,
+      currentLayout: R,
+      isDisabled: r
+    }),
+    [
+      D,
+      j,
+      z,
+      I,
+      a,
+      u,
+      c,
+      n,
+      i,
+      _,
+      q,
+      T,
+      x,
+      R,
+      r
+    ]
+  ), h = v.size ?? a, g = v.variant ?? u, tt = v.color ?? c, st = v.radius ?? n, rt = v.portal ?? i;
+  return /* @__PURE__ */ ot(nt.Provider, { value: K, children: [
+    U,
+    /* @__PURE__ */ et(
+      it,
+      {
+        isOpen: D,
+        activeElement: z,
+        config: I,
+        currentLayout: R,
+        setLayout: x,
+        forceClose: T,
+        size: h,
+        variant: g,
+        color: tt,
+        radius: st,
+        portal: rt,
+        className: b,
+        keyClassName: C,
+        disabled: r
+      }
+    )
+  ] });
+}
+export {
+  Dt as KeyboardProvider
+};