@als-tp/als-react-ts-ui 0.3.1 → 0.4.0

package/dist/als-react-ts-ui259.js

@@ -0,0 +1,51 @@
+import * as p from "react-dom";
+import { useIsoLayoutEffect as r } from "./als-react-ts-ui161.js";
+import { useStableCallback as D } from "./als-react-ts-ui160.js";
+import { getCombinedFieldValidityData as v } from "./als-react-ts-ui315.js";
+import { useFormContext as R } from "./als-react-ts-ui258.js";
+import { useFieldRootContext as b } from "./als-react-ts-ui254.js";
+function S(u) {
+  const {
+    enabled: l = !0,
+    value: a,
+    id: t,
+    name: f,
+    controlRef: d,
+    commit: m
+  } = u, {
+    formRef: n
+  } = R(), {
+    invalid: s,
+    markedDirtyRef: c,
+    validityData: o,
+    setValidityData: V
+  } = b(), i = D(u.getValue);
+  r(() => {
+    if (!l)
+      return;
+    let e = a;
+    e === void 0 && (e = i()), o.initialValue === null && e !== null && V((y) => ({
+      ...y,
+      initialValue: e
+    }));
+  }, [l, V, a, o.initialValue, i]), r(() => {
+    !l || !t || n.current.fields.set(t, {
+      getValue: i,
+      name: f,
+      controlRef: d,
+      validityData: v(o, s),
+      validate() {
+        let e = a;
+        e === void 0 && (e = i()), c.current = !0, p.flushSync(() => m(e));
+      }
+    });
+  }, [m, d, l, n, i, t, s, c, f, o, a]), r(() => {
+    const e = n.current.fields;
+    return () => {
+      t && e.delete(t);
+    };
+  }, [n, t]);
+}
+export {
+  S as useField
+};

package/dist/als-react-ts-ui26.js

@@ -0,0 +1,9 @@
+import { jsx as o } from "react/jsx-runtime";
+import r from "./als-react-ts-ui92.js";
+function e(t) {
+  return /* @__PURE__ */ o("div", { className: r.root });
+}
+export {
+  e as ALSRadio,
+  e as default
+};

package/dist/als-react-ts-ui260.js

@@ -0,0 +1,53 @@
+import { serializeValue as e } from "./als-react-ts-ui314.js";
+function a(n) {
+  return n != null && n.length > 0 && typeof n[0] == "object" && n[0] != null && "items" in n[0];
+}
+function o(n, r) {
+  if (r && n != null)
+    return r(n) ?? "";
+  if (n && typeof n == "object") {
+    if ("label" in n && n.label != null)
+      return String(n.label);
+    if ("value" in n)
+      return String(n.value);
+  }
+  return e(n);
+}
+function t(n, r) {
+  return r && n != null ? r(n) ?? "" : n && typeof n == "object" && "value" in n && "label" in n ? e(n.value) : e(n);
+}
+function y(n, r, f) {
+  if (f && n != null)
+    return f(n);
+  if (n && typeof n == "object" && "label" in n && n.label != null)
+    return n.label;
+  if (r && !Array.isArray(r))
+    return r[n] ?? o(n, f);
+  if (Array.isArray(r)) {
+    const c = a(r) ? r.flatMap((l) => l.items) : r;
+    if (n == null) {
+      const l = c.find((u) => u.value == null);
+      return l && l.label != null ? l.label : o(n, f);
+    }
+    if (typeof n != "object") {
+      const l = c.find((u) => u && u.value === n);
+      return l && l.label != null ? l.label : o(n, f);
+    }
+    if ("value" in n) {
+      const l = c.find((u) => u && u.value === n.value);
+      if (l && l.label != null)
+        return l.label;
+    }
+  }
+  return o(n, f);
+}
+function p(n, r) {
+  return !Array.isArray(n) || n.length === 0 ? "" : n.map((f) => o(f, r)).join(", ");
+}
+export {
+  a as isGroupedItems,
+  p as resolveMultipleLabels,
+  y as resolveSelectedLabel,
+  o as stringifyAsLabel,
+  t as stringifyAsValue
+};

package/dist/als-react-ts-ui261.js

@@ -0,0 +1,20 @@
+const f = (n, e) => Object.is(n, e);
+function u(n, e, r) {
+  return n == null || e == null ? Object.is(n, e) : r(n, e);
+}
+function i(n, e, r) {
+  return !n || n.length === 0 ? !1 : n.some((t) => t === void 0 ? !1 : u(t, e, r));
+}
+function d(n, e, r) {
+  return !n || n.length === 0 ? -1 : n.findIndex((t) => t === void 0 ? !1 : u(t, e, r));
+}
+function s(n, e, r) {
+  return n.filter((t) => !u(t, e, r));
+}
+export {
+  u as compareItemEquality,
+  f as defaultItemEquality,
+  d as findItemIndex,
+  i as itemIncludes,
+  s as removeItem
+};

package/dist/als-react-ts-ui262.js

@@ -0,0 +1,14 @@
+import * as c from "react";
+import { useIsoLayoutEffect as o } from "./als-react-ts-ui161.js";
+import { useStableCallback as f } from "./als-react-ts-ui160.js";
+function u(r, n) {
+  const t = c.useRef(r), e = f(n);
+  o(() => {
+    t.current !== r && e(t.current);
+  }, [r, e]), o(() => {
+    t.current = r;
+  }, [r]);
+}
+export {
+  u as useValueChanged
+};

package/dist/als-react-ts-ui263.js

@@ -0,0 +1,38 @@
+import { isElement as s } from "./als-react-ts-ui221.js";
+import { useId as m } from "./als-react-ts-ui216.js";
+import { useRefWithInit as c } from "./als-react-ts-ui184.js";
+import { useIsoLayoutEffect as a } from "./als-react-ts-ui161.js";
+import { useFloatingParentNodeId as u } from "./als-react-ts-ui286.js";
+import { FloatingRootStore as g } from "./als-react-ts-ui307.js";
+import { PopupTriggerMap as p } from "./als-react-ts-ui244.js";
+function O(o) {
+  const {
+    open: r = !1,
+    onOpenChange: i,
+    elements: e = {}
+  } = o, f = m(), l = u() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const n = e.reference;
+    n && !s(n) && console.error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `context.setPositionReference()`", "instead.");
+  }
+  const t = c(() => new g({
+    open: r,
+    onOpenChange: i,
+    referenceElement: e.reference ?? null,
+    floatingElement: e.floating ?? null,
+    triggerElements: e.triggers ?? new p(),
+    floatingId: f,
+    nested: l,
+    noEmit: o.noEmit || !1
+  })).current;
+  return a(() => {
+    const n = {
+      open: r,
+      floatingId: f
+    };
+    e.reference !== void 0 && (n.referenceElement = e.reference, n.domReferenceElement = s(e.reference) ? e.reference : null), e.floating !== void 0 && (n.floatingElement = e.floating), t.update(n);
+  }, [r, f, e.reference, e.floating, t]), t.context.onOpenChange = i, t.context.nested = l, t.context.noEmit = o.noEmit || !1, t;
+}
+export {
+  O as useFloatingRootContext
+};

package/dist/als-react-ts-ui264.js

@@ -0,0 +1,285 @@
+import * as m from "react";
+import { isHTMLElement as ye } from "./als-react-ts-ui221.js";
+import { useValueAsRef as G } from "./als-react-ts-ui225.js";
+import { useStableCallback as ae } from "./als-react-ts-ui160.js";
+import { useIsoLayoutEffect as A } from "./als-react-ts-ui161.js";
+import { useFloatingParentNodeId as Ve, useFloatingTree as Le } from "./als-react-ts-ui286.js";
+import { createChangeEventDetails as X } from "./als-react-ts-ui167.js";
+import { enqueueFocus as ze } from "./als-react-ts-ui300.js";
+import { ARROW_DOWN as ee, ARROW_LEFT as W, ARROW_RIGHT as _, ARROW_UP as Pe } from "./als-react-ts-ui310.js";
+import { isIndexOutOfListBounds as be, getMinListIndex as fe, getMaxListIndex as Me, createGridCellMap as Ge, isListIndexDisabled as de, getGridNavigatedIndex as We, getGridCellIndexOfCorner as _e, getGridCellIndices as qe, findNonDisabledListIndex as Y } from "./als-react-ts-ui311.js";
+import { getFloatingFocusElement as He, isTypeableCombobox as $e, activeElement as Ce, getDocument as Be, contains as Te, getTarget as Ue } from "./als-react-ts-ui241.js";
+import { stopEvent as S, isVirtualClick as je, isVirtualPointerEvent as Je } from "./als-react-ts-ui180.js";
+import { listNavigation as me, focusOut as Qe } from "./als-react-ts-ui168.js";
+const Xe = "Escape";
+function te(o, p, c) {
+  switch (o) {
+    case "vertical":
+      return p;
+    case "horizontal":
+      return c;
+    default:
+      return p || c;
+  }
+}
+function Z(o, p) {
+  return te(p, o === Pe || o === ee, o === W || o === _);
+}
+function pe(o, p, c) {
+  return te(p, o === ee, c ? o === W : o === _) || o === "Enter" || o === " " || o === "";
+}
+function Ye(o, p, c) {
+  return te(p, c ? o === W : o === _, o === ee);
+}
+function Ze(o, p, c, s) {
+  const g = c ? o === _ : o === W, x = o === Pe;
+  return p === "both" || p === "horizontal" && s && s > 1 ? o === Xe : te(p, g, x);
+}
+function dt(o, p) {
+  const c = "rootStore" in o ? o.rootStore : o, s = c.useState("open"), g = c.useState("floatingElement"), x = c.useState("domReferenceElement"), ge = c.context.dataRef, {
+    listRef: n,
+    activeIndex: y,
+    onNavigate: Se = () => {
+    },
+    enabled: O = !0,
+    selectedIndex: N = null,
+    allowEscape: re = !1,
+    loopFocus: q = !1,
+    nested: b = !1,
+    rtl: E = !1,
+    virtual: f = !1,
+    focusItemOnOpen: M = "auto",
+    focusItemOnHover: ne = !0,
+    openOnArrowKeyDown: oe = !0,
+    disabledIndices: R = void 0,
+    orientation: d = "vertical",
+    parentOrientation: Ie,
+    cols: v = 1,
+    scrollItemIntoView: ve = !0,
+    itemSizes: Fe,
+    dense: Ae = !1,
+    id: Re,
+    externalTree: Ne
+  } = p;
+  process.env.NODE_ENV !== "production" && (re && (q || console.warn("`useListNavigation` looping must be enabled to allow escaping."), f || console.warn("`useListNavigation` must be virtual to allow escaping.")), d === "vertical" && v > 1 && console.warn("In grid list navigation mode (`cols` > 1), the `orientation` should", 'be either "horizontal" or "both".'));
+  const ke = He(g), k = G(ke), H = Ve(), C = Le(Ne);
+  A(() => {
+    ge.current.orientation = d;
+  }, [ge, d]);
+  const ie = $e(x), T = m.useRef(M), r = m.useRef(N ?? -1), P = m.useRef(null), F = m.useRef(!0), l = ae((e) => {
+    Se(r.current === -1 ? null : r.current, e);
+  }), he = m.useRef(l), D = m.useRef(!!g), xe = m.useRef(s), h = m.useRef(!1), $ = m.useRef(!1), ce = G(R), B = G(s), De = G(ve), K = G(N), ue = ae(() => {
+    function e(a) {
+      f ? C?.events.emit("virtualfocus", a) : ze(a, {
+        sync: h.current,
+        preventScroll: !0
+      });
+    }
+    const i = n.current[r.current], t = $.current;
+    i && e(i), (h.current ? (a) => a() : requestAnimationFrame)(() => {
+      const a = n.current[r.current] || i;
+      if (!a)
+        return;
+      i || e(a);
+      const I = De.current;
+      I && // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      se && (t || !F.current) && a.scrollIntoView?.(typeof I == "boolean" ? {
+        block: "nearest",
+        inline: "nearest"
+      } : I);
+    });
+  });
+  A(() => {
+    O && (s && g ? (r.current = N ?? -1, T.current && N != null && ($.current = !0, l())) : D.current && (r.current = -1, he.current()));
+  }, [O, s, g, N, l]), A(() => {
+    if (O) {
+      if (!s) {
+        h.current = !1;
+        return;
+      }
+      if (g)
+        if (y == null) {
+          if (h.current = !1, K.current != null)
+            return;
+          if (D.current && (r.current = -1, ue()), (!xe.current || !D.current) && T.current && (P.current != null || T.current === !0 && P.current == null)) {
+            let e = 0;
+            const i = () => {
+              n.current[0] == null ? (e < 2 && (e ? requestAnimationFrame : queueMicrotask)(i), e += 1) : (r.current = P.current == null || pe(P.current, d, E) || b ? fe(n) : Me(n), P.current = null, l());
+            };
+            i();
+          }
+        } else be(n, y) || (r.current = y, ue(), $.current = !1);
+    }
+  }, [O, s, g, y, K, b, n, d, E, l, ue, ce]), A(() => {
+    if (!O || g || !C || f || !D.current)
+      return;
+    const e = C.nodesRef.current, i = e.find((a) => a.id === H)?.context?.elements.floating, t = Ce(Be(g)), u = e.some((a) => a.context && Te(a.context.elements.floating, t));
+    i && !u && F.current && i.focus({
+      preventScroll: !0
+    });
+  }, [O, g, C, H, f]), A(() => {
+    he.current = l, xe.current = s, D.current = !!g;
+  }), A(() => {
+    s || (P.current = null, T.current = M);
+  }, [s, M]);
+  const Ee = y != null, se = m.useMemo(() => {
+    function e(t) {
+      if (!B.current)
+        return;
+      const u = n.current.indexOf(t.currentTarget);
+      u !== -1 && r.current !== u && (r.current = u, l(t));
+    }
+    return {
+      onFocus(t) {
+        h.current = !0, e(t);
+      },
+      onClick: ({
+        currentTarget: t
+      }) => t.focus({
+        preventScroll: !0
+      }),
+      // Safari
+      onMouseMove(t) {
+        h.current = !0, $.current = !1, ne && e(t);
+      },
+      onPointerLeave(t) {
+        if (!B.current || !F.current || t.pointerType === "touch")
+          return;
+        h.current = !0;
+        const u = t.relatedTarget;
+        !ne || n.current.includes(u) || (r.current = -1, l(t), f || k.current?.focus({
+          preventScroll: !0
+        }));
+      }
+    };
+  }, [B, k, ne, n, l, f]), U = m.useCallback(() => Ie ?? C?.nodesRef.current.find((e) => e.id === H)?.context?.dataRef?.current.orientation, [H, C, Ie]), V = ae((e) => {
+    if (F.current = !1, h.current = !0, e.which === 229 || !B.current && e.currentTarget === k.current)
+      return;
+    if (b && Ze(e.key, d, E, v)) {
+      Z(e.key, U()) || S(e), c.setOpen(!1, X(me, e.nativeEvent)), ye(x) && (f ? C?.events.emit("virtualfocus", x) : x.focus());
+      return;
+    }
+    const i = r.current, t = fe(n, R), u = Me(n, R);
+    if (ie || (e.key === "Home" && (S(e), r.current = t, l(e)), e.key === "End" && (S(e), r.current = u, l(e))), v > 1) {
+      const a = Fe || Array.from({
+        length: n.current.length
+      }, () => ({
+        width: 1,
+        height: 1
+      })), I = Ge(a, v, Ae), L = I.findIndex((w) => w != null && !de(n, w, R)), le = I.reduce((w, z, Ke) => z != null && !de(n, z, R) ? Ke : w, -1), Q = I[We({
+        current: I.map((w) => w != null ? n.current[w] : null)
+      }, {
+        event: e,
+        orientation: d,
+        loopFocus: q,
+        rtl: E,
+        cols: v,
+        // treat undefined (empty grid spaces) as disabled indices so we
+        // don't end up in them
+        disabledIndices: qe([...(typeof R != "function" ? R : null) || n.current.map((w, z) => de(n, z, R) ? z : void 0), void 0], I),
+        minIndex: L,
+        maxIndex: le,
+        prevIndex: _e(
+          r.current > u ? t : r.current,
+          a,
+          I,
+          v,
+          // use a corner matching the edge closest to the direction
+          // we're moving in so we don't end up in the same item. Prefer
+          // top/left over bottom/right.
+          // eslint-disable-next-line no-nested-ternary
+          e.key === ee ? "bl" : e.key === (E ? W : _) ? "tr" : "tl"
+        ),
+        stopEvent: !0
+      })];
+      if (Q != null && (r.current = Q, l(e)), d === "both")
+        return;
+    }
+    if (Z(e.key, d)) {
+      if (S(e), s && !f && Ce(e.currentTarget.ownerDocument) === e.currentTarget) {
+        r.current = pe(e.key, d, E) ? t : u, l(e);
+        return;
+      }
+      pe(e.key, d, E) ? q ? i >= u ? re && i !== n.current.length ? r.current = -1 : (h.current = !1, r.current = t) : r.current = Y(n, {
+        startingIndex: i,
+        disabledIndices: R
+      }) : r.current = Math.min(u, Y(n, {
+        startingIndex: i,
+        disabledIndices: R
+      })) : q ? i <= t ? re && i !== -1 ? r.current = n.current.length : (h.current = !1, r.current = u) : r.current = Y(n, {
+        startingIndex: i,
+        decrement: !0,
+        disabledIndices: R
+      }) : r.current = Math.max(t, Y(n, {
+        startingIndex: i,
+        decrement: !0,
+        disabledIndices: R
+      })), be(n, r.current) && (r.current = -1), l(e);
+    }
+  }), j = m.useMemo(() => f && s && Ee && {
+    "aria-activedescendant": `${Re}-${y}`
+  }, [f, s, Ee, Re, y]), Oe = m.useMemo(() => ({
+    "aria-orientation": d === "both" ? void 0 : d,
+    ...ie ? {} : j,
+    onKeyDown(e) {
+      if (e.key === "Tab" && e.shiftKey && s && !f) {
+        const i = Ue(e.nativeEvent);
+        if (i && !Te(k.current, i))
+          return;
+        S(e), c.setOpen(!1, X(Qe, e.nativeEvent)), ye(x) && x.focus();
+        return;
+      }
+      V(e);
+    },
+    onPointerMove() {
+      F.current = !0;
+    }
+  }), [j, V, k, d, ie, c, s, f, x]), J = m.useMemo(() => {
+    function e(t) {
+      M === "auto" && je(t.nativeEvent) && (T.current = !f);
+    }
+    function i(t) {
+      T.current = M, M === "auto" && Je(t.nativeEvent) && (T.current = !0);
+    }
+    return {
+      onKeyDown(t) {
+        const u = c.select("open");
+        F.current = !1;
+        const a = t.key.startsWith("Arrow"), I = Ye(t.key, U(), E), L = Z(t.key, d), le = (b ? I : L) || t.key === "Enter" || t.key.trim() === "";
+        if (f && u)
+          return V(t);
+        if (!(!u && !oe && a)) {
+          if (le) {
+            const Q = Z(t.key, U());
+            P.current = b && Q ? null : t.key;
+          }
+          if (b) {
+            I && (S(t), u ? (r.current = fe(n, ce.current), l(t)) : c.setOpen(!0, X(me, t.nativeEvent, t.currentTarget)));
+            return;
+          }
+          L && (K.current != null && (r.current = K.current), S(t), !u && oe ? c.setOpen(!0, X(me, t.nativeEvent, t.currentTarget)) : V(t), u && l(t));
+        }
+      },
+      onFocus(t) {
+        c.select("open") && !f && (r.current = -1, l(t));
+      },
+      onPointerDown: i,
+      onPointerEnter: i,
+      onMouseDown: e,
+      onClick: e
+    };
+  }, [V, ce, M, n, b, l, c, oe, d, U, E, K, f]), we = m.useMemo(() => ({
+    ...j,
+    ...J
+  }), [j, J]);
+  return m.useMemo(() => O ? {
+    reference: we,
+    floating: Oe,
+    item: se,
+    trigger: J
+  } : {}, [O, we, Oe, J, se]);
+}
+export {
+  Xe as ESCAPE,
+  dt as useListNavigation
+};

package/dist/als-react-ts-ui265.js

@@ -0,0 +1,56 @@
+import * as o from "react";
+import { useStableCallback as S } from "./als-react-ts-ui160.js";
+import { useIsoLayoutEffect as T } from "./als-react-ts-ui161.js";
+import { useTimeout as D } from "./als-react-ts-ui229.js";
+import { EMPTY_ARRAY as U } from "./als-react-ts-ui212.js";
+import { stopEvent as O } from "./als-react-ts-ui180.js";
+function H(l, b) {
+  const g = "rootStore" in l ? l.rootStore : l, c = g.useState("open"), u = g.context.dataRef, {
+    listRef: E,
+    activeIndex: p,
+    onMatch: A,
+    onTypingChange: R,
+    enabled: h = !0,
+    findMatch: L = null,
+    resetMs: F = 750,
+    ignoreKeys: P = U,
+    selectedIndex: y = null
+  } = b, m = D(), r = o.useRef(""), i = o.useRef(y ?? p ?? -1), f = o.useRef(null);
+  T(() => {
+    c && (m.clear(), f.current = null, r.current = "");
+  }, [c, m]), T(() => {
+    c && r.current === "" && (i.current = y ?? p ?? -1);
+  }, [c, y, p]);
+  const n = S((e) => {
+    e ? u.current.typing || (u.current.typing = e, R?.(e)) : u.current.typing && (u.current.typing = e, R?.(e));
+  }), a = S((e) => {
+    function C(s, x, I) {
+      const K = L ? L(x, I) : x.find((Y) => Y?.toLocaleLowerCase().indexOf(I.toLocaleLowerCase()) === 0);
+      return K ? s.indexOf(K) : -1;
+    }
+    const t = E.current;
+    if (r.current.length > 0 && r.current[0] !== " " && (C(t, t, r.current) === -1 ? n(!1) : e.key === " " && O(e)), t == null || P.includes(e.key) || // Character key.
+    e.key.length !== 1 || // Modifier key.
+    e.ctrlKey || e.metaKey || e.altKey)
+      return;
+    c && e.key !== " " && (O(e), n(!0)), t.every((s) => s ? s[0]?.toLocaleLowerCase() !== s[1]?.toLocaleLowerCase() : !0) && r.current === e.key && (r.current = "", i.current = f.current), r.current += e.key, m.start(F, () => {
+      r.current = "", i.current = f.current, n(!1);
+    });
+    const w = i.current, d = C(t, [...t.slice((w || 0) + 1), ...t.slice(0, (w || 0) + 1)], r.current);
+    d !== -1 ? (A?.(d), f.current = d) : e.key !== " " && (r.current = "", n(!1));
+  }), k = o.useMemo(() => ({
+    onKeyDown: a
+  }), [a]), M = o.useMemo(() => ({
+    onKeyDown: a,
+    onKeyUp(e) {
+      e.key === " " && n(!1);
+    }
+  }), [a, n]);
+  return o.useMemo(() => h ? {
+    reference: k,
+    floating: M
+  } : {}, [h, k, M]);
+}
+export {
+  H as useTypeahead
+};

package/dist/als-react-ts-ui266.js

@@ -0,0 +1,82 @@
+class e {
+  /**
+   * The current state of the store.
+   * This property is updated immediately when the state changes as a result of calling {@link setState}, {@link update}, or {@link set}.
+   * To subscribe to state changes, use the {@link useState} method. The value returned by {@link useState} is updated after the component renders (similarly to React's useState).
+   * The values can be used directly (to avoid subscribing to the store) in effects or event handlers.
+   *
+   * Do not modify properties in state directly. Instead, use the provided methods to ensure proper state management and listener notification.
+   */
+  // Internal state to handle recursive `setState()` calls
+  constructor(t) {
+    this.state = t, this.listeners = /* @__PURE__ */ new Set(), this.updateTick = 0;
+  }
+  /**
+   * Registers a listener that will be called whenever the store's state changes.
+   *
+   * @param fn The listener function to be called on state changes.
+   * @returns A function to unsubscribe the listener.
+   */
+  subscribe = (t) => (this.listeners.add(t), () => {
+    this.listeners.delete(t);
+  });
+  /**
+   * Returns the current state of the store.
+   */
+  getSnapshot = () => this.state;
+  /**
+   * Updates the entire store's state and notifies all registered listeners.
+   *
+   * @param newState The new state to set for the store.
+   */
+  setState(t) {
+    if (this.state === t)
+      return;
+    this.state = t, this.updateTick += 1;
+    const s = this.updateTick;
+    for (const i of this.listeners) {
+      if (s !== this.updateTick)
+        return;
+      i(t);
+    }
+  }
+  /**
+   * Merges the provided changes into the current state and notifies listeners if there are changes.
+   *
+   * @param changes An object containing the changes to apply to the current state.
+   */
+  update(t) {
+    for (const s in t)
+      if (!Object.is(this.state[s], t[s])) {
+        e.prototype.setState.call(this, {
+          ...this.state,
+          ...t
+        });
+        return;
+      }
+  }
+  /**
+   * Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.
+   *
+   * @param key The key in the store's state to update.
+   * @param value The new value to set for the specified key.
+   */
+  set(t, s) {
+    Object.is(this.state[t], s) || e.prototype.setState.call(this, {
+      ...this.state,
+      [t]: s
+    });
+  }
+  /**
+   * Gives the state a new reference and updates all registered listeners.
+   */
+  notifyAll() {
+    const t = {
+      ...this.state
+    };
+    e.prototype.setState.call(this, t);
+  }
+}
+export {
+  e as Store
+};

package/dist/als-react-ts-ui267.js

@@ -0,0 +1,8 @@
+import { w as S } from "./als-react-ts-ui345.js";
+function h(t, e, r, o, s) {
+  const n = (c) => e(c, r, o, s);
+  return S.useSyncExternalStoreWithSelector(t.subscribe, t.getSnapshot, t.getSnapshot, n);
+}
+export {
+  h as useStore
+};

package/dist/als-react-ts-ui268.js

@@ -0,0 +1,6 @@
+function e(n) {
+  return n?.ownerDocument || document;
+}
+export {
+  e as ownerDocument
+};

package/dist/als-react-ts-ui269.js

@@ -0,0 +1,26 @@
+import { FieldControlDataAttributes as a } from "./als-react-ts-ui316.js";
+const e = {
+  badInput: !1,
+  customError: !1,
+  patternMismatch: !1,
+  rangeOverflow: !1,
+  rangeUnderflow: !1,
+  stepMismatch: !1,
+  tooLong: !1,
+  tooShort: !1,
+  typeMismatch: !1,
+  valid: null,
+  valueMissing: !1
+}, r = {
+  valid(l) {
+    return l === null ? null : l ? {
+      [a.valid]: ""
+    } : {
+      [a.invalid]: ""
+    };
+  }
+};
+export {
+  e as DEFAULT_VALIDITY_STATE,
+  r as fieldValidityMapping
+};

package/dist/als-react-ts-ui27.js

@@ -0,0 +1,9 @@
+import { jsx as r } from "react/jsx-runtime";
+import o from "./als-react-ts-ui93.js";
+function a(t) {
+  return /* @__PURE__ */ r("div", { className: o.root });
+}
+export {
+  a as ALSScrollArea,
+  a as default
+};