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

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

@@ -1,8 +1,187 @@
-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);
+import * as E from "react";
+import * as Rt from "react-dom";
+import { useStableCallback as Mt } from "./als-react-ts-ui192.js";
+import { useIsoLayoutEffect as C } from "./als-react-ts-ui193.js";
+import { isWebKit as Tt } from "./als-react-ts-ui371.js";
+import { useTimeout as tt } from "./als-react-ts-ui195.js";
+import { useScrollAreaRootContext as Nt } from "./als-react-ts-ui539.js";
+import { ScrollAreaViewportContext as Vt } from "./als-react-ts-ui545.js";
+import { useRenderElement as Wt } from "./als-react-ts-ui189.js";
+import { useDirection as Ct } from "./als-react-ts-ui285.js";
+import { getOffset as O } from "./als-react-ts-ui542.js";
+import { MIN_THUMB_SIZE as rt } from "./als-react-ts-ui541.js";
+import { clamp as a } from "./als-react-ts-ui519.js";
+import { styleDisableScrollbar as Pt } from "./als-react-ts-ui415.js";
+import { onVisible as Lt } from "./als-react-ts-ui546.js";
+import { scrollAreaStateAttributesMapping as It } from "./als-react-ts-ui544.js";
+import { ScrollAreaViewportCssVars as d } from "./als-react-ts-ui547.js";
+import { jsx as Dt } from "react/jsx-runtime";
+let et = !1;
+function Ft() {
+  et || // When `inherits: false`, specifying `inherit` on child elements doesn't work
+  // in Safari. To let CSS features work correctly, this optimization must be skipped.
+  Tt || (typeof CSS < "u" && "registerProperty" in CSS && [d.scrollAreaOverflowXStart, d.scrollAreaOverflowXEnd, d.scrollAreaOverflowYStart, d.scrollAreaOverflowYEnd].forEach((P) => {
+    try {
+      CSS.registerProperty({
+        name: P,
+        syntax: "<length>",
+        inherits: !1,
+        initialValue: "0px"
+      });
+    } catch {
+    }
+  }), et = !0);
 }
+const $t = /* @__PURE__ */ E.forwardRef(function(L, ot) {
+  const {
+    render: _t,
+    className: kt,
+    ...nt
+  } = L, {
+    viewportRef: e,
+    scrollbarYRef: st,
+    scrollbarXRef: lt,
+    thumbYRef: ct,
+    thumbXRef: it,
+    cornerRef: at,
+    setCornerSize: I,
+    setThumbSize: ft,
+    rootId: D,
+    setHiddenState: dt,
+    hiddenState: l,
+    handleScroll: mt,
+    setHovering: F,
+    setOverflowEdges: ut,
+    overflowEdges: m,
+    overflowEdgeThreshold: g
+  } = Nt(), X = Ct(), Y = E.useRef(!0), ht = tt(), A = tt();
+  function pt() {
+    const r = e.current, c = st.current, f = lt.current, R = ct.current, M = it.current, Et = at.current;
+    if (!r)
+      return;
+    const h = r.scrollHeight, p = r.scrollWidth, S = r.clientHeight, b = r.clientWidth, $ = r.scrollTop, T = r.scrollLeft;
+    if (h === 0 || p === 0)
+      return;
+    const s = S >= h, i = b >= p, gt = b / p, vt = S / h, x = Math.max(0, p - b), v = Math.max(0, h - S);
+    let H = 0, _ = 0;
+    i || (X === "rtl" ? H = a(-T, 0, x) : H = a(T, 0, x), _ = x - H);
+    const k = s ? 0 : a($, 0, v), Ht = s ? 0 : v - k, yt = i ? 0 : b, Ot = s ? 0 : S, z = O(f, "padding", "x"), K = O(c, "padding", "y"), U = O(M, "margin", "x"), j = O(R, "margin", "y"), q = yt - z - U, B = Ot - K - j, Xt = f ? Math.min(f.offsetWidth, q) : q, Yt = c ? Math.min(c.offsetHeight, B) : B, N = Math.max(rt, Xt * gt), V = Math.max(rt, Yt * vt);
+    if (ft((t) => t.height === V && t.width === N ? t : {
+      width: N,
+      height: V
+    }), c && R) {
+      const t = c.offsetHeight - V - K - j, o = h - S, y = o === 0 ? 0 : $ / o, W = Math.min(t, Math.max(0, y * t));
+      R.style.transform = `translate3d(0,${W}px,0)`;
+    }
+    if (f && M) {
+      const t = f.offsetWidth - N - z - U, o = p - b, y = o === 0 ? 0 : T / o, W = X === "rtl" ? a(y * t, -t, 0) : a(y * t, 0, t);
+      M.style.transform = `translate3d(${W}px,0,0)`;
+    }
+    const Z = a(H, 0, x), G = a(_, 0, x), J = a(k, 0, v), Q = a(Ht, 0, v), At = [[d.scrollAreaOverflowXStart, Z], [d.scrollAreaOverflowXEnd, G], [d.scrollAreaOverflowYStart, J], [d.scrollAreaOverflowYEnd, Q]];
+    for (const [t, o] of At)
+      r.style.setProperty(t, `${o}px`);
+    if (Et) {
+      if (i || s)
+        I({
+          width: 0,
+          height: 0
+        });
+      else if (!i && !s) {
+        const t = c?.offsetWidth || 0, o = f?.offsetHeight || 0;
+        I({
+          width: t,
+          height: o
+        });
+      }
+    }
+    dt((t) => {
+      const o = s || i;
+      return t.scrollbarYHidden === s && t.scrollbarXHidden === i && t.cornerHidden === o ? t : {
+        scrollbarYHidden: s,
+        scrollbarXHidden: i,
+        cornerHidden: o
+      };
+    });
+    const w = {
+      xStart: !i && Z > g.xStart,
+      xEnd: !i && G > g.xEnd,
+      yStart: !s && J > g.yStart,
+      yEnd: !s && Q > g.yEnd
+    };
+    ut((t) => t.xStart === w.xStart && t.xEnd === w.xEnd && t.yStart === w.yStart && t.yEnd === w.yEnd ? t : w);
+  }
+  const n = Mt(() => {
+    Rt.flushSync(pt);
+  });
+  C(() => e.current ? (Ft(), Lt(e.current, n)) : void 0, [n, e]), C(() => {
+    queueMicrotask(n);
+  }, [n, l, X]), C(() => {
+    e.current?.matches(":hover") && F(!0);
+  }, [e, F]), E.useEffect(() => {
+    const r = e.current;
+    if (typeof ResizeObserver > "u" || !r)
+      return;
+    const c = new ResizeObserver(n);
+    return c.observe(r), A.start(0, () => {
+      Promise.all(r.getAnimations({
+        subtree: !0
+      }).map((f) => f.finished)).then(n).catch(() => {
+      });
+    }), () => {
+      c.disconnect(), A.clear();
+    };
+  }, [n, e, A]);
+  function u() {
+    Y.current = !1;
+  }
+  const St = {
+    role: "presentation",
+    ...D && {
+      "data-id": `${D}-viewport`
+    },
+    // https://accessibilityinsights.io/info-examples/web/scrollable-region-focusable/
+    ...(!l.scrollbarXHidden || !l.scrollbarYHidden) && {
+      tabIndex: 0
+    },
+    className: Pt.className,
+    style: {
+      overflow: "scroll"
+    },
+    onScroll() {
+      e.current && (n(), Y.current || mt({
+        x: e.current.scrollLeft,
+        y: e.current.scrollTop
+      }), ht.start(100, () => {
+        Y.current = !0;
+      }));
+    },
+    onWheel: u,
+    onTouchMove: u,
+    onPointerMove: u,
+    onPointerEnter: u,
+    onKeyDown: u
+  }, bt = E.useMemo(() => ({
+    hasOverflowX: !l.scrollbarXHidden,
+    hasOverflowY: !l.scrollbarYHidden,
+    overflowXStart: m.xStart,
+    overflowXEnd: m.xEnd,
+    overflowYStart: m.yStart,
+    overflowYEnd: m.yEnd,
+    cornerHidden: l.cornerHidden
+  }), [l.scrollbarXHidden, l.scrollbarYHidden, l.cornerHidden, m]), xt = Wt("div", L, {
+    ref: [ot, e],
+    state: bt,
+    props: [St, nt],
+    stateAttributesMapping: It
+  }), wt = E.useMemo(() => ({
+    computeThumbPosition: n
+  }), [n]);
+  return /* @__PURE__ */ Dt(Vt.Provider, {
+    value: wt,
+    children: xt
+  });
+});
+process.env.NODE_ENV !== "production" && ($t.displayName = "ScrollAreaViewport");
 export {
-  h as useStore
+  $t as ScrollAreaViewport
 };

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

@@ -1,6 +1,39 @@
-function e(n) {
-  return n?.ownerDocument || document;
-}
+import * as n from "react";
+import { useIsoLayoutEffect as a } from "./als-react-ts-ui193.js";
+import { useScrollAreaViewportContext as l } from "./als-react-ts-ui545.js";
+import { useRenderElement as p } from "./als-react-ts-ui189.js";
+import { useScrollAreaRootContext as f } from "./als-react-ts-ui539.js";
+import { scrollAreaStateAttributesMapping as m } from "./als-react-ts-ui544.js";
+const u = /* @__PURE__ */ n.forwardRef(function(t, s) {
+  const {
+    render: A,
+    className: R,
+    ...i
+  } = t, e = n.useRef(null), {
+    computeThumbPosition: r
+  } = l(), {
+    viewportState: c
+  } = f();
+  return a(() => {
+    if (typeof ResizeObserver > "u")
+      return;
+    const o = new ResizeObserver(r);
+    return e.current && o.observe(e.current), () => {
+      o.disconnect();
+    };
+  }, [r]), p("div", t, {
+    ref: [s, e],
+    state: c,
+    stateAttributesMapping: m,
+    props: [{
+      role: "presentation",
+      style: {
+        minWidth: "fit-content"
+      }
+    }, i]
+  });
+});
+process.env.NODE_ENV !== "production" && (u.displayName = "ScrollAreaContent");
 export {
-  e as ownerDocument
+  u as ScrollAreaContent
 };

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

@@ -1,26 +1,126 @@
-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]: ""
+import * as h from "react";
+import { useScrollAreaRootContext as I } from "./als-react-ts-ui539.js";
+import { ScrollAreaScrollbarContext as N } from "./als-react-ts-ui548.js";
+import { useRenderElement as V } from "./als-react-ts-ui189.js";
+import { getOffset as m } from "./als-react-ts-ui542.js";
+import { ScrollAreaRootCssVars as x } from "./als-react-ts-ui540.js";
+import { ScrollAreaScrollbarCssVars as W } from "./als-react-ts-ui549.js";
+import { useDirection as U } from "./als-react-ts-ui285.js";
+import { scrollAreaStateAttributesMapping as B } from "./als-react-ts-ui544.js";
+import { jsx as j } from "react/jsx-runtime";
+const K = /* @__PURE__ */ h.forwardRef(function(R, C) {
+  const {
+    render: q,
+    className: F,
+    orientation: t = "vertical",
+    keepMounted: O = !1,
+    ...T
+  } = R, {
+    hovering: Y,
+    scrollingX: H,
+    scrollingY: X,
+    hiddenState: a,
+    overflowEdges: f,
+    scrollbarYRef: c,
+    scrollbarXRef: i,
+    viewportRef: o,
+    thumbYRef: p,
+    thumbXRef: b,
+    handlePointerDown: L,
+    handlePointerUp: y,
+    rootId: A,
+    thumbSize: E
+  } = I(), k = h.useMemo(() => ({
+    hovering: Y,
+    scrolling: {
+      horizontal: H,
+      vertical: X
+    }[t],
+    orientation: t,
+    hasOverflowX: !a.scrollbarXHidden,
+    hasOverflowY: !a.scrollbarYHidden,
+    overflowXStart: f.xStart,
+    overflowXEnd: f.xEnd,
+    overflowYStart: f.yStart,
+    overflowYEnd: f.yEnd,
+    cornerHidden: a.cornerHidden
+  }), [Y, H, X, t, a, f]), D = U();
+  h.useEffect(() => {
+    const r = o.current, l = t === "vertical" ? c.current : i.current;
+    if (!l)
+      return;
+    function n(e) {
+      if (!(!r || !l || e.ctrlKey)) {
+        if (e.preventDefault(), t === "vertical") {
+          if (r.scrollTop === 0 && e.deltaY < 0)
+            return;
+        } else if (r.scrollLeft === 0 && e.deltaX < 0)
+          return;
+        if (t === "vertical") {
+          if (r.scrollTop === r.scrollHeight - r.clientHeight && e.deltaY > 0)
+            return;
+        } else if (r.scrollLeft === r.scrollWidth - r.clientWidth && e.deltaX > 0)
+          return;
+        t === "vertical" ? r.scrollTop += e.deltaY : r.scrollLeft += e.deltaX;
+      }
+    }
+    return l.addEventListener("wheel", n, {
+      passive: !1
+    }), () => {
+      l.removeEventListener("wheel", n);
     };
-  }
-};
+  }, [t, i, c, o]);
+  const M = {
+    ...A && {
+      "data-id": `${A}-scrollbar`
+    },
+    onPointerDown(r) {
+      if (r.button === 0 && r.currentTarget === r.target && o.current) {
+        if (p.current && c.current && t === "vertical") {
+          const l = m(p.current, "margin", "y"), n = m(c.current, "padding", "y"), e = p.current.offsetHeight, g = c.current.getBoundingClientRect(), S = r.clientY - g.top - e / 2 - n + l / 2, u = o.current.scrollHeight, d = o.current.clientHeight, v = c.current.offsetHeight - e - n - l, s = S / v * (u - d);
+          o.current.scrollTop = s;
+        }
+        if (b.current && i.current && t === "horizontal") {
+          const l = m(b.current, "margin", "x"), n = m(i.current, "padding", "x"), e = b.current.offsetWidth, g = i.current.getBoundingClientRect(), S = r.clientX - g.left - e / 2 - n + l / 2, u = o.current.scrollWidth, d = o.current.clientWidth, v = i.current.offsetWidth - e - n - l, w = S / v;
+          let s;
+          D === "rtl" ? (s = (1 - w) * (u - d), o.current.scrollLeft <= 0 && (s = -s)) : s = w * (u - d), o.current.scrollLeft = s;
+        }
+        L(r);
+      }
+    },
+    onPointerUp: y,
+    style: {
+      position: "absolute",
+      touchAction: "none",
+      WebkitUserSelect: "none",
+      userSelect: "none",
+      ...t === "vertical" && {
+        top: 0,
+        bottom: `var(${x.scrollAreaCornerHeight})`,
+        insetInlineEnd: 0,
+        [W.scrollAreaThumbHeight]: `${E.height}px`
+      },
+      ...t === "horizontal" && {
+        insetInlineStart: 0,
+        insetInlineEnd: `var(${x.scrollAreaCornerWidth})`,
+        bottom: 0,
+        [W.scrollAreaThumbWidth]: `${E.width}px`
+      }
+    }
+  }, P = V("div", R, {
+    ref: [C, t === "vertical" ? c : i],
+    state: k,
+    props: [M, T],
+    stateAttributesMapping: B
+  }), $ = h.useMemo(() => ({
+    orientation: t
+  }), [t]), z = t === "vertical" ? a.scrollbarYHidden : a.scrollbarXHidden;
+  return O || !z ? /* @__PURE__ */ j(N.Provider, {
+    value: $,
+    children: P
+  }) : null;
+});
+process.env.NODE_ENV !== "production" && (K.displayName = "ScrollAreaScrollbar");
 export {
-  e as DEFAULT_VALIDITY_STATE,
-  r as fieldValidityMapping
+  K as ScrollAreaScrollbar
 };

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

@@ -1,9 +1,18 @@
-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 });
-}
+import { ALSScrollAreaCorner as r, ALSScrollAreaThumb as o, ALSScrollAreaScrollbar as l, ALSScrollAreaContent as S, ALSScrollAreaViewport as e, ALSScrollAreaRoot as A } from "./als-react-ts-ui93.js";
+const c = {
+  /** Root container for the scroll area */
+  Root: A,
+  /** Scrollable viewport container */
+  Viewport: e,
+  /** Content wrapper inside the viewport */
+  Content: S,
+  /** Scrollbar track (vertical or horizontal) */
+  Scrollbar: l,
+  /** Draggable scrollbar thumb */
+  Thumb: o,
+  /** Corner element for both scrollbars */
+  Corner: r
+};
 export {
-  a as ALSScrollArea,
-  a as default
+  c as ALSScrollArea
 };

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

@@ -1,18 +1,47 @@
-function l(e) {
-  const t = e.getBoundingClientRect();
-  if (process.env.NODE_ENV === "test")
-    return t;
-  const o = window.getComputedStyle(e, "::before"), n = window.getComputedStyle(e, "::after");
-  if (!(o.content !== "none" || n.content !== "none"))
-    return t;
-  const i = parseFloat(o.width) || 0, r = parseFloat(o.height) || 0, a = parseFloat(n.width) || 0, c = parseFloat(n.height) || 0, d = Math.max(t.width, i, a), f = Math.max(t.height, r, c), s = d - t.width, h = f - t.height;
-  return {
-    left: t.left - s / 2,
-    right: t.right + s / 2,
-    top: t.top - h / 2,
-    bottom: t.bottom + h / 2
-  };
-}
+import * as o from "react";
+import { useScrollAreaRootContext as d } from "./als-react-ts-ui539.js";
+import { useScrollAreaScrollbarContext as S } from "./als-react-ts-ui548.js";
+import { ScrollAreaScrollbarCssVars as t } from "./als-react-ts-ui549.js";
+import { useRenderElement as b } from "./als-react-ts-ui189.js";
+const v = /* @__PURE__ */ o.forwardRef(function(r, l) {
+  const {
+    render: P,
+    className: R,
+    ...n
+  } = r, {
+    thumbYRef: a,
+    thumbXRef: i,
+    handlePointerDown: s,
+    handlePointerMove: c,
+    handlePointerUp: m,
+    setScrollingX: h,
+    setScrollingY: f
+  } = d(), {
+    orientation: e
+  } = S(), u = o.useMemo(() => ({
+    orientation: e
+  }), [e]);
+  return b("div", r, {
+    ref: [l, e === "vertical" ? a : i],
+    state: u,
+    props: [{
+      onPointerDown: s,
+      onPointerMove: c,
+      onPointerUp(p) {
+        e === "vertical" && f(!1), e === "horizontal" && h(!1), m(p);
+      },
+      style: {
+        ...e === "vertical" && {
+          height: `var(${t.scrollAreaThumbHeight})`
+        },
+        ...e === "horizontal" && {
+          width: `var(${t.scrollAreaThumbWidth})`
+        }
+      }
+    }, n]
+  });
+});
+process.env.NODE_ENV !== "production" && (v.displayName = "ScrollAreaThumb");
 export {
-  l as getPseudoElementBounds
+  v as ScrollAreaThumb
 };

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

@@ -1,6 +1,30 @@
-import * as e from "react";
-const t = /* @__PURE__ */ e.createContext(void 0);
-process.env.NODE_ENV !== "production" && (t.displayName = "SelectPortalContext");
+import * as s from "react";
+import { useScrollAreaRootContext as c } from "./als-react-ts-ui539.js";
+import { useRenderElement as a } from "./als-react-ts-ui189.js";
+const d = /* @__PURE__ */ s.forwardRef(function(e, o) {
+  const {
+    render: f,
+    className: p,
+    ...t
+  } = e, {
+    cornerRef: n,
+    cornerSize: r,
+    hiddenState: i
+  } = c(), l = a("div", e, {
+    ref: [o, n],
+    props: [{
+      style: {
+        position: "absolute",
+        bottom: 0,
+        insetInlineEnd: 0,
+        width: r.width,
+        height: r.height
+      }
+    }, t]
+  });
+  return i.cornerHidden ? null : l;
+});
+process.env.NODE_ENV !== "production" && (d.displayName = "ScrollAreaCorner");
 export {
-  t as SelectPortalContext
+  d as ScrollAreaCorner
 };