@a-ui/react 7.13.0-beta.5 → 7.13.0-beta.7

package/es/index176.mjs

@@ -1,10 +1,393 @@
-import { getDefaultOptions as m } from "./index156.mjs";
-import { addDays as d } from "./index135.mjs";
-import { toDate as l } from "./index149.mjs";
-function u(s, t, e) {
-  const r = m(), c = e?.weekStartsOn ?? e?.locale?.options?.weekStartsOn ?? r.weekStartsOn ?? r.locale?.options?.weekStartsOn ?? 0, o = l(s, e?.in), a = o.getDay(), i = (t % 7 + 7) % 7, n = 7 - c, f = t < 0 || t > 6 ? t - (a + n) % 7 : (i + n) % 7 - (a + n) % 7;
-  return d(o, f, e);
+import { evaluate as $, getPaddingObject as H, getAlignmentAxis as I, getAlignment as X, getSide as _, getSideAxis as M, getOppositePlacement as q, getExpandedPlacements as G, getOppositeAxisPlacements as J, getAlignmentSides as K, clamp as B, getAxisLength as N, min as Y, rectToClientRect as W, getOppositeAxis as Q } from "./index177.mjs";
+function z(a, s, m) {
+  let {
+    reference: n,
+    floating: r
+  } = a;
+  const e = M(s), i = I(s), l = N(i), d = _(s), g = e === "y", x = n.x + n.width / 2 - r.width / 2, c = n.y + n.height / 2 - r.height / 2, f = n[l] / 2 - r[l] / 2;
+  let t;
+  switch (d) {
+    case "top":
+      t = {
+        x,
+        y: n.y - r.height
+      };
+      break;
+    case "bottom":
+      t = {
+        x,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      t = {
+        x: n.x + n.width,
+        y: c
+      };
+      break;
+    case "left":
+      t = {
+        x: n.x - r.width,
+        y: c
+      };
+      break;
+    default:
+      t = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (X(s)) {
+    case "start":
+      t[i] -= f * (m && g ? -1 : 1);
+      break;
+    case "end":
+      t[i] += f * (m && g ? -1 : 1);
+      break;
+  }
+  return t;
 }
+async function Z(a, s) {
+  var m;
+  s === void 0 && (s = {});
+  const {
+    x: n,
+    y: r,
+    platform: e,
+    rects: i,
+    elements: l,
+    strategy: d
+  } = a, {
+    boundary: g = "clippingAncestors",
+    rootBoundary: x = "viewport",
+    elementContext: c = "floating",
+    altBoundary: f = !1,
+    padding: t = 0
+  } = $(s, a), o = H(t), v = l[f ? c === "floating" ? "reference" : "floating" : c], w = W(await e.getClippingRect({
+    element: (m = await (e.isElement == null ? void 0 : e.isElement(v))) == null || m ? v : v.contextElement || await (e.getDocumentElement == null ? void 0 : e.getDocumentElement(l.floating)),
+    boundary: g,
+    rootBoundary: x,
+    strategy: d
+  })), y = c === "floating" ? {
+    x: n,
+    y: r,
+    width: i.floating.width,
+    height: i.floating.height
+  } : i.reference, p = await (e.getOffsetParent == null ? void 0 : e.getOffsetParent(l.floating)), h = await (e.isElement == null ? void 0 : e.isElement(p)) ? await (e.getScale == null ? void 0 : e.getScale(p)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, P = W(e.convertOffsetParentRelativeRectToViewportRelativeRect ? await e.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: l,
+    rect: y,
+    offsetParent: p,
+    strategy: d
+  }) : y);
+  return {
+    top: (w.top - P.top + o.top) / h.y,
+    bottom: (P.bottom - w.bottom + o.bottom) / h.y,
+    left: (w.left - P.left + o.left) / h.x,
+    right: (P.right - w.right + o.right) / h.x
+  };
+}
+const ee = 50, oe = async (a, s, m) => {
+  const {
+    placement: n = "bottom",
+    strategy: r = "absolute",
+    middleware: e = [],
+    platform: i
+  } = m, l = i.detectOverflow ? i : {
+    ...i,
+    detectOverflow: Z
+  }, d = await (i.isRTL == null ? void 0 : i.isRTL(s));
+  let g = await i.getElementRects({
+    reference: a,
+    floating: s,
+    strategy: r
+  }), {
+    x,
+    y: c
+  } = z(g, n, d), f = n, t = 0;
+  const o = {};
+  for (let u = 0; u < e.length; u++) {
+    const v = e[u];
+    if (!v)
+      continue;
+    const {
+      name: w,
+      fn: y
+    } = v, {
+      x: p,
+      y: h,
+      data: P,
+      reset: b
+    } = await y({
+      x,
+      y: c,
+      initialPlacement: n,
+      placement: f,
+      strategy: r,
+      middlewareData: o,
+      rects: g,
+      platform: l,
+      elements: {
+        reference: a,
+        floating: s
+      }
+    });
+    x = p ?? x, c = h ?? c, o[w] = {
+      ...o[w],
+      ...P
+    }, b && t < ee && (t++, typeof b == "object" && (b.placement && (f = b.placement), b.rects && (g = b.rects === !0 ? await i.getElementRects({
+      reference: a,
+      floating: s,
+      strategy: r
+    }) : b.rects), {
+      x,
+      y: c
+    } = z(g, f, d)), u = -1);
+  }
+  return {
+    x,
+    y: c,
+    placement: f,
+    strategy: r,
+    middlewareData: o
+  };
+}, se = (a) => ({
+  name: "arrow",
+  options: a,
+  async fn(s) {
+    const {
+      x: m,
+      y: n,
+      placement: r,
+      rects: e,
+      platform: i,
+      elements: l,
+      middlewareData: d
+    } = s, {
+      element: g,
+      padding: x = 0
+    } = $(a, s) || {};
+    if (g == null)
+      return {};
+    const c = H(x), f = {
+      x: m,
+      y: n
+    }, t = I(r), o = N(t), u = await i.getDimensions(g), v = t === "y", w = v ? "top" : "left", y = v ? "bottom" : "right", p = v ? "clientHeight" : "clientWidth", h = e.reference[o] + e.reference[t] - f[t] - e.floating[o], P = f[t] - e.reference[t], b = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(g));
+    let D = b ? b[p] : 0;
+    (!D || !await (i.isElement == null ? void 0 : i.isElement(b))) && (D = l.floating[p] || e.floating[o]);
+    const V = h / 2 - P / 2, E = D / 2 - u[o] / 2 - 1, C = Y(c[w], E), F = Y(c[y], E), T = C, j = D - u[o] - F, A = D / 2 - u[o] / 2 + V, L = B(T, A, j), S = !d.arrow && X(r) != null && A !== L && e.reference[o] / 2 - (A < T ? C : F) - u[o] / 2 < 0, O = S ? A < T ? A - T : A - j : 0;
+    return {
+      [t]: f[t] + O,
+      data: {
+        [t]: L,
+        centerOffset: A - L - O,
+        ...S && {
+          alignmentOffset: O
+        }
+      },
+      reset: S
+    };
+  }
+}), ae = function(a) {
+  return a === void 0 && (a = {}), {
+    name: "flip",
+    options: a,
+    async fn(s) {
+      var m, n;
+      const {
+        placement: r,
+        middlewareData: e,
+        rects: i,
+        initialPlacement: l,
+        platform: d,
+        elements: g
+      } = s, {
+        mainAxis: x = !0,
+        crossAxis: c = !0,
+        fallbackPlacements: f,
+        fallbackStrategy: t = "bestFit",
+        fallbackAxisSideDirection: o = "none",
+        flipAlignment: u = !0,
+        ...v
+      } = $(a, s);
+      if ((m = e.arrow) != null && m.alignmentOffset)
+        return {};
+      const w = _(r), y = M(l), p = _(l) === l, h = await (d.isRTL == null ? void 0 : d.isRTL(g.floating)), P = f || (p || !u ? [q(l)] : G(l)), b = o !== "none";
+      !f && b && P.push(...J(l, u, o, h));
+      const D = [l, ...P], V = await d.detectOverflow(s, v), E = [];
+      let C = ((n = e.flip) == null ? void 0 : n.overflows) || [];
+      if (x && E.push(V[w]), c) {
+        const A = K(r, i, h);
+        E.push(V[A[0]], V[A[1]]);
+      }
+      if (C = [...C, {
+        placement: r,
+        overflows: E
+      }], !E.every((A) => A <= 0)) {
+        var F, T;
+        const A = (((F = e.flip) == null ? void 0 : F.index) || 0) + 1, L = D[A];
+        if (L && (!(c === "alignment" ? y !== M(L) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        C.every((R) => M(R.placement) === y ? R.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: A,
+              overflows: C
+            },
+            reset: {
+              placement: L
+            }
+          };
+        let S = (T = C.filter((O) => O.overflows[0] <= 0).sort((O, R) => O.overflows[1] - R.overflows[1])[0]) == null ? void 0 : T.placement;
+        if (!S)
+          switch (t) {
+            case "bestFit": {
+              var j;
+              const O = (j = C.filter((R) => {
+                if (b) {
+                  const k = M(R.placement);
+                  return k === y || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  k === "y";
+                }
+                return !0;
+              }).map((R) => [R.placement, R.overflows.filter((k) => k > 0).reduce((k, U) => k + U, 0)]).sort((R, k) => R[1] - k[1])[0]) == null ? void 0 : j[0];
+              O && (S = O);
+              break;
+            }
+            case "initialPlacement":
+              S = l;
+              break;
+          }
+        if (r !== S)
+          return {
+            reset: {
+              placement: S
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, te = /* @__PURE__ */ new Set(["left", "top"]);
+async function ne(a, s) {
+  const {
+    placement: m,
+    platform: n,
+    elements: r
+  } = a, e = await (n.isRTL == null ? void 0 : n.isRTL(r.floating)), i = _(m), l = X(m), d = M(m) === "y", g = te.has(i) ? -1 : 1, x = e && d ? -1 : 1, c = $(s, a);
+  let {
+    mainAxis: f,
+    crossAxis: t,
+    alignmentAxis: o
+  } = typeof c == "number" ? {
+    mainAxis: c,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: c.mainAxis || 0,
+    crossAxis: c.crossAxis || 0,
+    alignmentAxis: c.alignmentAxis
+  };
+  return l && typeof o == "number" && (t = l === "end" ? o * -1 : o), d ? {
+    x: t * x,
+    y: f * g
+  } : {
+    x: f * g,
+    y: t * x
+  };
+}
+const le = function(a) {
+  return a === void 0 && (a = 0), {
+    name: "offset",
+    options: a,
+    async fn(s) {
+      var m, n;
+      const {
+        x: r,
+        y: e,
+        placement: i,
+        middlewareData: l
+      } = s, d = await ne(s, a);
+      return i === ((m = l.offset) == null ? void 0 : m.placement) && (n = l.arrow) != null && n.alignmentOffset ? {} : {
+        x: r + d.x,
+        y: e + d.y,
+        data: {
+          ...d,
+          placement: i
+        }
+      };
+    }
+  };
+}, ce = function(a) {
+  return a === void 0 && (a = {}), {
+    name: "shift",
+    options: a,
+    async fn(s) {
+      const {
+        x: m,
+        y: n,
+        placement: r,
+        platform: e
+      } = s, {
+        mainAxis: i = !0,
+        crossAxis: l = !1,
+        limiter: d = {
+          fn: (w) => {
+            let {
+              x: y,
+              y: p
+            } = w;
+            return {
+              x: y,
+              y: p
+            };
+          }
+        },
+        ...g
+      } = $(a, s), x = {
+        x: m,
+        y: n
+      }, c = await e.detectOverflow(s, g), f = M(_(r)), t = Q(f);
+      let o = x[t], u = x[f];
+      if (i) {
+        const w = t === "y" ? "top" : "left", y = t === "y" ? "bottom" : "right", p = o + c[w], h = o - c[y];
+        o = B(p, o, h);
+      }
+      if (l) {
+        const w = f === "y" ? "top" : "left", y = f === "y" ? "bottom" : "right", p = u + c[w], h = u - c[y];
+        u = B(p, u, h);
+      }
+      const v = d.fn({
+        ...s,
+        [t]: o,
+        [f]: u
+      });
+      return {
+        ...v,
+        data: {
+          x: v.x - m,
+          y: v.y - n,
+          enabled: {
+            [t]: i,
+            [f]: l
+          }
+        }
+      };
+    }
+  };
+};
 export {
-  u as setDay
+  se as arrow,
+  oe as computePosition,
+  Z as detectOverflow,
+  ae as flip,
+  le as offset,
+  W as rectToClientRect,
+  ce as shift
 };

package/es/index177.mjs

@@ -1,10 +1,127 @@
-import { addDays as m } from "./index135.mjs";
-import { getISODay as n } from "./index165.mjs";
-import { toDate as c } from "./index149.mjs";
-function y(o, a, t) {
-  const r = c(o, t?.in), e = n(r, t), f = a - e;
-  return m(r, f, t);
+const m = Math.min, h = Math.max, S = Math.round, w = Math.floor, C = (t) => ({
+  x: t,
+  y: t
+}), p = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function j(t, n, e) {
+  return h(t, m(n, e));
+}
+function L(t, n) {
+  return typeof t == "function" ? t(n) : t;
+}
+function g(t) {
+  return t.split("-")[0];
+}
+function a(t) {
+  return t.split("-")[1];
+}
+function x(t) {
+  return t === "x" ? "y" : "x";
+}
+function b(t) {
+  return t === "y" ? "height" : "width";
+}
+function d(t) {
+  const n = t[0];
+  return n === "t" || n === "b" ? "y" : "x";
+}
+function A(t) {
+  return x(d(t));
+}
+function E(t, n, e) {
+  e === void 0 && (e = !1);
+  const r = a(t), i = A(t), o = b(i);
+  let c = i === "x" ? r === (e ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return n.reference[o] > n.floating[o] && (c = u(c)), [c, u(c)];
+}
+function R(t) {
+  const n = u(t);
+  return [s(t), n, s(n)];
+}
+function s(t) {
+  return t.includes("start") ? t.replace("start", "end") : t.replace("end", "start");
+}
+const f = ["left", "right"], l = ["right", "left"], P = ["top", "bottom"], y = ["bottom", "top"];
+function O(t, n, e) {
+  switch (t) {
+    case "top":
+    case "bottom":
+      return e ? n ? l : f : n ? f : l;
+    case "left":
+    case "right":
+      return n ? P : y;
+    default:
+      return [];
+  }
+}
+function T(t, n, e, r) {
+  const i = a(t);
+  let o = O(g(t), e === "start", r);
+  return i && (o = o.map((c) => c + "-" + i), n && (o = o.concat(o.map(s)))), o;
+}
+function u(t) {
+  const n = g(t);
+  return p[n] + t.slice(n.length);
+}
+function M(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function k(t) {
+  return typeof t != "number" ? M(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function q(t) {
+  const {
+    x: n,
+    y: e,
+    width: r,
+    height: i
+  } = t;
+  return {
+    width: r,
+    height: i,
+    top: e,
+    left: n,
+    right: n + r,
+    bottom: e + i,
+    x: n,
+    y: e
+  };
 }
 export {
-  y as setISODay
+  j as clamp,
+  C as createCoords,
+  L as evaluate,
+  M as expandPaddingObject,
+  w as floor,
+  a as getAlignment,
+  A as getAlignmentAxis,
+  E as getAlignmentSides,
+  b as getAxisLength,
+  R as getExpandedPlacements,
+  s as getOppositeAlignmentPlacement,
+  x as getOppositeAxis,
+  T as getOppositeAxisPlacements,
+  u as getOppositePlacement,
+  k as getPaddingObject,
+  g as getSide,
+  d as getSideAxis,
+  h as max,
+  m as min,
+  q as rectToClientRect,
+  S as round
 };

package/es/index178.mjs

@@ -1,9 +1,136 @@
-import { getISOWeek as n } from "./index166.mjs";
-import { toDate as a } from "./index149.mjs";
-function c(o, r, e) {
-  const t = a(o, e?.in), f = n(t, e) - r;
-  return t.setDate(t.getDate() - f * 7), t;
+function u() {
+  return typeof window < "u";
+}
+function a(t) {
+  return m(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function i(t) {
+  var n;
+  return (t == null || (n = t.ownerDocument) == null ? void 0 : n.defaultView) || window;
+}
+function L(t) {
+  var n;
+  return (n = (m(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : n.documentElement;
+}
+function m(t) {
+  return u() ? t instanceof Node || t instanceof i(t).Node : !1;
+}
+function h(t) {
+  return u() ? t instanceof Element || t instanceof i(t).Element : !1;
+}
+function g(t) {
+  return u() ? t instanceof HTMLElement || t instanceof i(t).HTMLElement : !1;
+}
+function p(t) {
+  return !u() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof i(t).ShadowRoot;
+}
+function y(t) {
+  const {
+    overflow: n,
+    overflowX: r,
+    overflowY: c,
+    display: e
+  } = b(t);
+  return /auto|scroll|overlay|hidden|clip/.test(n + c + r) && e !== "inline" && e !== "contents";
+}
+function _(t) {
+  return /^(table|td|th)$/.test(a(t));
+}
+function T(t) {
+  try {
+    if (t.matches(":popover-open"))
+      return !0;
+  } catch {
+  }
+  try {
+    return t.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+const v = /transform|translate|scale|rotate|perspective|filter/, C = /paint|layout|strict|content/, o = (t) => !!t && t !== "none";
+let s;
+function D(t) {
+  const n = h(t) ? b(t) : t;
+  return o(n.transform) || o(n.translate) || o(n.scale) || o(n.rotate) || o(n.perspective) || !R() && (o(n.backdropFilter) || o(n.filter)) || v.test(n.willChange || "") || C.test(n.contain || "");
+}
+function W(t) {
+  let n = f(t);
+  for (; g(n) && !N(n); ) {
+    if (D(n))
+      return n;
+    if (T(n))
+      return null;
+    n = f(n);
+  }
+  return null;
+}
+function R() {
+  return s == null && (s = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), s;
+}
+function N(t) {
+  return /^(html|body|#document)$/.test(a(t));
+}
+function b(t) {
+  return i(t).getComputedStyle(t);
+}
+function $(t) {
+  return h(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function f(t) {
+  if (a(t) === "html")
+    return t;
+  const n = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    t.assignedSlot || // DOM Element detected.
+    t.parentNode || // ShadowRoot detected.
+    p(t) && t.host || // Fallback.
+    L(t)
+  );
+  return p(n) ? n.host : n;
+}
+function S(t) {
+  const n = f(t);
+  return N(n) ? t.ownerDocument ? t.ownerDocument.body : t.body : g(n) && y(n) ? n : S(n);
+}
+function w(t, n, r) {
+  var c;
+  n === void 0 && (n = []), r === void 0 && (r = !0);
+  const e = S(t), E = e === ((c = t.ownerDocument) == null ? void 0 : c.body), l = i(e);
+  if (E) {
+    const d = k(l);
+    return n.concat(l, l.visualViewport || [], y(e) ? e : [], d && r ? w(d) : []);
+  } else
+    return n.concat(e, w(e, [], r));
+}
+function k(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
 }
 export {
-  c as setISOWeek
+  b as getComputedStyle,
+  W as getContainingBlock,
+  L as getDocumentElement,
+  k as getFrameElement,
+  S as getNearestOverflowAncestor,
+  a as getNodeName,
+  $ as getNodeScroll,
+  w as getOverflowAncestors,
+  f as getParentNode,
+  i as getWindow,
+  D as isContainingBlock,
+  h as isElement,
+  g as isHTMLElement,
+  N as isLastTraversableNode,
+  m as isNode,
+  y as isOverflowElement,
+  p as isShadowRoot,
+  _ as isTableElement,
+  T as isTopLayer,
+  R as isWebKit
 };