@t-headless-ui/react 1.1.2 → 1.1.3

package/dist/es/input-tag/components/input-tag-root.mjs

@@ -0,0 +1,110 @@
+"use client";
+import { jsx as v } from "react/jsx-runtime";
+import { useImperativeHandle as P } from "react";
+import { InputTagInnerContext as R } from "../inner-context.mjs";
+import { useInputTagStore as j } from "../store/useInputTagStore.mjs";
+import { keepFocus as L } from "../utils/keepFocus.mjs";
+const O = {
+  validate: (u, n) => u && n.every((l) => l.value !== u)
+};
+function E(u) {
+  const {
+    defaultValue: n,
+    value: l,
+    inputValue: I,
+    readOnly: d,
+    disabled: p,
+    onRemove: c,
+    onChange: f,
+    labelInValue: m,
+    onClick: s,
+    children: g,
+    maxTagCount: V,
+    focused: b,
+    disableInput: T,
+    ref: h,
+    validate: C = O.validate,
+    tokenSeparators: k,
+    ...r
+  } = u, {
+    refWrapper: i,
+    refInput: a,
+    refTSLastSeparateTriggered: x,
+    focused: t,
+    setFocused: y,
+    value: S,
+    setValue: F,
+    inputValue: w,
+    setInputValue: D,
+    hotkeyHandler: H,
+    handleClearClick: M
+  } = j({
+    defaultValue: n,
+    propsValue: l,
+    propsInputValue: I,
+    readOnly: d,
+    disabled: p,
+    onRemove: c,
+    onChange: f,
+    labelInValue: m,
+    propsFocused: b
+  });
+  return P(h, () => ({
+    blur: () => {
+      var e;
+      return (e = a.current) == null ? void 0 : e.blur();
+    },
+    focus: () => {
+      var e;
+      return (e = a.current) == null ? void 0 : e.focus();
+    },
+    dom: i.current
+  }), [a, i]), /* @__PURE__ */ v(
+    R.Provider,
+    {
+      value: {
+        refInput: a,
+        refTSLastSeparateTriggered: x,
+        focused: t,
+        setFocused: y,
+        value: S,
+        setValue: F,
+        inputValue: w,
+        setInputValue: D,
+        hotkeyHandler: H,
+        readOnly: d,
+        disabled: p,
+        disableInput: T,
+        onRemove: c,
+        labelInValue: m,
+        maxTagCount: V,
+        handleClearClick: M,
+        onChange: f,
+        validate: C,
+        tokenSeparators: k
+      },
+      children: /* @__PURE__ */ v(
+        "div",
+        {
+          ...r,
+          ref: i,
+          onMouseDown: (e) => {
+            var o;
+            t && L(e), (o = r == null ? void 0 : r.onMouseDown) == null || o.call(r, e);
+          },
+          onClick: (e) => {
+            var o;
+            t || (o = a.current) == null || o.focus(), s == null || s(e);
+          },
+          "aria-disabled": !!p,
+          "aria-readonly": !!d,
+          "data-focused": !!t,
+          children: g
+        }
+      )
+    }
+  );
+}
+export {
+  E as InputTagRoot
+};

package/dist/es/input-tag/components/input-tag.mjs

@@ -0,0 +1,38 @@
+"use client";
+import { jsxs as l, jsx as C, Fragment as s } from "react/jsx-runtime";
+import { useMemo as u } from "react";
+import { useInputInnerTagContext as j } from "../inner-context.mjs";
+import { mergedRenderTag as y } from "../utils/mergedRenderTag.mjs";
+function k(a) {
+  const { value: r, setValue: c, readOnly: m, disabled: d, onRemove: p, labelInValue: g, maxTagCount: n, onChange: f } = j(), {
+    renderTag: b = ({ label: e, closable: o, onClose: T }, v) => /* @__PURE__ */ l("span", { children: [
+      e,
+      " ",
+      o && /* @__PURE__ */ C("span", { onClick: T, children: "×" })
+    ] }, v)
+  } = a, t = u(() => typeof n == "object" ? n.count : n, [n]), { visibleList: h, hiddenList: i } = u(() => {
+    let e = r, o = [];
+    return typeof t == "number" && t >= 0 && t < r.length && (e = r.slice(0, t), o = r.slice(t)), { visibleList: e, hiddenList: o };
+  }, [r, t]), x = (e) => typeof n == "object" && n.render ? n.render(e) : /* @__PURE__ */ l(s, { children: [
+    "+",
+    e.length
+  ] });
+  return /* @__PURE__ */ l(s, { children: [
+    h.map((e, o) => y({
+      readOnly: m,
+      item: e,
+      disabled: d,
+      index: o,
+      renderTag: b,
+      value: r,
+      onRemove: p,
+      setValue: c,
+      onChange: f,
+      labelInValue: g
+    })),
+    (i == null ? void 0 : i.length) > 0 && x(i)
+  ] });
+}
+export {
+  k as InputTag
+};

package/dist/es/input-tag/components/input.mjs

@@ -0,0 +1,107 @@
+"use client";
+import { jsx as A } from "react/jsx-runtime";
+import { useInputInnerTagContext as B } from "../inner-context.mjs";
+import { InputComponent as E } from "../../input/input.mjs";
+import { handleTokenSeparators as h } from "../utils/handleTokenSeparators.mjs";
+import { tryAddInputValueToTag as C } from "../utils/tryAddInputValueToTag.mjs";
+import { mergeRefs as H } from "../../hooks/use-merge-refs.mjs";
+function q(V) {
+  const {
+    refInput: k,
+    refTSLastSeparateTriggered: p,
+    setFocused: y,
+    value: r,
+    setValue: l,
+    inputValue: i,
+    setInputValue: n,
+    hotkeyHandler: v,
+    readOnly: t,
+    disabled: x,
+    labelInValue: s,
+    onChange: u,
+    validate: d,
+    tokenSeparators: T,
+    disableInput: D
+  } = B(), { placeholder: S, saveOnBlur: F, onInputChange: f, onKeyDown: m, onPaste: c, onFocus: b, onBlur: g, onPressEnter: I, className: w, style: O, ref: j } = V, a = x || D;
+  return /* @__PURE__ */ A(
+    E,
+    {
+      className: w,
+      style: {
+        outline: "none",
+        backgroundColor: "transparent",
+        ...O
+      },
+      autoComplete: "off",
+      disabled: a,
+      readOnly: t,
+      ref: H(k, j),
+      placeholder: r.length ? "" : S,
+      autoFitWidth: !0,
+      onPressEnter: async (e, o) => {
+        i && o.preventDefault(), I == null || I(o), await C({
+          validate: d,
+          inputValue: i,
+          value: r,
+          setInputValue: n,
+          disabled: a,
+          readOnly: t,
+          setValue: l,
+          onChange: u,
+          labelInValue: s
+        });
+      },
+      onFocus: (e) => {
+        !a && !t && (y(!0), b == null || b(e));
+      },
+      onBlur: async (e) => {
+        y(!1), g == null || g(e), F && await C({
+          validate: d,
+          inputValue: i,
+          value: r,
+          setInputValue: n,
+          disabled: a,
+          readOnly: t,
+          setValue: l,
+          onChange: u,
+          labelInValue: s
+        }), n("");
+      },
+      value: i,
+      onChange: (e, o) => {
+        f == null || f(e, o), o.nativeEvent.inputType !== "insertFromPaste" && h({
+          str: e,
+          refTSLastSeparateTriggered: p,
+          tokenSeparators: T,
+          validate: d,
+          value: r,
+          disabled: a,
+          readOnly: t,
+          setValue: l,
+          onChange: u,
+          labelInValue: s
+        }), p.current ? n("") : n(e);
+      },
+      onKeyDown: (e) => {
+        v(e), m == null || m(e);
+      },
+      onPaste: (e) => {
+        c == null || c(e), h({
+          str: e.clipboardData.getData("text"),
+          refTSLastSeparateTriggered: p,
+          tokenSeparators: T,
+          validate: d,
+          value: r,
+          disabled: a,
+          readOnly: t,
+          setValue: l,
+          onChange: u,
+          labelInValue: s
+        });
+      }
+    }
+  );
+}
+export {
+  q as InputTagInput
+};

package/dist/es/input-tag/constants.mjs

@@ -0,0 +1,7 @@
+const o = "INPUT", c = "add", t = "remove", e = "clear";
+export {
+  c as ADD,
+  e as CLEAR,
+  o as INPUT,
+  t as REMOVE
+};

package/dist/es/input-tag/index.mjs

@@ -0,0 +1,15 @@
+import { InputTagInnerContext as t } from "./inner-context.mjs";
+import { InputTagClear as o } from "./components/input-tag-clear.mjs";
+import { InputTag as p } from "./components/input-tag.mjs";
+import { InputTagInput as n } from "./components/input.mjs";
+import { InputTagRoot as r } from "./components/input-tag-root.mjs";
+const T = {
+  Root: r,
+  Input: n,
+  Tag: p,
+  Clear: o,
+  Context: t
+};
+export {
+  T as InputTag
+};

package/dist/es/input-tag/inner-context.mjs

@@ -0,0 +1,12 @@
+"use client";
+import { createContext as n, useContext as e } from "react";
+const o = n(null), u = () => {
+  const t = e(o);
+  if (!t)
+    throw new Error("InputTag components must be used within <InputTag.Root>");
+  return t;
+};
+export {
+  o as InputTagInnerContext,
+  u as useInputInnerTagContext
+};

package/dist/es/input-tag/store/useInputTagStore.mjs

@@ -0,0 +1,66 @@
+"use client";
+import { useRef as a } from "react";
+import { CLEAR as x } from "../constants.mjs";
+import { getHotkeyHandler as F } from "../../utils/getHotkeyHandler.mjs";
+import { Backspace as L } from "../../utils/keycode.mjs";
+import { formatValue as g } from "../utils/formatValue.mjs";
+import { valueChangeHandler as M } from "../utils/valueChangeHandler.mjs";
+import { tagCloseHandler as w } from "../utils/tagCloseHandler.mjs";
+import { useMergeValue as l } from "../../hooks/use-merge-value.mjs";
+import { isUndefined as V } from "../../utils/is.mjs";
+function z(v) {
+  const { defaultValue: n, propsValue: u, propsInputValue: h, readOnly: s, disabled: p, onRemove: C, onChange: i, labelInValue: f, propsFocused: H } = v, d = a(null), I = a(null), k = a(null), [m, b] = l(!1, {
+    value: H
+  }), [o, r] = l([], {
+    defaultValue: V(n) ? void 0 : g(n),
+    value: V(u) ? void 0 : g(u)
+  }), [y, R] = l("", {
+    value: h
+  }), S = (t) => {
+    var e;
+    t.stopPropagation(), M({ disabled: p, readOnly: s, setValue: r, value: [], onChange: i, labelInValue: f, reason: x }), m || (e = d.current) == null || e.focus();
+  }, T = F(
+    /* @__PURE__ */ new Map([
+      [
+        L.code,
+        (t) => {
+          if (!t.target.value && o.length)
+            for (let e = o.length - 1; e >= 0; e--) {
+              const c = o[e];
+              if (c.disabled !== !1) {
+                w({
+                  item: c,
+                  index: e,
+                  event: t,
+                  onRemove: C,
+                  value: o,
+                  disabled: p,
+                  readOnly: s,
+                  setValue: r,
+                  onChange: i,
+                  labelInValue: f
+                });
+                return;
+              }
+            }
+        }
+      ]
+    ])
+  );
+  return {
+    refInput: d,
+    refWrapper: I,
+    refTSLastSeparateTriggered: k,
+    focused: m,
+    setFocused: b,
+    value: o,
+    setValue: r,
+    inputValue: y,
+    setInputValue: R,
+    hotkeyHandler: T,
+    handleClearClick: S
+  };
+}
+export {
+  z as useInputTagStore
+};

package/dist/es/input-tag/utils/formatValue.mjs

@@ -0,0 +1,15 @@
+import { isArray as r, isObject as u } from "../../utils/is.mjs";
+function e(a) {
+  return r(a) ? a.map((l) => u(l) ? {
+    ...l,
+    label: "label" in l ? l.label : l.value,
+    value: l.value,
+    closable: l.disabled
+  } : {
+    label: l,
+    value: l
+  }) : [];
+}
+export {
+  e as formatValue
+};

package/dist/es/input-tag/utils/handleTokenSeparators.mjs

@@ -0,0 +1,35 @@
+import { valueChangeHandler as h } from "./valueChangeHandler.mjs";
+import { ADD as w } from "../constants.mjs";
+import { isArray as d, isFunction as g } from "../../utils/is.mjs";
+async function A({
+  str: r,
+  refTSLastSeparateTriggered: t,
+  tokenSeparators: i,
+  validate: o,
+  value: e,
+  disabled: u,
+  readOnly: c,
+  setValue: f,
+  onChange: m,
+  labelInValue: p
+}) {
+  if (t.current = null, d(i) && i.length) {
+    const s = r.split(new RegExp(`[${i.join("")}]`));
+    if (s.length > 1) {
+      t.current = Date.now();
+      const l = [];
+      await Promise.all(
+        s.map(async (n) => {
+          const a = n ? g(o) ? await o(n, e) : !0 : !1;
+          a && l.push({
+            value: a === !0 ? n : a,
+            label: n
+          });
+        })
+      ), l.length && h({ disabled: u, readOnly: c, setValue: f, value: e.concat(l), onChange: m, labelInValue: p, reason: w });
+    }
+  }
+}
+export {
+  A as handleTokenSeparators
+};

package/dist/es/input-tag/utils/keepFocus.mjs

@@ -0,0 +1,7 @@
+import { INPUT as e } from "../constants.mjs";
+function r(t) {
+  t.target.tagName !== e && t.preventDefault();
+}
+export {
+  r as keepFocus
+};

package/dist/es/input-tag/utils/mergedRenderTag.mjs

@@ -0,0 +1,32 @@
+import { tagCloseHandler as p } from "./tagCloseHandler.mjs";
+function H({
+  readOnly: o,
+  item: e,
+  disabled: l,
+  index: n,
+  renderTag: r,
+  value: t,
+  onRemove: s,
+  setValue: c,
+  onChange: a,
+  labelInValue: u
+}) {
+  const { value: g, label: C } = e, f = !o && !l && !e.disabled;
+  return r(
+    {
+      value: g,
+      label: C,
+      closable: f,
+      onClose: (m) => {
+        p({ item: e, index: n, event: m, onRemove: s, value: t, disabled: l, readOnly: o, setValue: c, onChange: a, labelInValue: u });
+      },
+      disabled: l,
+      readOnly: o
+    },
+    n,
+    t
+  );
+}
+export {
+  H as mergedRenderTag
+};

package/dist/es/input-tag/utils/tagCloseHandler.mjs

@@ -0,0 +1,27 @@
+import { REMOVE as u } from "../constants.mjs";
+import { valueChangeHandler as C } from "./valueChangeHandler.mjs";
+function h({
+  item: t,
+  index: r,
+  event: s,
+  onRemove: a,
+  value: l,
+  disabled: c,
+  readOnly: f,
+  setValue: i,
+  onChange: p,
+  labelInValue: g
+}) {
+  a == null || a(t, r, s), C({
+    disabled: c,
+    readOnly: f,
+    setValue: i,
+    value: [...l.slice(0, r), ...l.slice(r + 1)],
+    onChange: p,
+    labelInValue: g,
+    reason: u
+  });
+}
+export {
+  h as tagCloseHandler
+};

package/dist/es/input-tag/utils/tryAddInputValueToTag.mjs

@@ -0,0 +1,35 @@
+import { ADD as s } from "../constants.mjs";
+import { valueChangeHandler as f } from "./valueChangeHandler.mjs";
+import { isFunction as u } from "../../utils/is.mjs";
+async function g({
+  validate: t,
+  inputValue: o,
+  value: e,
+  setInputValue: a,
+  disabled: n,
+  readOnly: c,
+  setValue: i,
+  onChange: l,
+  labelInValue: m
+}) {
+  try {
+    const r = u(t) ? await t(o, e) : !0;
+    r && (f({
+      disabled: n,
+      readOnly: c,
+      setValue: i,
+      value: e.concat({
+        value: r === !0 ? o : r,
+        label: o
+      }),
+      onChange: l,
+      labelInValue: m,
+      reason: s
+    }), a(""));
+  } catch (r) {
+    console == null || console.error(r);
+  }
+}
+export {
+  g as tryAddInputValueToTag
+};

package/dist/es/input-tag/utils/valueChangeHandler.mjs

@@ -0,0 +1,6 @@
+function l({ disabled: f, readOnly: i, setValue: p, value: r, onChange: t, labelInValue: u, reason: c }) {
+  f || i || (p(r), t == null || t(u ? r : r.map((d) => d.value), c));
+}
+export {
+  l as valueChangeHandler
+};

package/dist/es/mini-floating-ui/constants.mjs

@@ -1,19 +1,19 @@
-const o = "top", n = "bottom", r = "right", c = "left", s = "start", p = "end", a = "clippingParents", l = "popper", d = "reference", m = "viewport", i = [o, n, r, c], f = [...i].reduce(
-  (t, e) => t.concat([e, `${e}-${s}`, `${e}-${p}`]),
+const s = "top", o = "bottom", n = "right", r = "left", c = "start", i = "end", a = "clippingParents", l = "popper", d = "reference", m = "viewport", p = ["top", o, n, r], f = [...p].reduce(
+  (t, e) => t.concat([e, `${e}-${c}`, `${e}-end`]),
   []
 ), g = "Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.";
 export {
   g as INVALID_ELEMENT_ERROR,
-  i as basePlacements,
-  n as bottom,
+  p as basePlacements,
+  o as bottom,
   a as clippingParents,
-  p as end,
-  c as left,
+  i as end,
+  r as left,
   f as placements,
   l as popper,
   d as reference,
-  r as right,
-  s as start,
-  o as top,
+  n as right,
+  c as start,
+  s as top,
   m as viewport
 };

package/dist/es/modal/components/modal.mjs

@@ -1,75 +1,77 @@
 "use client";
-import { jsx as o, jsxs as A } from "react/jsx-runtime";
-import { useRef as p, useEffect as N, cloneElement as x } from "react";
-import { duration1 as R, maskAnimation as T, duration2 as b, modalAnimation as j } from "../constants.mjs";
-import { useFocusTrap as w } from "../../hooks/use-focus-tarp.mjs";
-import { useOverflowHidden as C } from "../hooks/useOverflowHidden.mjs";
-import { motion as k } from "../../node_modules/.pnpm/motion@12.9.2_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/motion/dist/es/framer-motion/dist/es/render/components/motion/proxy.mjs";
-import { Portal as I } from "../../portal/portal.mjs";
-function q(v) {
+import { jsx as o, jsxs as N } from "react/jsx-runtime";
+import { useRef as p, useEffect as R, cloneElement as x } from "react";
+import { duration1 as T, maskAnimation as b, duration2 as j, modalAnimation as w } from "../constants.mjs";
+import { useFocusTrap as C } from "../../hooks/use-focus-tarp.mjs";
+import { useOverflowHidden as I } from "../hooks/useOverflowHidden.mjs";
+import { motion as h } from "../../node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/render/components/motion/proxy.mjs";
+import { Portal as M } from "../../portal/portal.mjs";
+function z(k) {
   const {
-    mask: n = () => !0,
+    mask: e = () => !0,
     focusLock: s = !0,
     attach: m,
-    afterClose: e,
+    afterClose: n,
     afterOpen: a,
     content: l,
     onCancel: i,
-    maskCls: h,
+    maskCls: v,
     maskStyle: y,
-    containerClassName: E,
+    containerClassName: g,
     index: c,
     initialFocusEl: r,
-    contentProps: u
-  } = v, d = p(null), f = p(null);
-  w(f, s), C(m, n(c));
+    contentProps: u,
+    animation: E
+  } = k, d = p(null), f = p(null);
+  C(f, s), I(m, e(c));
   const P = () => {
-    n && setTimeout(() => {
+    e && setTimeout(() => {
       i == null || i();
     }, 100);
-  }, g = (t) => {
+  }, A = (t) => {
     t.key === "Escape" && (t.stopPropagation(), i == null || i());
   };
-  return N(() => {
+  return R(() => {
     setTimeout(() => {
       var t;
       (t = d.current) == null || t.focus({ preventScroll: !0 }), r == null || r();
     }, 0);
-  }, []), /* @__PURE__ */ o(I, { attach: m, children: /* @__PURE__ */ A("div", { tabIndex: -1, ref: d, onKeyDown: g, children: [
-    n(c) ? /* @__PURE__ */ o(
-      k.div,
+  }, []), /* @__PURE__ */ o(M, { attach: m, children: /* @__PURE__ */ N("div", { tabIndex: -1, ref: d, onKeyDown: A, children: [
+    e(c) ? /* @__PURE__ */ o(
+      h.div,
       {
-        className: h,
+        className: v,
         style: y,
         animate: "animate",
         exit: "exit",
-        variants: T,
+        variants: b,
         initial: "initial",
-        transition: R,
+        transition: T,
         onClick: P
       }
     ) : null,
-    /* @__PURE__ */ o("div", { className: E, children: /* @__PURE__ */ o(
-      k.div,
+    /* @__PURE__ */ o("div", { className: g, children: /* @__PURE__ */ o(
+      h.div,
       {
         onClick: (t) => {
           t.stopPropagation();
         },
         tabIndex: -1,
         role: "dialog",
-        variants: j,
+        variants: E || w,
         animate: "animate",
-        transition: b,
+        transition: j,
         exit: "exit",
         initial: "initial",
         onAnimationComplete: (t) => {
-          t === "animate" && (a == null || a()), t === "exit" && (e == null || e());
+          t === "animate" && (a == null || a()), t === "exit" && (n == null || n());
         },
-        children: s ? /* @__PURE__ */ o("div", { ref: f, children: x(l, u) }) : x(l, u)
+        style: { height: "100%" },
+        children: s ? /* @__PURE__ */ o("div", { ref: f, style: { height: "100%" }, children: x(l, u) }) : x(l, u)
       }
     ) })
   ] }) });
 }
 export {
-  q as Modal
+  z as Modal
 };

package/dist/es/modal/components/modalProvider.mjs

@@ -2,7 +2,7 @@
 import { jsx as m } from "react/jsx-runtime";
 import { useSyncExternalStore as f, createElement as u } from "react";
 import { Modal as a } from "./modal.mjs";
-import { AnimatePresence as S } from "../../node_modules/.pnpm/motion@12.9.2_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/motion/dist/es/framer-motion/dist/es/components/AnimatePresence/index.mjs";
+import { AnimatePresence as S } from "../../node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/components/AnimatePresence/index.mjs";
 function v({
   store: t,
   maskCls: r,