@fangxinyan/lumina 0.6.18 → 0.8.0

package/dist/chunk-HSDMJUB6.cjs

@@ -0,0 +1,319 @@
+'use strict';
+
+var React = require('react');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+// src/utils/overlayStack.ts
+var FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "[tabindex]:not([tabindex='-1'])",
+  "[contenteditable='true']"
+].join(",");
+var layers = [];
+var listeningDocuments = /* @__PURE__ */ new Map();
+var scrollLocks = /* @__PURE__ */ new Map();
+var nextOverlayZIndex = 1e3;
+var nextLayerOrder = 0;
+var OverlayZIndexContext = React__namespace.createContext(void 0);
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? React__namespace.useLayoutEffect : React__namespace.useEffect;
+function OverlayZIndexProvider({ zIndex, children }) {
+  return React__namespace.createElement(OverlayZIndexContext.Provider, { value: zIndex }, children);
+}
+function useOverlayZIndex(open, explicitZIndex) {
+  const parentZIndex = React__namespace.useContext(OverlayZIndexContext);
+  const allocatedZIndexRef = React__namespace.useRef();
+  const wasOpenRef = React__namespace.useRef(false);
+  const hasValidExplicitZIndex = explicitZIndex != null && Number.isFinite(explicitZIndex);
+  if (hasValidExplicitZIndex) {
+    if (open) nextOverlayZIndex = Math.max(nextOverlayZIndex, explicitZIndex);
+    wasOpenRef.current = open;
+    return explicitZIndex;
+  }
+  if (!open) {
+    wasOpenRef.current = false;
+    return allocatedZIndexRef.current ?? Math.max(nextOverlayZIndex, parentZIndex ?? 0);
+  }
+  const floor = parentZIndex ?? 0;
+  if (!wasOpenRef.current || allocatedZIndexRef.current == null || allocatedZIndexRef.current <= floor) {
+    nextOverlayZIndex = Math.max(nextOverlayZIndex, floor) + 10;
+    allocatedZIndexRef.current = nextOverlayZIndex;
+  }
+  wasOpenRef.current = true;
+  return allocatedZIndexRef.current;
+}
+function isElementVisibleForFocus(element, container) {
+  const view = element.ownerDocument.defaultView;
+  if (!view) return true;
+  const elementStyle = view.getComputedStyle(element);
+  if (elementStyle.visibility === "hidden" || elementStyle.visibility === "collapse") return false;
+  let current = element;
+  while (current) {
+    const style = view.getComputedStyle(current);
+    if (style.display === "none" || style.contentVisibility === "hidden") return false;
+    if (current === container) break;
+    current = current.parentElement;
+  }
+  return true;
+}
+function getFocusableElements(container) {
+  return Array.from(container.querySelectorAll(FOCUSABLE_SELECTOR)).filter(
+    (element) => element.tabIndex >= 0 && element.getAttribute("aria-hidden") !== "true" && !element.hasAttribute("hidden") && !element.closest("[hidden],[inert]") && isElementVisibleForFocus(element, container)
+  );
+}
+function getLayerZIndex(layer) {
+  if (layer.zIndex != null && Number.isFinite(layer.zIndex)) return layer.zIndex;
+  const container = layer.containerRef.current;
+  if (!container) return 0;
+  const inlineValue = container.style.zIndex.trim();
+  const computedValue = inlineValue || container.ownerDocument.defaultView?.getComputedStyle(container).zIndex || "";
+  const parsed = Number.parseFloat(computedValue);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function isOwnedBy(child, parent, documentLayers, visited = /* @__PURE__ */ new Set()) {
+  if (child === parent || visited.has(child.id)) return false;
+  visited.add(child.id);
+  const owner = child.ownerRef?.current;
+  const parentContainer = parent.containerRef.current;
+  if (!owner || !parentContainer) return false;
+  if (parentContainer.contains(owner)) return true;
+  return documentLayers.some(
+    (candidate) => candidate !== child && candidate !== parent && candidate.containerRef.current?.contains(owner) && isOwnedBy(candidate, parent, documentLayers, visited)
+  );
+}
+function isLayerOwnedByElement(layer, owner, documentLayers, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(layer.id)) return false;
+  visited.add(layer.id);
+  const layerOwner = layer.ownerRef?.current;
+  if (!layerOwner) return false;
+  if (layerOwner === owner || owner.contains(layerOwner)) return true;
+  return documentLayers.some((candidate) => {
+    if (candidate === layer || !candidate.containerRef.current?.contains(layerOwner)) return false;
+    return isLayerOwnedByElement(candidate, owner, documentLayers, visited);
+  });
+}
+function isTargetWithinOverlayScope(owner, target) {
+  const NodeConstructor = owner.ownerDocument.defaultView?.Node;
+  if (!target || !NodeConstructor || !(target instanceof NodeConstructor)) return false;
+  if (owner.contains(target)) return true;
+  const documentLayers = layers.filter((layer) => layer.document === owner.ownerDocument);
+  return documentLayers.some(
+    (layer) => !!layer.containerRef.current?.contains(target) && isLayerOwnedByElement(layer, owner, documentLayers)
+  );
+}
+function orderDocumentLayers(documentLayers) {
+  return [...documentLayers].sort((left, right) => {
+    if (isOwnedBy(right, left, documentLayers)) return -1;
+    if (isOwnedBy(left, right, documentLayers)) return 1;
+    const zIndexDelta = getLayerZIndex(left) - getLayerZIndex(right);
+    return zIndexDelta || left.order - right.order;
+  });
+}
+function createFocusScope(trappingLayer, documentLayers) {
+  const container = trappingLayer.containerRef.current;
+  if (!container) return null;
+  const containers = [container];
+  const focusable = getFocusableElements(container);
+  const ownedLayers = orderDocumentLayers(documentLayers).filter((layer) => isOwnedBy(layer, trappingLayer, documentLayers));
+  ownedLayers.forEach((layer) => {
+    const childContainer = layer.containerRef.current;
+    if (!childContainer) return;
+    containers.push(childContainer);
+    const childFocusable = getFocusableElements(childContainer);
+    if (childFocusable.length === 0) return;
+    const owner = layer.ownerRef?.current;
+    const ownerIndex = owner ? focusable.findIndex((element) => element === owner || owner.contains(element) || element.contains(owner)) : -1;
+    focusable.splice(ownerIndex >= 0 ? ownerIndex + 1 : focusable.length, 0, ...childFocusable);
+  });
+  return { containers, focusable: [...new Set(focusable)] };
+}
+function trapTabKey(event, scope) {
+  const { containers, focusable } = scope;
+  const container = containers[0];
+  if (focusable.length === 0) {
+    event.preventDefault();
+    container.focus();
+    return;
+  }
+  const active = container.ownerDocument.activeElement;
+  const activeInsideScope = containers.some((scopeContainer) => scopeContainer.contains(active));
+  const activeIndex = focusable.indexOf(active);
+  if (!activeInsideScope || activeIndex < 0) {
+    event.preventDefault();
+    (event.shiftKey ? focusable[focusable.length - 1] : focusable[0]).focus();
+    return;
+  }
+  const direction = event.shiftKey ? -1 : 1;
+  const nextIndex = (activeIndex + direction + focusable.length) % focusable.length;
+  event.preventDefault();
+  focusable[nextIndex].focus();
+}
+function handleDocumentKeyDown(event) {
+  const documentLayers = layers.filter((layer) => layer.document === event.currentTarget);
+  const orderedLayers = orderDocumentLayers(documentLayers);
+  const top = orderedLayers[orderedLayers.length - 1];
+  if (!top) return;
+  if (event.key === "Escape" && top.onEscape) {
+    event.preventDefault();
+    event.stopPropagation();
+    top.onEscape();
+    return;
+  }
+  if (event.key === "Tab") {
+    const active = top.document.activeElement;
+    const trappingLayer = [...orderedLayers].reverse().find((layer) => {
+      if (!layer.trapFocus) return false;
+      const scope2 = createFocusScope(layer, documentLayers);
+      if (!scope2) return false;
+      const ownsTop = layer === top || isOwnedBy(top, layer, documentLayers);
+      const containsActive = scope2.containers.some((container) => container.contains(active));
+      return ownsTop || containsActive;
+    });
+    const scope = trappingLayer ? createFocusScope(trappingLayer, documentLayers) : null;
+    if (scope) trapTabKey(event, scope);
+  }
+}
+function retainDocumentListener(doc) {
+  const count = listeningDocuments.get(doc) ?? 0;
+  if (count === 0) doc.addEventListener("keydown", handleDocumentKeyDown, true);
+  listeningDocuments.set(doc, count + 1);
+}
+function releaseDocumentListener(doc) {
+  const count = listeningDocuments.get(doc) ?? 0;
+  if (count <= 1) {
+    doc.removeEventListener("keydown", handleDocumentKeyDown, true);
+    listeningDocuments.delete(doc);
+    return;
+  }
+  listeningDocuments.set(doc, count - 1);
+}
+function lockDocumentScroll(doc) {
+  const existing = scrollLocks.get(doc);
+  if (existing) {
+    existing.count += 1;
+    return;
+  }
+  const body = doc.body;
+  const scrollbarWidth = Math.max(0, doc.defaultView.innerWidth - doc.documentElement.clientWidth);
+  const computedPadding = Number.parseFloat(doc.defaultView.getComputedStyle(body).paddingRight) || 0;
+  scrollLocks.set(doc, {
+    count: 1,
+    overflow: body.style.overflow,
+    paddingRight: body.style.paddingRight
+  });
+  body.style.overflow = "hidden";
+  if (scrollbarWidth > 0) body.style.paddingRight = `${computedPadding + scrollbarWidth}px`;
+}
+function unlockDocumentScroll(doc) {
+  const state = scrollLocks.get(doc);
+  if (!state) return;
+  state.count -= 1;
+  if (state.count > 0) return;
+  doc.body.style.overflow = state.overflow;
+  doc.body.style.paddingRight = state.paddingRight;
+  scrollLocks.delete(doc);
+}
+function useOverlayLayer({
+  open,
+  containerRef,
+  ownerRef,
+  zIndex,
+  onEscape,
+  escapeEnabled = true,
+  trapFocus = false,
+  autoFocus = false,
+  restoreFocus = false,
+  lockScroll = false,
+  initialFocusRef
+}) {
+  const idRef = React__namespace.useRef(/* @__PURE__ */ Symbol("lumina-overlay"));
+  const entryRef = React__namespace.useRef(null);
+  const previousFocusRef = React__namespace.useRef(null);
+  const restoreFocusRef = React__namespace.useRef(restoreFocus);
+  restoreFocusRef.current = restoreFocus;
+  if (entryRef.current) {
+    entryRef.current.containerRef = containerRef;
+    entryRef.current.ownerRef = ownerRef;
+    entryRef.current.zIndex = zIndex;
+    entryRef.current.onEscape = escapeEnabled ? onEscape : void 0;
+    entryRef.current.trapFocus = trapFocus;
+  }
+  useIsomorphicLayoutEffect(() => {
+    if (!open || typeof document === "undefined") return;
+    const container = containerRef.current;
+    const doc = container?.ownerDocument ?? document;
+    previousFocusRef.current = doc.activeElement;
+    const entry = {
+      id: idRef.current,
+      containerRef,
+      ownerRef,
+      zIndex,
+      onEscape: escapeEnabled ? onEscape : void 0,
+      trapFocus,
+      document: doc,
+      order: ++nextLayerOrder
+    };
+    entryRef.current = entry;
+    layers.push(entry);
+    retainDocumentListener(doc);
+    const frame = autoFocus ? doc.defaultView?.requestAnimationFrame(() => {
+      const currentContainer = containerRef.current;
+      if (!currentContainer) return;
+      const target = initialFocusRef?.current ?? getFocusableElements(currentContainer)[0] ?? currentContainer;
+      target?.focus();
+    }) : void 0;
+    return () => {
+      if (frame != null) doc.defaultView?.cancelAnimationFrame(frame);
+      const index = layers.findIndex((layer) => layer.id === entry.id);
+      if (index >= 0) layers.splice(index, 1);
+      releaseDocumentListener(doc);
+      const currentEntry = entryRef.current ?? entry;
+      entryRef.current = null;
+      if (restoreFocusRef.current) {
+        const previous = previousFocusRef.current;
+        const owner = currentEntry.ownerRef?.current;
+        const ownerTarget = owner ? owner.tabIndex >= 0 ? owner : getFocusableElements(owner)[0] : void 0;
+        const closingContainer = currentEntry.containerRef.current ?? container;
+        doc.defaultView?.requestAnimationFrame(() => {
+          const active = doc.activeElement;
+          const focusWasReleased = active == null || active === doc.body || active === doc.documentElement || !active.isConnected || closingContainer?.contains(active);
+          const target = ownerTarget?.isConnected ? ownerTarget : previous;
+          if (target?.isConnected && focusWasReleased) target.focus();
+        });
+      }
+    };
+  }, [open]);
+  useIsomorphicLayoutEffect(() => {
+    if (!open || !lockScroll || typeof document === "undefined") return;
+    const doc = containerRef.current?.ownerDocument ?? document;
+    lockDocumentScroll(doc);
+    return () => unlockDocumentScroll(doc);
+  }, [open, lockScroll, containerRef]);
+}
+
+exports.OverlayZIndexProvider = OverlayZIndexProvider;
+exports.isTargetWithinOverlayScope = isTargetWithinOverlayScope;
+exports.useOverlayLayer = useOverlayLayer;
+exports.useOverlayZIndex = useOverlayZIndex;

package/dist/chunk-HVPUGYBY.js

@@ -0,0 +1,166 @@
+import { useOverlayZIndex, useOverlayLayer, OverlayZIndexProvider } from './chunk-2A4GYSN4.js';
+import { Icon } from './chunk-LQMOYVQF.js';
+import { useComponentPortalTheme, withComponentTheme } from './chunk-DRDDQCDD.js';
+import { usePortalContainer } from './chunk-ULTDRMGN.js';
+import './tokens-CEJVVA3G.css';
+import './shared-NJHRNLRH.css';
+import './Drawer-VCXAXWV6.css';
+import * as React from 'react';
+import ReactDOM from 'react-dom';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+var ANIM_MS = 280;
+var DrawerBase = React.forwardRef((props, ref) => {
+  const hasExplicitSize = props.size !== void 0;
+  const {
+    open,
+    onClose,
+    placement = "right",
+    size = 380,
+    title,
+    extra,
+    footer,
+    children,
+    bodyClassName = "",
+    bodyStyle,
+    bodyProps,
+    bodyOverflow,
+    bodyInset = "safe",
+    mask = true,
+    maskClosable = true,
+    maskClassName = "",
+    maskStyle,
+    keyboard = true,
+    closable = true,
+    closeIcon,
+    destroyOnClose = false,
+    afterOpenChange,
+    zIndex,
+    className = "",
+    style,
+    onClick,
+    ...rest
+  } = props;
+  const portalContainer = usePortalContainer();
+  const portalTheme = useComponentPortalTheme("Drawer");
+  const panelRef = React.useRef(null);
+  const titleId = React.useId();
+  const panelZIndex = useOverlayZIndex(open, zIndex);
+  const [hasOpenedOnce, setHasOpenedOnce] = React.useState(open);
+  React.useEffect(() => {
+    if (open) setHasOpenedOnce(true);
+  }, [open]);
+  useOverlayLayer({
+    open: open && portalContainer != null,
+    containerRef: panelRef,
+    zIndex: panelZIndex,
+    onEscape: onClose,
+    escapeEnabled: keyboard,
+    trapFocus: mask,
+    autoFocus: mask,
+    restoreFocus: true,
+    lockScroll: mask
+  });
+  const setPanelRef = React.useCallback((node) => {
+    panelRef.current = node;
+    if (typeof ref === "function") ref(node);
+    else if (ref) ref.current = node;
+  }, [ref]);
+  const prevOpen = React.useRef(open);
+  const afterOpenChangeRef = React.useRef(afterOpenChange);
+  afterOpenChangeRef.current = afterOpenChange;
+  React.useEffect(() => {
+    if (prevOpen.current !== open) {
+      prevOpen.current = open;
+      const id = window.setTimeout(() => afterOpenChangeRef.current?.(open), ANIM_MS);
+      return () => window.clearTimeout(id);
+    }
+  }, [open]);
+  if (!portalContainer) return null;
+  if (!hasOpenedOnce) return null;
+  if (!open && destroyOnClose) return null;
+  const isV = placement === "left" || placement === "right";
+  const panelStyle = {
+    ...portalTheme.style,
+    ...isV ? { width: size, maxWidth: "92vw" } : { height: size, maxHeight: "80vh" },
+    ...portalTheme.styles.popup,
+    ...hasExplicitSize ? isV ? { width: size } : { height: size } : null
+  };
+  Object.assign(panelStyle, style);
+  panelStyle.zIndex = panelZIndex;
+  const overlayStyle = {
+    ...portalTheme.styles.overlay,
+    ...maskStyle,
+    zIndex: panelZIndex - 1
+  };
+  const drawerBodyStyle = bodyOverflow == null ? { ...portalTheme.styles.body, ...bodyStyle } : { ...portalTheme.styles.body, overflow: bodyOverflow, ...bodyStyle };
+  return ReactDOM.createPortal(
+    /* @__PURE__ */ jsx(OverlayZIndexProvider, { zIndex: panelZIndex, children: /* @__PURE__ */ jsxs(Fragment, { children: [
+      mask && /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: ["drawer-overlay", open ? "" : "hidden", maskClassName].filter(Boolean).join(" "),
+          style: overlayStyle,
+          onClick: () => maskClosable && onClose?.()
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        "div",
+        {
+          ref: setPanelRef,
+          className: `drawer ${placement} ${open ? "" : "hidden"} ${className}`,
+          style: panelStyle,
+          onClick: (e) => {
+            onClick?.(e);
+            e.stopPropagation();
+          },
+          role: "dialog",
+          "aria-hidden": !open,
+          "aria-modal": mask || void 0,
+          "aria-labelledby": title ? titleId : void 0,
+          tabIndex: -1,
+          ...portalTheme.dataAttributes,
+          ...rest,
+          children: [
+            (title || extra || closable) && /* @__PURE__ */ jsxs("div", { className: "drawer-head", children: [
+              /* @__PURE__ */ jsx("div", { id: title ? titleId : void 0, className: "drawer-title", children: title }),
+              /* @__PURE__ */ jsxs("div", { className: "drawer-head-right", children: [
+                extra,
+                closable && /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    className: "drawer-close",
+                    onClick: onClose,
+                    "aria-label": "Close",
+                    children: closeIcon ?? /* @__PURE__ */ jsx(Icon, { name: "x", size: 16 })
+                  }
+                )
+              ] })
+            ] }),
+            /* @__PURE__ */ jsx(
+              "div",
+              {
+                ...bodyProps,
+                className: ["drawer-body", `inset-${bodyInset}`, bodyClassName].filter(Boolean).join(" "),
+                style: drawerBodyStyle,
+                children
+              }
+            ),
+            footer && /* @__PURE__ */ jsx("div", { className: "drawer-foot", children: footer })
+          ]
+        }
+      )
+    ] }) }),
+    portalContainer
+  );
+});
+DrawerBase.displayName = "Drawer";
+var Drawer = withComponentTheme(
+  DrawerBase,
+  "Drawer",
+  "drawer",
+  { portalOnly: true }
+);
+
+export { Drawer };

package/dist/chunk-HYHBCHFM.cjs

@@ -0,0 +1,167 @@
+'use strict';
+
+var chunk2AUXUZ3Z_cjs = require('./chunk-2AUXUZ3Z.cjs');
+var chunkNRJXZPZR_cjs = require('./chunk-NRJXZPZR.cjs');
+require('./tokens-CEJVVA3G.css');
+require('./shared-NJHRNLRH.css');
+require('./Textarea-ZGHBZNLX.css');
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+// src/utils/inputEvents.ts
+function createValueOverrideTarget(element, value) {
+  if (!element) return { value };
+  return new Proxy(element, {
+    get(target, property) {
+      if (property === "value") return value;
+      const result = Reflect.get(target, property, target);
+      return typeof result === "function" ? result.bind(target) : result;
+    }
+  });
+}
+var TextareaBase = React__namespace.forwardRef(
+  ({
+    value,
+    defaultValue,
+    onChange,
+    onValueChange,
+    invalid,
+    allowClear,
+    maxLength,
+    showCount,
+    className = "",
+    theme,
+    style,
+    ...rest
+  }, ref) => {
+    const [inner, setInner] = React__namespace.useState(defaultValue ?? "");
+    const [themeRootElement, themeRootRef] = chunkNRJXZPZR_cjs.useComponentThemeRootRef(
+      void 0,
+      { component: "Textarea", theme }
+    );
+    const textareaRef = React__namespace.useRef(null);
+    const isControlled = value !== void 0;
+    const currentValue = isControlled ? value : inner;
+    const disabled = rest.disabled;
+    const handleChange = (e) => {
+      if (!isControlled) setInner(e.target.value);
+      onChange?.(e);
+      onValueChange?.(e.target.value, e);
+    };
+    const setTextareaRef = React__namespace.useCallback((node) => {
+      textareaRef.current = node;
+      if (typeof ref === "function") ref(node);
+      else if (ref) ref.current = node;
+    }, [ref]);
+    const handleClear = (e) => {
+      e.stopPropagation();
+      if (disabled) return;
+      if (!isControlled) setInner("");
+      if (!isControlled && textareaRef.current) textareaRef.current.value = "";
+      const clearedTarget = createValueOverrideTarget(textareaRef.current, "");
+      const synthetic = {
+        ...e,
+        type: "change",
+        target: clearedTarget,
+        currentTarget: clearedTarget
+      };
+      onChange?.(synthetic);
+      onValueChange?.("", synthetic);
+    };
+    const cls = ["textarea", invalid && "invalid", className].filter(Boolean).join(" ");
+    const showClear = !!allowClear && !!currentValue && !disabled;
+    const count = currentValue ? currentValue.length : 0;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      chunkNRJXZPZR_cjs.ComponentThemeBoundary,
+      {
+        component: "Textarea",
+        cssPrefix: "textarea",
+        theme,
+        rootElement: themeRootElement,
+        children: (themeState) => {
+          const mergedRootStyle = chunkNRJXZPZR_cjs.mergeComponentRootStyleWithInstanceStyle(
+            themeState.rootStyle,
+            style
+          );
+          const field = /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              ref: showCount ? void 0 : themeRootRef,
+              className: "textarea-wrap",
+              ...!showCount ? themeState.rootDataAttributes : null,
+              style: showCount ? themeState.styles.control : mergedRootStyle,
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  "textarea",
+                  {
+                    ref: setTextareaRef,
+                    className: cls,
+                    value: isControlled ? value : void 0,
+                    defaultValue: isControlled ? void 0 : defaultValue,
+                    onChange: handleChange,
+                    maxLength,
+                    ...rest,
+                    style: { ...themeState.styles.input, ...style }
+                  }
+                ),
+                showClear && /* @__PURE__ */ jsxRuntime.jsx(
+                  "button",
+                  {
+                    type: "button",
+                    className: "textarea-clear",
+                    role: "button",
+                    "aria-label": "Clear",
+                    onMouseDown: (e) => e.preventDefault(),
+                    onClick: handleClear,
+                    children: /* @__PURE__ */ jsxRuntime.jsx(chunk2AUXUZ3Z_cjs.Icon, { name: "x", size: 12 })
+                  }
+                )
+              ]
+            }
+          );
+          if (!showCount) return field;
+          return /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              ref: themeRootRef,
+              className: "textarea-shell",
+              ...themeState.rootDataAttributes,
+              style: mergedRootStyle,
+              children: [
+                field,
+                /* @__PURE__ */ jsxRuntime.jsx("div", { className: "textarea-count", style: themeState.styles.count, children: maxLength != null ? `${count} / ${maxLength}` : `${count}` })
+              ]
+            }
+          );
+        }
+      }
+    );
+  }
+);
+TextareaBase.displayName = "Textarea";
+var Textarea = TextareaBase;
+var TextArea = Textarea;
+
+exports.TextArea = TextArea;
+exports.Textarea = Textarea;
+exports.createValueOverrideTarget = createValueOverrideTarget;

package/dist/chunk-HYJSMFZA.cjs

@@ -0,0 +1,2 @@
+'use strict';
+