@rpcbase/ui 0.230.0 → 0.232.0

package/dist/index407.js

@@ -1,59 +1,495 @@
-import { addLeadingZeros as n } from "./index406.js";
-const g = {
-  // Year
-  y(e, t) {
-    const r = e.getFullYear(), a = r > 0 ? r : 1 - r;
-    return n(t === "yy" ? a % 100 : a, t.length);
-  },
-  // Month
-  M(e, t) {
-    const r = e.getMonth();
-    return t === "M" ? String(r + 1) : n(r + 1, 2);
-  },
-  // Day of the month
-  d(e, t) {
-    return n(e.getDate(), t.length);
-  },
-  // AM or PM
-  a(e, t) {
-    const r = e.getHours() / 12 >= 1 ? "pm" : "am";
-    switch (t) {
-      case "a":
-      case "aa":
-        return r.toUpperCase();
-      case "aaa":
-        return r;
-      case "aaaaa":
-        return r[0];
-      default:
-        return r === "am" ? "a.m." : "p.m.";
-    }
-  },
-  // Hour [1-12]
-  h(e, t) {
-    return n(e.getHours() % 12 || 12, t.length);
-  },
-  // Hour [0-23]
-  H(e, t) {
-    return n(e.getHours(), t.length);
-  },
-  // Minute
-  m(e, t) {
-    return n(e.getMinutes(), t.length);
-  },
-  // Second
-  s(e, t) {
-    return n(e.getSeconds(), t.length);
-  },
-  // Fraction of second
-  S(e, t) {
-    const r = t.length, a = e.getMilliseconds(), s = Math.trunc(
-      a * Math.pow(10, r - 3)
-    );
-    return n(s, t.length);
+import { evaluate as P, getSide as E, getSideAxis as S, getOppositePlacement as J, getExpandedPlacements as K, getOppositeAxisPlacements as Q, getAlignmentSides as Z, getAlignment as j, min as X, max as L, getAlignmentAxis as ee, getPaddingObject as te, rectToClientRect as Y, sides as ne, getAxisLength as ie, clamp as $, getOppositeAxis as U } from "./index324.js";
+function z(t, e, d) {
+  let {
+    reference: i,
+    floating: m
+  } = t;
+  const n = S(e), l = ee(e), o = ie(l), x = E(e), v = n === "y", a = i.x + i.width / 2 - m.width / 2, s = i.y + i.height / 2 - m.height / 2, c = i[o] / 2 - m[o] / 2;
+  let r;
+  switch (x) {
+    case "top":
+      r = {
+        x: a,
+        y: i.y - m.height
+      };
+      break;
+    case "bottom":
+      r = {
+        x: a,
+        y: i.y + i.height
+      };
+      break;
+    case "right":
+      r = {
+        x: i.x + i.width,
+        y: s
+      };
+      break;
+    case "left":
+      r = {
+        x: i.x - m.width,
+        y: s
+      };
+      break;
+    default:
+      r = {
+        x: i.x,
+        y: i.y
+      };
+  }
+  switch (j(e)) {
+    case "start":
+      r[l] -= c * (d && v ? -1 : 1);
+      break;
+    case "end":
+      r[l] += c * (d && v ? -1 : 1);
+      break;
+  }
+  return r;
+}
+async function se(t, e) {
+  var d;
+  e === void 0 && (e = {});
+  const {
+    x: i,
+    y: m,
+    platform: n,
+    rects: l,
+    elements: o,
+    strategy: x
+  } = t, {
+    boundary: v = "clippingAncestors",
+    rootBoundary: a = "viewport",
+    elementContext: s = "floating",
+    altBoundary: c = !1,
+    padding: r = 0
+  } = P(e, t), f = te(r), p = o[c ? s === "floating" ? "reference" : "floating" : s], w = Y(await n.getClippingRect({
+    element: (d = await (n.isElement == null ? void 0 : n.isElement(p))) == null || d ? p : p.contextElement || await (n.getDocumentElement == null ? void 0 : n.getDocumentElement(o.floating)),
+    boundary: v,
+    rootBoundary: a,
+    strategy: x
+  })), A = s === "floating" ? {
+    x: i,
+    y: m,
+    width: l.floating.width,
+    height: l.floating.height
+  } : l.reference, h = await (n.getOffsetParent == null ? void 0 : n.getOffsetParent(o.floating)), u = await (n.isElement == null ? void 0 : n.isElement(h)) ? await (n.getScale == null ? void 0 : n.getScale(h)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, y = Y(n.convertOffsetParentRelativeRectToViewportRelativeRect ? await n.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: o,
+    rect: A,
+    offsetParent: h,
+    strategy: x
+  }) : A);
+  return {
+    top: (w.top - y.top + f.top) / u.y,
+    bottom: (y.bottom - w.bottom + f.bottom) / u.y,
+    left: (w.left - y.left + f.left) / u.x,
+    right: (y.right - w.right + f.right) / u.x
+  };
+}
+const oe = 50, ce = async (t, e, d) => {
+  const {
+    placement: i = "bottom",
+    strategy: m = "absolute",
+    middleware: n = [],
+    platform: l
+  } = d, o = l.detectOverflow ? l : {
+    ...l,
+    detectOverflow: se
+  }, x = await (l.isRTL == null ? void 0 : l.isRTL(e));
+  let v = await l.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: m
+  }), {
+    x: a,
+    y: s
+  } = z(v, i, x), c = i, r = 0;
+  const f = {};
+  for (let g = 0; g < n.length; g++) {
+    const p = n[g];
+    if (!p)
+      continue;
+    const {
+      name: w,
+      fn: A
+    } = p, {
+      x: h,
+      y: u,
+      data: y,
+      reset: b
+    } = await A({
+      x: a,
+      y: s,
+      initialPlacement: i,
+      placement: c,
+      strategy: m,
+      middlewareData: f,
+      rects: v,
+      platform: o,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    a = h ?? a, s = u ?? s, f[w] = {
+      ...f[w],
+      ...y
+    }, b && r < oe && (r++, typeof b == "object" && (b.placement && (c = b.placement), b.rects && (v = b.rects === !0 ? await l.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: m
+    }) : b.rects), {
+      x: a,
+      y: s
+    } = z(v, c, x)), g = -1);
   }
+  return {
+    x: a,
+    y: s,
+    placement: c,
+    strategy: m,
+    middlewareData: f
+  };
+}, re = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(e) {
+      var d, i;
+      const {
+        placement: m,
+        middlewareData: n,
+        rects: l,
+        initialPlacement: o,
+        platform: x,
+        elements: v
+      } = e, {
+        mainAxis: a = !0,
+        crossAxis: s = !0,
+        fallbackPlacements: c,
+        fallbackStrategy: r = "bestFit",
+        fallbackAxisSideDirection: f = "none",
+        flipAlignment: g = !0,
+        ...p
+      } = P(t, e);
+      if ((d = n.arrow) != null && d.alignmentOffset)
+        return {};
+      const w = E(m), A = S(o), h = E(o) === o, u = await (x.isRTL == null ? void 0 : x.isRTL(v.floating)), y = c || (h || !g ? [J(o)] : K(o)), b = f !== "none";
+      !c && b && y.push(...Q(o, g, f, u));
+      const H = [o, ...y], k = await x.detectOverflow(e, p), D = [];
+      let C = ((i = n.flip) == null ? void 0 : i.overflows) || [];
+      if (a && D.push(k[w]), s) {
+        const M = Z(m, l, u);
+        D.push(k[M[0]], k[M[1]]);
+      }
+      if (C = [...C, {
+        placement: m,
+        overflows: D
+      }], !D.every((M) => M <= 0)) {
+        var F, V;
+        const M = (((F = n.flip) == null ? void 0 : F.index) || 0) + 1, _ = H[M];
+        if (_ && (!(s === "alignment" ? A !== S(_) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        C.every((O) => S(O.placement) === A ? O.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: M,
+              overflows: C
+            },
+            reset: {
+              placement: _
+            }
+          };
+        let W = (V = C.filter((T) => T.overflows[0] <= 0).sort((T, O) => T.overflows[1] - O.overflows[1])[0]) == null ? void 0 : V.placement;
+        if (!W)
+          switch (r) {
+            case "bestFit": {
+              var B;
+              const T = (B = C.filter((O) => {
+                if (b) {
+                  const R = S(O.placement);
+                  return R === A || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  R === "y";
+                }
+                return !0;
+              }).map((O) => [O.placement, O.overflows.filter((R) => R > 0).reduce((R, G) => R + G, 0)]).sort((O, R) => O[1] - R[1])[0]) == null ? void 0 : B[0];
+              T && (W = T);
+              break;
+            }
+            case "initialPlacement":
+              W = o;
+              break;
+          }
+        if (m !== W)
+          return {
+            reset: {
+              placement: W
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function I(t, e) {
+  return {
+    top: t.top - e.height,
+    right: t.right - e.width,
+    bottom: t.bottom - e.height,
+    left: t.left - e.width
+  };
+}
+function N(t) {
+  return ne.some((e) => t[e] >= 0);
+}
+const fe = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "hide",
+    options: t,
+    async fn(e) {
+      const {
+        rects: d,
+        platform: i
+      } = e, {
+        strategy: m = "referenceHidden",
+        ...n
+      } = P(t, e);
+      switch (m) {
+        case "referenceHidden": {
+          const l = await i.detectOverflow(e, {
+            ...n,
+            elementContext: "reference"
+          }), o = I(l, d.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: o,
+              referenceHidden: N(o)
+            }
+          };
+        }
+        case "escaped": {
+          const l = await i.detectOverflow(e, {
+            ...n,
+            altBoundary: !0
+          }), o = I(l, d.floating);
+          return {
+            data: {
+              escapedOffsets: o,
+              escaped: N(o)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, q = /* @__PURE__ */ new Set(["left", "top"]);
+async function le(t, e) {
+  const {
+    placement: d,
+    platform: i,
+    elements: m
+  } = t, n = await (i.isRTL == null ? void 0 : i.isRTL(m.floating)), l = E(d), o = j(d), x = S(d) === "y", v = q.has(l) ? -1 : 1, a = n && x ? -1 : 1, s = P(e, t);
+  let {
+    mainAxis: c,
+    crossAxis: r,
+    alignmentAxis: f
+  } = typeof s == "number" ? {
+    mainAxis: s,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: s.mainAxis || 0,
+    crossAxis: s.crossAxis || 0,
+    alignmentAxis: s.alignmentAxis
+  };
+  return o && typeof f == "number" && (r = o === "end" ? f * -1 : f), x ? {
+    x: r * a,
+    y: c * v
+  } : {
+    x: c * v,
+    y: r * a
+  };
+}
+const me = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var d, i;
+      const {
+        x: m,
+        y: n,
+        placement: l,
+        middlewareData: o
+      } = e, x = await le(e, t);
+      return l === ((d = o.offset) == null ? void 0 : d.placement) && (i = o.arrow) != null && i.alignmentOffset ? {} : {
+        x: m + x.x,
+        y: n + x.y,
+        data: {
+          ...x,
+          placement: l
+        }
+      };
+    }
+  };
+}, de = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: d,
+        y: i,
+        placement: m,
+        platform: n
+      } = e, {
+        mainAxis: l = !0,
+        crossAxis: o = !1,
+        limiter: x = {
+          fn: (w) => {
+            let {
+              x: A,
+              y: h
+            } = w;
+            return {
+              x: A,
+              y: h
+            };
+          }
+        },
+        ...v
+      } = P(t, e), a = {
+        x: d,
+        y: i
+      }, s = await n.detectOverflow(e, v), c = S(E(m)), r = U(c);
+      let f = a[r], g = a[c];
+      if (l) {
+        const w = r === "y" ? "top" : "left", A = r === "y" ? "bottom" : "right", h = f + s[w], u = f - s[A];
+        f = $(h, f, u);
+      }
+      if (o) {
+        const w = c === "y" ? "top" : "left", A = c === "y" ? "bottom" : "right", h = g + s[w], u = g - s[A];
+        g = $(h, g, u);
+      }
+      const p = x.fn({
+        ...e,
+        [r]: f,
+        [c]: g
+      });
+      return {
+        ...p,
+        data: {
+          x: p.x - d,
+          y: p.y - i,
+          enabled: {
+            [r]: l,
+            [c]: o
+          }
+        }
+      };
+    }
+  };
+}, xe = function(t) {
+  return t === void 0 && (t = {}), {
+    options: t,
+    fn(e) {
+      const {
+        x: d,
+        y: i,
+        placement: m,
+        rects: n,
+        middlewareData: l
+      } = e, {
+        offset: o = 0,
+        mainAxis: x = !0,
+        crossAxis: v = !0
+      } = P(t, e), a = {
+        x: d,
+        y: i
+      }, s = S(m), c = U(s);
+      let r = a[c], f = a[s];
+      const g = P(o, e), p = typeof g == "number" ? {
+        mainAxis: g,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...g
+      };
+      if (x) {
+        const h = c === "y" ? "height" : "width", u = n.reference[c] - n.floating[h] + p.mainAxis, y = n.reference[c] + n.reference[h] - p.mainAxis;
+        r < u ? r = u : r > y && (r = y);
+      }
+      if (v) {
+        var w, A;
+        const h = c === "y" ? "width" : "height", u = q.has(E(m)), y = n.reference[s] - n.floating[h] + (u && ((w = l.offset) == null ? void 0 : w[s]) || 0) + (u ? 0 : p.crossAxis), b = n.reference[s] + n.reference[h] + (u ? 0 : ((A = l.offset) == null ? void 0 : A[s]) || 0) - (u ? p.crossAxis : 0);
+        f < y ? f = y : f > b && (f = b);
+      }
+      return {
+        [c]: r,
+        [s]: f
+      };
+    }
+  };
+}, ue = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "size",
+    options: t,
+    async fn(e) {
+      var d, i;
+      const {
+        placement: m,
+        rects: n,
+        platform: l,
+        elements: o
+      } = e, {
+        apply: x = () => {
+        },
+        ...v
+      } = P(t, e), a = await l.detectOverflow(e, v), s = E(m), c = j(m), r = S(m) === "y", {
+        width: f,
+        height: g
+      } = n.floating;
+      let p, w;
+      s === "top" || s === "bottom" ? (p = s, w = c === (await (l.isRTL == null ? void 0 : l.isRTL(o.floating)) ? "start" : "end") ? "left" : "right") : (w = s, p = c === "end" ? "top" : "bottom");
+      const A = g - a.top - a.bottom, h = f - a.left - a.right, u = X(g - a[p], A), y = X(f - a[w], h), b = !e.middlewareData.shift;
+      let H = u, k = y;
+      if ((d = e.middlewareData.shift) != null && d.enabled.x && (k = h), (i = e.middlewareData.shift) != null && i.enabled.y && (H = A), b && !c) {
+        const C = L(a.left, 0), F = L(a.right, 0), V = L(a.top, 0), B = L(a.bottom, 0);
+        r ? k = f - 2 * (C !== 0 || F !== 0 ? C + F : L(a.left, a.right)) : H = g - 2 * (V !== 0 || B !== 0 ? V + B : L(a.top, a.bottom));
+      }
+      await x({
+        ...e,
+        availableWidth: k,
+        availableHeight: H
+      });
+      const D = await l.getDimensions(o.floating);
+      return f !== D.width || g !== D.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
 };
 export {
-  g as lightFormatters
+  ce as computePosition,
+  se as detectOverflow,
+  re as flip,
+  fe as hide,
+  xe as limitShift,
+  me as offset,
+  Y as rectToClientRect,
+  de as shift,
+  ue as size
 };
 //# sourceMappingURL=index407.js.map