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

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

@@ -0,0 +1,187 @@
+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 {
+  $t as ScrollAreaViewport
+};

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

@@ -0,0 +1,39 @@
+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 {
+  u as ScrollAreaContent
+};

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

@@ -0,0 +1,126 @@
+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 {
+  K as ScrollAreaScrollbar
+};

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

@@ -0,0 +1,18 @@
+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 {
+  c as ALSScrollArea
+};

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

@@ -0,0 +1,47 @@
+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 {
+  v as ScrollAreaThumb
+};

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

@@ -0,0 +1,30 @@
+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 {
+  d as ScrollAreaCorner
+};

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

@@ -0,0 +1,42 @@
+const r = "_trigger_r1z8h_6", _ = "_positioner_r1z8h_40", t = "_popup_r1z8h_45", o = "_arrow_r1z8h_96", p = "_arrowFill_r1z8h_121", e = "_arrowOuterStroke_r1z8h_125", i = "_arrowInnerStroke_r1z8h_129", n = "_image_r1z8h_134", s = "_title_r1z8h_155", c = "_description_r1z8h_176", h = "_content_r1z8h_198", a = {
+  trigger: r,
+  positioner: _,
+  popup: t,
+  "popup--default": "_popup--default_r1z8h_66",
+  "popup--compact": "_popup--compact_r1z8h_70",
+  "popup--rich": "_popup--rich_r1z8h_75",
+  "popup--sm": "_popup--sm_r1z8h_83",
+  "popup--md": "_popup--md_r1z8h_87",
+  "popup--lg": "_popup--lg_r1z8h_91",
+  arrow: o,
+  arrowFill: p,
+  arrowOuterStroke: e,
+  arrowInnerStroke: i,
+  image: n,
+  "image--sm": "_image--sm_r1z8h_142",
+  "image--md": "_image--md_r1z8h_146",
+  "image--lg": "_image--lg_r1z8h_150",
+  title: s,
+  "title--sm": "_title--sm_r1z8h_163",
+  "title--md": "_title--md_r1z8h_167",
+  "title--lg": "_title--lg_r1z8h_171",
+  description: c,
+  "description--sm": "_description--sm_r1z8h_185",
+  "description--md": "_description--md_r1z8h_189",
+  "description--lg": "_description--lg_r1z8h_193",
+  content: h
+};
+export {
+  o as arrow,
+  p as arrowFill,
+  i as arrowInnerStroke,
+  e as arrowOuterStroke,
+  h as content,
+  a as default,
+  c as description,
+  n as image,
+  t as popup,
+  _ as positioner,
+  s as title,
+  r as trigger
+};

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

@@ -0,0 +1,38 @@
+import * as t from "react";
+import { useIsoLayoutEffect as f } from "./als-react-ts-ui193.js";
+import { usePreviewCardRootContext as c } from "./als-react-ts-ui532.js";
+import { triggerOpenStateMapping as l } from "./als-react-ts-ui244.js";
+import { useRenderElement as d } from "./als-react-ts-ui189.js";
+const u = /* @__PURE__ */ t.forwardRef(function(e, o) {
+  const {
+    render: v,
+    className: y,
+    delay: s,
+    closeDelay: i,
+    ...a
+  } = e, {
+    open: r,
+    triggerProps: n,
+    setTriggerElement: m,
+    writeDelayRefs: p
+  } = c();
+  f(() => {
+    p({
+      delay: s,
+      closeDelay: i
+    });
+  });
+  const g = t.useMemo(() => ({
+    open: r
+  }), [r]);
+  return d("a", e, {
+    ref: [m, o],
+    state: g,
+    props: [n, a],
+    stateAttributesMapping: l
+  });
+});
+process.env.NODE_ENV !== "production" && (u.displayName = "PreviewCardTrigger");
+export {
+  u as PreviewCardTrigger
+};

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

@@ -0,0 +1,83 @@
+import * as r from "react";
+import { usePreviewCardRootContext as A } from "./als-react-ts-ui532.js";
+import { PreviewCardPositionerContext as E } from "./als-react-ts-ui536.js";
+import { useAnchorPositioning as N } from "./als-react-ts-ui364.js";
+import { popupStateMapping as b } from "./als-react-ts-ui244.js";
+import { usePreviewCardPortalContext as U } from "./als-react-ts-ui535.js";
+import { POPUP_COLLISION_AVOIDANCE as k } from "./als-react-ts-ui260.js";
+import { useRenderElement as H } from "./als-react-ts-ui189.js";
+import { jsx as I } from "react/jsx-runtime";
+const V = /* @__PURE__ */ r.forwardRef(function(i, s) {
+  const {
+    render: D,
+    className: L,
+    anchor: a,
+    positionMethod: d = "absolute",
+    side: l = "bottom",
+    align: c = "center",
+    sideOffset: p = 0,
+    alignOffset: m = 0,
+    collisionBoundary: f = "clipping-ancestors",
+    collisionPadding: u = 5,
+    arrowPadding: P = 5,
+    sticky: g = !1,
+    disableAnchorTracking: w = !1,
+    collisionAvoidance: v = k,
+    ...C
+  } = i, {
+    open: o,
+    mounted: t,
+    floatingRootContext: h,
+    setPositionerElement: y
+  } = A(), R = U(), e = N({
+    anchor: a,
+    floatingRootContext: h,
+    positionMethod: d,
+    mounted: t,
+    side: l,
+    sideOffset: p,
+    align: c,
+    alignOffset: m,
+    arrowPadding: P,
+    collisionBoundary: f,
+    collisionPadding: u,
+    sticky: g,
+    disableAnchorTracking: w,
+    keepMounted: R,
+    collisionAvoidance: v
+  }), S = r.useMemo(() => {
+    const n = {};
+    return o || (n.pointerEvents = "none"), {
+      role: "presentation",
+      hidden: !t,
+      style: {
+        ...e.positionerStyles,
+        ...n
+      }
+    };
+  }, [o, t, e.positionerStyles]), x = r.useMemo(() => ({
+    open: o,
+    side: e.side,
+    align: e.align,
+    anchorHidden: e.anchorHidden
+  }), [o, e.side, e.align, e.anchorHidden]), M = r.useMemo(() => ({
+    side: e.side,
+    align: e.align,
+    arrowRef: e.arrowRef,
+    arrowUncentered: e.arrowUncentered,
+    arrowStyles: e.arrowStyles
+  }), [e.side, e.align, e.arrowRef, e.arrowUncentered, e.arrowStyles]), O = H("div", i, {
+    state: x,
+    ref: [y, s],
+    props: [S, C],
+    stateAttributesMapping: b
+  });
+  return /* @__PURE__ */ I(E.Provider, {
+    value: M,
+    children: O
+  });
+});
+process.env.NODE_ENV !== "production" && (V.displayName = "PreviewCardPositioner");
+export {
+  V as PreviewCardPositioner
+};

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

@@ -0,0 +1,50 @@
+import * as i from "react";
+import { usePreviewCardRootContext as d } from "./als-react-ts-ui532.js";
+import { usePreviewCardPositionerContext as l } from "./als-react-ts-ui536.js";
+import { popupStateMapping as C } from "./als-react-ts-ui244.js";
+import { transitionStatusMapping as c } from "./als-react-ts-ui245.js";
+import { useOpenChangeComplete as P } from "./als-react-ts-ui253.js";
+import { useRenderElement as g } from "./als-react-ts-ui189.js";
+import { getDisabledMountTransitionStyles as v } from "./als-react-ts-ui366.js";
+const w = {
+  ...C,
+  ...c
+}, M = /* @__PURE__ */ i.forwardRef(function(o, s) {
+  const {
+    className: N,
+    render: S,
+    ...a
+  } = o, {
+    open: e,
+    transitionStatus: t,
+    popupRef: r,
+    onOpenChangeComplete: m,
+    popupProps: u
+  } = d(), {
+    side: p,
+    align: n
+  } = l();
+  P({
+    open: e,
+    ref: r,
+    onComplete() {
+      e && m?.(!0);
+    }
+  });
+  const f = i.useMemo(() => ({
+    open: e,
+    side: p,
+    align: n,
+    transitionStatus: t
+  }), [e, p, n, t]);
+  return g("div", o, {
+    ref: [r, s],
+    state: f,
+    props: [u, v(t), a],
+    stateAttributesMapping: w
+  });
+});
+process.env.NODE_ENV !== "production" && (M.displayName = "PreviewCardPopup");
+export {
+  M as PreviewCardPopup
+};