@progress/kendo-react-inputs 13.3.0 → 13.4.0-develop.2

package/textbox/Textbox.mjs

@@ -6,105 +6,109 @@
  *-------------------------------------------------------------------------------------------
  */
 import * as e from "react";
-import o from "prop-types";
-import { useUnstyled as w, useCustomComponent as g, useAsyncFocusBlur as H, classNames as h, uTextBox as C } from "@progress/kendo-react-common";
-const B = e.forwardRef((t, F) => {
-  const l = e.useRef(null), s = e.useRef(null), r = e.useRef(void 0), i = w(), a = i && i.uTextBox, b = e.useCallback(() => {
+import a from "prop-types";
+import { useUnstyled as j, useCustomComponent as x, useAsyncFocusBlur as H, classNames as g, kendoThemeMaps as h, uTextBox as w } from "@progress/kendo-react-common";
+const C = e.forwardRef((t, k) => {
+  const o = e.useRef(null), i = e.useRef(null), s = e.useRef(void 0), c = j(), y = c && c.uTextBox, B = e.useCallback(() => {
     var n;
-    return r.current !== void 0 ? r.current : (n = l.current) == null ? void 0 : n.value;
+    return s.current !== void 0 ? s.current : (n = o.current) == null ? void 0 : n.value;
   }, []);
-  e.useImperativeHandle(s, () => ({
+  e.useImperativeHandle(i, () => ({
     get element() {
-      return l.current;
+      return o.current;
     },
     get name() {
-      return l.current && l.current.name;
+      return o.current && o.current.name;
     },
     get value() {
-      return b();
+      return B();
     }
-  })), e.useImperativeHandle(F, () => s.current);
+  })), e.useImperativeHandle(k, () => i.current);
   const {
-    size: c = u.size,
+    size: l = u.size,
     fillMode: d = u.fillMode,
-    rounded: f = u.rounded,
-    autoFocus: y = u.autoFocus,
+    rounded: r = u.rounded,
+    autoFocus: F = u.autoFocus,
     inputAttributes: _,
-    className: m,
-    dir: E,
-    style: R,
-    prefix: N = u.prefix,
-    suffix: T = u.suffix,
+    className: f,
+    dir: b,
+    style: M,
+    prefix: p = u.prefix,
+    suffix: S = u.suffix,
     valid: D,
-    onFocus: p,
-    onBlur: q,
+    onFocus: z,
+    onBlur: E,
     // Destruct to avoid warning when used inside a form field
     modified: G,
     touched: K,
     visited: U,
-    ...M
-  } = t, [z] = g(N), [O] = g(T), [v, x] = e.useState(!1), S = (n) => {
-    x(!0);
-  }, A = (n) => {
-    x(!1);
-  }, I = e.useCallback(
+    validationMessage: J,
+    autoSize: L,
+    textareaStyle: Q,
+    ...R
+  } = t, [T] = x(p), [N] = x(S), [m, v] = e.useState(!1), q = (n) => {
+    v(!0);
+  }, O = (n) => {
+    v(!1);
+  }, A = e.useCallback(
     (n) => {
-      r.current = n.target.value, t.onChange && t.onChange.call(void 0, {
+      s.current = n.target.value, t.onChange && t.onChange.call(void 0, {
         syntheticEvent: n,
         nativeEvent: n.nativeEvent,
         value: n.target.value,
-        target: s.current
-      }), r.current = void 0;
+        target: i.current
+      }), s.current = void 0;
     },
     [t.onChange]
-  ), { onFocus: P, onBlur: j } = H({
-    onFocus: S,
-    onBlur: A,
-    onSyncFocus: p,
-    onSyncBlur: q
-  }), k = e.useMemo(
-    () => h(
-      C.wrapper({
-        c: a,
-        rounded: f,
-        fillMode: d,
-        size: c,
-        focused: v,
-        required: t.required,
-        disabled: t.disabled,
-        invalid: t.valid === !1
-      }),
-      m
+  ), { onFocus: I, onBlur: P } = H({
+    onFocus: q,
+    onBlur: O,
+    onSyncFocus: z,
+    onSyncBlur: E
+  }), $ = e.useMemo(
+    () => g(
+      "k-input",
+      "k-textbox",
+      {
+        [`k-input-${h.sizeMap[l] || l}`]: l,
+        [`k-input-${d}`]: d,
+        [`k-rounded-${h.roundedMap[r] || r}`]: r,
+        "k-focus": m,
+        "k-required": t.required,
+        "k-disabled": t.disabled,
+        "k-invalid": t.valid === !1
+      },
+      f
     ),
-    [m, d, v, t.disabled, t.required, t.valid, f, c, a]
+    [f, d, m, t.disabled, t.required, t.valid, r, l]
   );
-  return /* @__PURE__ */ e.createElement("span", { style: R, dir: E, className: k, onFocus: P, onBlur: j }, /* @__PURE__ */ e.createElement(z, null), /* @__PURE__ */ e.createElement(
+  return /* @__PURE__ */ e.createElement("span", { style: M, dir: b, className: $, onFocus: I, onBlur: P }, /* @__PURE__ */ e.createElement(T, null), /* @__PURE__ */ e.createElement(
     "input",
     {
-      ref: l,
-      className: h(C.inputInner({ c: a })),
-      autoFocus: y,
-      ...Object.assign({}, M, _),
+      ref: o,
+      className: g(w.inputInner({ c: y })),
+      autoFocus: F,
+      ...Object.assign({}, R, _),
       "aria-required": t.required,
-      onChange: I
+      onChange: A
     }
-  ), /* @__PURE__ */ e.createElement(O, null));
+  ), /* @__PURE__ */ e.createElement(N, null));
 }), u = {
   prefix: (t) => null,
   suffix: (t) => null,
-  size: "medium",
-  rounded: "medium",
-  fillMode: "solid",
+  size: void 0,
+  rounded: void 0,
+  fillMode: void 0,
   autoFocus: !1
 };
-B.propTypes = {
-  size: o.oneOf([null, "small", "medium", "large"]),
-  rounded: o.oneOf([null, "small", "medium", "large", "full"]),
-  fillMode: o.oneOf([null, "solid", "flat", "outline"]),
-  autoFocus: o.bool,
-  inputAttributes: o.object
+C.propTypes = {
+  size: a.oneOf(["small", "medium", "large"]),
+  rounded: a.oneOf(["small", "medium", "large", "full"]),
+  fillMode: a.oneOf(["solid", "flat", "outline"]),
+  autoFocus: a.bool,
+  inputAttributes: a.object
 };
-B.displayName = "KendoReactTextBoxComponent";
+C.displayName = "KendoReactTextBoxComponent";
 export {
-  B as TextBox
+  C as TextBox
 };

package/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2026 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+/**
+ * @hidden
+ */
+export declare function nullable(subRequirement: any): any;