@xola/ui-kit 3.0.8 → 3.4.1

package/build/components/Drawer.js

@@ -0,0 +1,126 @@
+import { jsx as e, jsxs as n } from "react/jsx-runtime";
+import { Transition as o, Dialog as s } from "@headlessui/react";
+import l from "clsx";
+import { forwardRef as v, Fragment as m } from "react";
+import { isIosBrowser as g } from "../helpers/browser.js";
+import { useViewportHeight as y } from "../hooks/useViewportHeight.js";
+import { CloseIcon as b } from "../icons/build/CloseIcon.js";
+import { Button as N } from "./Buttons/Button.js";
+const T = {
+  small: "w-72",
+  medium: "w-85",
+  large: "w-110",
+  xl: "w-200",
+  "2xl": "w-screen md:max-w-screen-md 2xl:max-w-screen-lg"
+  // This was the old size
+}, F = v(
+  ({
+    isOpen: i = !1,
+    title: f,
+    size: u = "medium",
+    content: x,
+    sideIndent: h = 0,
+    position: r = "right",
+    classNames: t = {},
+    onClose: a
+  }, w) => {
+    const d = y(), p = g();
+    return /* @__PURE__ */ e(o.Root, { show: i, as: m, children: /* @__PURE__ */ e(
+      s,
+      {
+        ref: w,
+        as: "div",
+        className: l("ui-drawer fixed inset-0 z-10 overflow-hidden", t.dialog),
+        open: i,
+        onClose: a,
+        children: /* @__PURE__ */ n(
+          "div",
+          {
+            className: l(
+              "flex",
+              p ? `h-[${d}px] max-h-[${d}px] w-full` : "h-screen w-full"
+            ),
+            children: [
+              /* @__PURE__ */ e(
+                o.Child,
+                {
+                  as: m,
+                  enter: "ease-in-out duration-500",
+                  enterFrom: "opacity-0",
+                  enterTo: "opacity-100",
+                  leave: "ease-in-out duration-500",
+                  leaveFrom: "opacity-100",
+                  leaveTo: "opacity-0",
+                  children: /* @__PURE__ */ e(
+                    s.Overlay,
+                    {
+                      className: l(
+                        "absolute inset-0 bg-black bg-opacity-80 transition-opacity",
+                        t.overlay
+                      )
+                    }
+                  )
+                }
+              ),
+              /* @__PURE__ */ e(
+                "div",
+                {
+                  style: {
+                    [r === "right" ? "right" : "left"]: `${h ?? 0}px`
+                  },
+                  className: l("fixed inset-y-0 flex max-w-full", t.dialogContent),
+                  children: /* @__PURE__ */ e(
+                    o.Child,
+                    {
+                      as: m,
+                      enter: "transform transition ease-in-out duration-500 sm:duration-700",
+                      enterFrom: r === "right" ? "translate-x-full" : "-translate-x-full",
+                      enterTo: "translate-x-0",
+                      leave: "transform transition ease-out-in duration-500 sm:duration-700",
+                      leaveFrom: "translate-x-0",
+                      leaveTo: r === "right" ? "translate-x-full" : "-translate-x-full",
+                      children: /* @__PURE__ */ n("div", { className: "flex", children: [
+                        r === "right" ? /* @__PURE__ */ e(c, { onClose: a }) : null,
+                        /* @__PURE__ */ n(
+                          "div",
+                          {
+                            className: l(
+                              "flex h-full w-full flex-col overflow-y-auto bg-white px-4 py-8 shadow-xl sm:px-6",
+                              T[u],
+                              t.children
+                            ),
+                            children: [
+                              /* @__PURE__ */ e("div", { className: "w-full", children: /* @__PURE__ */ e(s.Title, { children: f }) }),
+                              /* @__PURE__ */ e("div", { className: l("relative mt-3 flex-1", t.content), children: x })
+                            ]
+                          }
+                        ),
+                        r === "left" ? /* @__PURE__ */ e(c, { onClose: a }) : null
+                      ] })
+                    }
+                  )
+                }
+              )
+            ]
+          }
+        )
+      }
+    ) });
+  }
+);
+F.displayName = "Drawer";
+const c = ({ onClose: i }) => /* @__PURE__ */ e(
+  N,
+  {
+    size: "small",
+    variant: "link",
+    className: l(
+      "m-2.5 inline-flex !h-10 !w-10 items-center justify-center !rounded-full bg-white !px-1.5 !text-black"
+    ),
+    onClick: () => i(!1),
+    children: /* @__PURE__ */ e(b, { size: "medium" })
+  }
+);
+export {
+  F as Drawer
+};

package/build/components/Forms/BaseInput.d.ts

@@ -0,0 +1,20 @@
+import { default as React, ElementType } from 'react';
+declare const sizes: {
+    readonly small: "px-3 py-1.5 text-sm leading-sm";
+    readonly medium: "px-3 py-2.5 text-base leading-base";
+    readonly large: "px-5 py-3.5 text-md leading-md";
+};
+type BaseInputSize = keyof typeof sizes;
+export interface BaseInputProps {
+    [key: string]: any;
+    as?: ElementType;
+    size?: BaseInputSize;
+    isError?: boolean;
+    isRequired?: boolean;
+    value?: string | number;
+    prefix?: string;
+    suffix?: string;
+    className?: string;
+}
+export declare const BaseInput: React.ForwardRefExoticComponent<Omit<BaseInputProps & Record<string, any>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export {};

package/build/components/Forms/BaseInput.js

@@ -0,0 +1,41 @@
+import { jsxs as x, jsx as s } from "react/jsx-runtime";
+import y from "clsx";
+import { isString as i, isEmpty as l } from "lodash-es";
+import { forwardRef as u } from "react";
+import { Dot as h } from "../Dot/Dot.js";
+const k = {
+  small: "px-3 py-1.5 text-sm leading-sm",
+  medium: "px-3 py-2.5 text-base leading-base",
+  large: "px-5 py-3.5 text-md leading-md"
+}, w = u(
+  ({ as: t = "input", size: d = "medium", isError: n, isRequired: c, value: r, prefix: a, suffix: o, className: g, ...p }, m) => {
+    const b = () => {
+      if (!i(r)) return;
+      let e = r;
+      return a && (e = e.replace(new RegExp(`^${a}`), "")), o && (e = e.replace(new RegExp(`${o}$`), "")), e.replaceAll(/[^.\S]+/g, "").replace(/[\p{Sc}]/u, "");
+    }, f = i(r) ? l(b()) : l(r == null ? void 0 : r.toString());
+    return /* @__PURE__ */ x("div", { className: "relative flex w-full items-center", children: [
+      /* @__PURE__ */ s(
+        t,
+        {
+          ref: m,
+          className: y(
+            "w-full rounded text-gray-darker placeholder-gray-dark hover:placeholder-gray-darker disabled:text-gray",
+            "border border-transparent hover:border-black hover:bg-gray-lighter focus:text-black active:text-black disabled:bg-gray-lighter",
+            k[d],
+            t === "select" && "pr-8",
+            n ? "!focus:border-danger !border-danger focus:ring-0 focus:ring-danger" : "border-gray-light focus:border-primary focus:ring-0 focus:ring-primary",
+            g
+          ),
+          value: r,
+          ...p
+        }
+      ),
+      c && f && /* @__PURE__ */ s(h, { className: "absolute right-3", color: "danger" })
+    ] });
+  }
+);
+w.displayName = "BaseInput";
+export {
+  w as BaseInput
+};

package/build/components/Forms/Checkbox.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export interface CheckboxProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    label: React.ReactNode;
+    classNames?: {
+        checkbox?: string;
+        label?: string;
+    };
+    className?: string;
+}
+export declare const Checkbox: ({ label, classNames, className, ...rest }: CheckboxProps) => React.JSX.Element;

package/build/components/Forms/Checkbox.js

@@ -0,0 +1,34 @@
+import { jsxs as s, jsx as c } from "react/jsx-runtime";
+import e from "clsx";
+import { useId as d } from "../../hooks/useId.js";
+import n from "./Checkbox.module.css.js";
+const m = ({ label: r, classNames: o = {}, className: i, ...l }) => {
+  const t = d("checkbox");
+  return /* @__PURE__ */ s("div", { className: e("ui-checkbox", i, "flex items-center"), children: [
+    /* @__PURE__ */ c(
+      "input",
+      {
+        type: "checkbox",
+        className: e(
+          "ui-checkbox-input",
+          o.checkbox,
+          n.checkbox,
+          "h-4 w-4 rounded !border-primary text-white transition-colors disabled:border-none disabled:bg-gray-light disabled:text-gray-light"
+        ),
+        ...l,
+        id: t
+      }
+    ),
+    r ? /* @__PURE__ */ c(
+      "label",
+      {
+        htmlFor: t,
+        className: e("ui-checkbox-label", o.label, "ml-2 leading-none text-gray-darker"),
+        children: r
+      }
+    ) : null
+  ] });
+};
+export {
+  m as Checkbox
+};

package/build/components/Forms/Checkbox.module.css.js

@@ -0,0 +1,7 @@
+const c = "_checkbox_1gb8z_1", e = {
+  checkbox: c
+};
+export {
+  c as checkbox,
+  e as default
+};

package/build/components/Forms/ComboBox.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+import { Props as SelectProps } from 'react-select';
+export interface ComboBoxProps extends SelectProps {
+    isCreatable?: boolean;
+    isError?: boolean;
+    className?: string;
+}
+export declare const ComboBox: ({ isCreatable, isError, className, ...rest }: ComboBoxProps) => React.JSX.Element;

package/build/components/Forms/ComboBox.js

@@ -0,0 +1,41 @@
+import { jsx as o } from "react/jsx-runtime";
+import i from "clsx";
+import { useRef as c, useState as s, useEffect as m } from "react";
+import u, { components as f } from "react-select";
+import d from "react-select/creatable";
+import { Tooltip as b } from "../Tooltip.js";
+/* empty css             */
+const R = ({ isCreatable: e = !1, isError: t, className: l, ...n }) => /* @__PURE__ */ o(
+  e ? d : u,
+  {
+    className: i("ui-combo-box", t && "border-danger", l),
+    classNamePrefix: "ui-combo-box",
+    components: e ? {
+      IndicatorsContainer: () => null,
+      Menu: () => null,
+      MultiValueLabel: x
+    } : void 0,
+    ...n
+  }
+), { MultiValueLabel: p } = f, x = (e) => {
+  const t = c(null), [l, n] = s(!0);
+  return m(() => {
+    var r;
+    if ((r = t.current) != null && r.offsetParent) {
+      const a = t.current.offsetWidth > t.current.offsetParent.clientWidth;
+      n(!a);
+    }
+  }, [e.data.label]), /* @__PURE__ */ o(p, { ...e, children: /* @__PURE__ */ o(
+    b,
+    {
+      disabled: l,
+      maxWidth: "none",
+      content: /* @__PURE__ */ o("span", { children: e.data.label }),
+      className: "",
+      children: /* @__PURE__ */ o("span", { ref: t, children: e.data.label })
+    }
+  ) });
+};
+export {
+  R as ComboBox
+};

package/build/components/Forms/FormGroup.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export interface FormGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    className?: string;
+}
+export declare const FormGroup: ({ className, ...rest }: FormGroupProps) => React.JSX.Element;

package/build/components/Forms/FormGroup.js

@@ -0,0 +1,6 @@
+import { jsx as m } from "react/jsx-runtime";
+import p from "clsx";
+const i = ({ className: r, ...o }) => /* @__PURE__ */ m("div", { className: p("ui-form-group", r, "mb-4"), ...o });
+export {
+  i as FormGroup
+};

package/build/components/Forms/InlineValuePopover.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+export interface InlineValuePopoverProps {
+    text?: React.ReactNode;
+    isOpen?: boolean;
+    showArrow?: boolean;
+    autoSelectOnClick?: boolean;
+    children?: React.ReactNode;
+    error?: React.ReactNode | null;
+    classNames?: {
+        text?: string;
+        textField?: string;
+        children?: string;
+    };
+    onClick?: (e: React.MouseEvent) => void;
+    onClickOutside?: () => void;
+}
+export declare const InlineValuePopover: ({ text, isOpen, showArrow, autoSelectOnClick, children, error, classNames, onClick, onClickOutside, ...rest }: InlineValuePopoverProps) => React.JSX.Element;

package/build/components/Forms/InlineValuePopover.js

@@ -0,0 +1,47 @@
+import { jsxs as d, jsx as e } from "react/jsx-runtime";
+import i from "clsx";
+import { useRef as P } from "react";
+import { DownArrowIcon as g } from "../../icons/build/DownArrowIcon.js";
+import { Popover as l } from "../Popover/Popover.js";
+import { ValuePopoverText as j } from "./ValuePopoverText.js";
+const D = ({
+  text: f,
+  isOpen: x = !1,
+  showArrow: b = !0,
+  autoSelectOnClick: c = !1,
+  children: h,
+  error: p = null,
+  classNames: r,
+  onClick: o,
+  onClickOutside: v,
+  ...m
+}) => {
+  const t = P(null), w = (I) => {
+    setTimeout(() => {
+      var u;
+      const n = (u = t == null ? void 0 : t.current) == null ? void 0 : u.querySelector("select,textarea,input");
+      n && (n.focus(), c && n.select());
+    }, 0), o == null || o(I);
+  };
+  return /* @__PURE__ */ d(l, { visible: x, className: "", onClickOutside: v, ...m, children: [
+    /* @__PURE__ */ d(
+      "span",
+      {
+        className: i(
+          "cursor-pointer whitespace-nowrap",
+          p && "!border-danger !text-danger",
+          r == null ? void 0 : r.text
+        ),
+        onClick: w,
+        children: [
+          /* @__PURE__ */ e("span", { className: i("border-b border-b-black font-bold text-black", r == null ? void 0 : r.textField), children: /* @__PURE__ */ e(j, { value: f, error: p }) }),
+          b && /* @__PURE__ */ e(g, { size: "medium" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ e(l.Content, { children: /* @__PURE__ */ e("div", { ref: t, className: i("p-2", r == null ? void 0 : r.children), children: h }) })
+  ] });
+};
+export {
+  D as InlineValuePopover
+};

package/build/components/Forms/Input.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { BaseInputProps } from './BaseInput';
+export interface InputProps extends BaseInputProps, Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof BaseInputProps> {
+    type?: string;
+}
+export declare const Input: React.ForwardRefExoticComponent<Omit<InputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

package/build/components/Forms/Input.js

@@ -0,0 +1,9 @@
+import { jsx as i } from "react/jsx-runtime";
+import s from "clsx";
+import { forwardRef as a } from "react";
+import { BaseInput as e } from "./BaseInput.js";
+const n = a(({ className: t, type: r = "text", value: o, ...p }, m) => /* @__PURE__ */ i(e, { ref: m, as: "input", className: s("ui-input", t), type: r, value: o, ...p }));
+n.displayName = "Input";
+export {
+  n as Input
+};

package/build/components/Forms/Label.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export interface LabelProps extends React.LabelHTMLAttributes<HTMLLabelElement> {
+    isDisabled?: boolean;
+    isError?: boolean;
+    className?: string;
+}
+export declare const Label: ({ isDisabled, isError, className, ...rest }: LabelProps) => React.JSX.Element;

package/build/components/Forms/Label.js

@@ -0,0 +1,17 @@
+import { jsx as o } from "react/jsx-runtime";
+import r from "clsx";
+const m = ({ isDisabled: t = !1, isError: e = !1, className: l, ...a }) => /* @__PURE__ */ o(
+  "label",
+  {
+    className: r(
+      "ui-label",
+      l,
+      "mb-1 block text-sm font-bold",
+      e ? "text-danger" : t ? "text-gray" : "text-black"
+    ),
+    ...a
+  }
+);
+export {
+  m as Label
+};

package/build/components/Forms/RangeSlider.d.ts

@@ -0,0 +1,33 @@
+import { default as React } from 'react';
+interface TooltipFormatter {
+    from: (value: number) => number;
+    to: (value: number) => string;
+}
+export interface RangeSliderProps {
+    values: number[];
+    min: number;
+    max: number;
+    isDisabled?: boolean;
+    shouldConnectHandles?: boolean;
+    step?: number;
+    isTooltipEnabled?: boolean;
+    tooltipCustomFormatter?: TooltipFormatter[] | null;
+    tooltipSuffix?: string;
+    className?: string;
+    onChange?: (values: number[], handle: number) => void;
+}
+/**
+ * @param {string?}     props.className                 Class name to apply to the Range slider input.
+ * @param {number[]}    props.values                    Initial values to be display on the slider input.
+ * @param {number}      props.min                       Slider Minimum value.
+ * @param {number}      props.max                       Slider Maximum value.
+ * @param {boolean?}    props.isDisabled                To disabled the range slider.
+ * @param {boolean?}    props.shouldConnectHandles      To Display colored bars between handles.
+ * @param {number?}     props.step                      Increament / decrement slider input by this Step count.
+ * @param {boolean?}    props.isTooltipEnabled          Show tooltip on slider.
+ * @param {object[]?}   props.tooltipCustomFormatter    Custom tooltip formatter.
+ * @param {string?}     props.tooltipSuffix             Suffix to be added to the tooltip.
+ * @param {Function?}   props.onChange                  Debounced callback when range slider is changed.
+ */
+export declare const RangeSlider: ({ values, min, max, isDisabled, shouldConnectHandles, step, isTooltipEnabled, tooltipCustomFormatter, tooltipSuffix, className, onChange, }: RangeSliderProps) => React.JSX.Element;
+export {};

package/build/components/Forms/RangeSlider.js

@@ -0,0 +1,39 @@
+import { jsx as d } from "react/jsx-runtime";
+import u from "clsx";
+import g from "nouislider-react";
+/* empty css                                                      */
+/* empty css                */
+const j = ({
+  values: t,
+  min: o,
+  max: e,
+  isDisabled: i = !1,
+  shouldConnectHandles: s = !1,
+  step: a = 1,
+  isTooltipEnabled: l = !0,
+  tooltipCustomFormatter: m = null,
+  tooltipSuffix: n,
+  className: p,
+  onChange: f
+}) => {
+  const c = m ?? t.map(() => ({
+    from: (r) => r,
+    to: (r) => `${Math.round(r)}${n ?? ""}`
+  }));
+  return /* @__PURE__ */ d(
+    g,
+    {
+      className: u("ui-range-slider", p),
+      connect: s,
+      disabled: i,
+      start: t,
+      range: { min: o, max: e },
+      step: a,
+      tooltips: l ? c : !1,
+      onChange: f
+    }
+  );
+};
+export {
+  j as RangeSlider
+};

package/build/components/Forms/Select.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+import { BaseInputProps } from './BaseInput';
+export interface SelectProps extends BaseInputProps, Omit<React.SelectHTMLAttributes<HTMLSelectElement>, keyof BaseInputProps> {
+}
+export declare const Select: React.ForwardRefExoticComponent<Omit<SelectProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

package/build/components/Forms/Select.js

@@ -0,0 +1,8 @@
+import { jsx as t } from "react/jsx-runtime";
+import { forwardRef as o } from "react";
+import { BaseInput as m } from "./BaseInput.js";
+const p = o((e, r) => /* @__PURE__ */ t(m, { ref: r, as: "select", ...e }));
+p.displayName = "Select";
+export {
+  p as Select
+};

package/build/components/Forms/Switch.d.ts

@@ -0,0 +1,46 @@
+import { default as React } from 'react';
+declare const sizes: {
+    readonly large: {
+        readonly parent: "h-6 w-11";
+        readonly inner: "h-5 w-5";
+        readonly translate: "translate-x-5";
+    };
+    readonly medium: {
+        readonly parent: "h-5 w-8";
+        readonly inner: "h-4 w-4";
+        readonly translate: "translate-x-3";
+    };
+    readonly small: {
+        readonly parent: "h-3 w-5";
+        readonly inner: "h-2 w-2";
+        readonly translate: "translate-x-2";
+    };
+};
+type SwitchSize = keyof typeof sizes;
+export interface SwitchProps {
+    isChecked?: boolean;
+    size?: SwitchSize;
+    disabled?: boolean;
+    className?: string;
+    onChange?: (checked: boolean) => void;
+}
+export interface SwitchGroupProps {
+    className?: string;
+    children: React.ReactNode;
+}
+export interface SwitchLabelProps {
+    direction?: "left" | "right";
+    className?: string;
+    children: React.ReactNode;
+}
+export declare const Switch: (({ isChecked, size, disabled, className, onChange }: SwitchProps) => React.JSX.Element) & {
+    Group: {
+        ({ children, className }: SwitchGroupProps): React.JSX.Element;
+        displayName: string;
+    };
+    Label: {
+        ({ direction, children, className }: SwitchLabelProps): React.JSX.Element;
+        displayName: string;
+    };
+};
+export {};

package/build/components/Forms/Switch.js

@@ -0,0 +1,62 @@
+import { jsx as e } from "react/jsx-runtime";
+import { Switch as s } from "@headlessui/react";
+import n from "clsx";
+import { noop as m } from "lodash-es";
+const i = {
+  large: {
+    parent: "h-6 w-11",
+    inner: "h-5 w-5",
+    translate: "translate-x-5"
+  },
+  medium: {
+    parent: "h-5 w-8",
+    inner: "h-4 w-4",
+    translate: "translate-x-3"
+  },
+  small: {
+    parent: "h-3 w-5",
+    inner: "h-2 w-2",
+    translate: "translate-x-2"
+  }
+}, p = ({ isChecked: r = !1, size: t = "medium", disabled: a, className: c, onChange: u }) => /* @__PURE__ */ e(
+  s,
+  {
+    checked: r,
+    disabled: a,
+    className: n(
+      "ui-switch",
+      r ? "bg-primary disabled:bg-gray-light" : "bg-gray disabled:bg-gray-light",
+      "relative inline-flex flex-shrink-0 cursor-pointer rounded-full border-2 border-transparent transition-colors duration-200 ease-in-out focus:outline-none",
+      i[t].parent,
+      c
+    ),
+    onChange: u ?? m,
+    children: /* @__PURE__ */ e(
+      "span",
+      {
+        className: n(
+          r ? i[t].translate : "translate-x-0",
+          "ui-switch-inner pointer-events-none inline-block transform rounded-full bg-white shadow ring-0 transition duration-200 ease-in-out",
+          i[t].inner
+        )
+      }
+    )
+  }
+), o = ({ children: r, className: t }) => /* @__PURE__ */ e(s.Group, { as: "div", className: n("ui-switch-group", "inline-flex items-center", t), children: r });
+o.displayName = "Switch.Group";
+const l = ({ direction: r = "left", children: t, className: a }) => /* @__PURE__ */ e(
+  s.Label,
+  {
+    as: "span",
+    className: n("ui-switch-label", "cursor-pointer", r === "left" ? "mr-2" : "ml-2", a),
+    children: t
+  }
+);
+l.displayName = "Switch.Label";
+const g = Object.assign(p, {
+  Group: o,
+  Label: l
+});
+export {
+  g as Switch
+};

package/build/components/Forms/Textarea.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { BaseInputProps } from './BaseInput';
+export interface TextareaProps extends BaseInputProps, Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, keyof BaseInputProps> {
+    shouldAutoSize?: boolean;
+}
+export declare const Textarea: React.ForwardRefExoticComponent<Omit<TextareaProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

package/build/components/Forms/Textarea.js

@@ -0,0 +1,35 @@
+import { jsx as m } from "react/jsx-runtime";
+import i from "clsx";
+import { forwardRef as p } from "react";
+import f from "react-textarea-autosize";
+import { BaseInput as s } from "./BaseInput.js";
+const n = p(
+  ({ className: a, value: r, shouldAutoSize: x = !1, rows: t = 2, ...e }, o) => x ? (
+    // TextareaAutosize has a few special props like minRows and maxRows instead of rows field so using rows field to feed the minRows prop. See full list here https://github.com/Andarist/react-textarea-autosize?tab=readme-ov-file#props
+    /* @__PURE__ */ m(
+      s,
+      {
+        ref: o,
+        as: f,
+        value: r,
+        minRows: t,
+        className: i("ui-textarea", a),
+        ...e
+      }
+    )
+  ) : /* @__PURE__ */ m(
+    s,
+    {
+      ref: o,
+      as: "textarea",
+      value: r,
+      rows: t,
+      className: i("ui-textarea", a),
+      ...e
+    }
+  )
+);
+n.displayName = "Textarea";
+export {
+  n as Textarea
+};