@kong/kongponents 9.47.4 → 9.48.0

package/dist/kongponents.es303.js

@@ -1,97 +1,7 @@
-import { defineComponent as K, computed as g, useTemplateRef as $, createElementBlock as d, openBlock as l, createBlock as u, createCommentVNode as h, Fragment as m, renderList as f, withCtx as S, renderSlot as v, createElementVNode as p, toDisplayString as y, createTextVNode as V } from "vue";
-import w from "./kongponents.es233.js";
-const D = { ref: "itemsContainer" }, O = { class: "select-group-title" }, R = { class: "select-item-description" }, I = ".select-item button:not(:disabled)", q = '.select-item[aria-selected="true"] button:not(:disabled)', G = /* @__PURE__ */ K({
-  __name: "KSelectItems",
-  props: {
-    items: { default: () => [] },
-    itemCreationEnabled: { type: Boolean },
-    filterString: { default: "" },
-    itemCreationValid: { type: Boolean, default: !0 }
-  },
-  emits: ["selected", "add-item"],
-  setup(s, { expose: k, emit: A }) {
-    const L = A, C = (n) => L("selected", n), T = g(() => {
-      var n;
-      return (n = s.items) == null ? void 0 : n.filter((t) => !t.group);
-    }), b = g(() => {
-      var n, t;
-      return [...new Set((t = (n = s.items) == null ? void 0 : n.filter((e) => e.group)) == null ? void 0 : t.map((e) => e.group))].sort((e, o) => e.toLowerCase().localeCompare(o.toLowerCase()));
-    }), x = (n) => {
-      var t;
-      return (t = s.items) == null ? void 0 : t.filter((e) => e.group === n);
-    }, E = $("itemsContainer"), B = (n) => {
-      var i, c;
-      const t = E.value;
-      if (!t)
-        return;
-      const e = t.querySelectorAll(I);
-      if (!(e != null && e.length))
-        return;
-      const o = t.querySelector(q);
-      if (o) {
-        const r = [...e].indexOf(o);
-        (i = e[n === "down" ? r + 1 : r - 1]) == null || i.focus();
-      } else
-        (c = e[n === "down" ? 0 : e.length - 1]) == null || c.focus();
-    }, a = ({ target: n, key: t }) => {
-      var e;
-      if (t === "ArrowDown" || t === "ArrowUp") {
-        const o = (e = E.value) == null ? void 0 : e.querySelectorAll(I);
-        if (o != null && o.length) {
-          const i = [...o].indexOf(n), c = t === "ArrowDown" ? i + 1 : i - 1, r = o[c];
-          r == null || r.focus();
-        }
-      }
-    };
-    return k({ setFocus: B }), (n, t) => (l(), d("div", D, [
-      (l(!0), d(m, null, f(T.value, (e) => (l(), u(w, {
-        key: e.key,
-        item: e,
-        onKeydown: a,
-        onSelected: C
-      }, {
-        content: S(() => [
-          v(n.$slots, "content", { item: e }, void 0, !0)
-        ]),
-        _: 2
-      }, 1032, ["item"]))), 128)),
-      (l(!0), d(m, null, f(b.value, (e) => (l(), d("div", {
-        key: `${e}-group`,
-        class: "select-group",
-        "data-propagate-clicks": "false"
-      }, [
-        p("span", O, y(e), 1),
-        (l(!0), d(m, null, f(x(e), (o) => (l(), u(w, {
-          key: o.key,
-          item: o,
-          onKeydown: a,
-          onSelected: C
-        }, {
-          content: S(() => [
-            v(n.$slots, "content", { item: o }, void 0, !0)
-          ]),
-          _: 2
-        }, 1032, ["item"]))), 128))
-      ]))), 128)),
-      s.itemCreationEnabled ? (l(), u(w, {
-        key: "select-add-item",
-        class: "select-add-item",
-        "data-testid": "select-add-item",
-        item: { label: `${s.filterString} (Add new value)`, value: "add_item", disabled: !s.itemCreationValid },
-        onKeydown: a,
-        onSelected: t[0] || (t[0] = (e) => n.$emit("add-item"))
-      }, {
-        content: S(() => [
-          p("div", R, [
-            V(y(s.filterString) + " ", 1),
-            t[1] || (t[1] = p("span", { class: "select-item-new-indicator" }, "(Add new value)", -1))
-          ])
-        ]),
-        _: 1
-      }, 8, ["item"])) : h("", !0)
-    ], 512));
-  }
-});
+import { getDefaultExportFromCjs as e } from "./kongponents.es481.js";
+import { __require as o } from "./kongponents.es380.js";
+var t = /* @__PURE__ */ o();
+const r = /* @__PURE__ */ e(t);
 export {
-  G as default
+  r as default
 };

package/dist/kongponents.es304.js

@@ -0,0 +1,72 @@
+import M from "./kongponents.es390.js";
+import T from "./kongponents.es391.js";
+var c = 36e5, D = 6e4, i = {
+  timezoneZ: /^(Z)$/,
+  timezoneHH: /^([+-]\d{2})$/,
+  timezoneHHMM: /^([+-])(\d{2}):?(\d{2})$/
+};
+function z(e, r, n) {
+  var t, u;
+  if (!e || (t = i.timezoneZ.exec(e), t))
+    return 0;
+  var a;
+  if (t = i.timezoneHH.exec(e), t)
+    return a = parseInt(t[1], 10), l(a) ? -(a * c) : NaN;
+  if (t = i.timezoneHHMM.exec(e), t) {
+    a = parseInt(t[2], 10);
+    var o = parseInt(t[3], 10);
+    return l(a, o) ? (u = Math.abs(a) * c + o * D, t[1] === "+" ? -u : u) : NaN;
+  }
+  if (p(e)) {
+    r = new Date(r || Date.now());
+    var I = n ? r : H(r), f = v(I, e), N = n ? f : m(r, f, e);
+    return -N;
+  }
+  return NaN;
+}
+function H(e) {
+  return T(
+    e.getFullYear(),
+    e.getMonth(),
+    e.getDate(),
+    e.getHours(),
+    e.getMinutes(),
+    e.getSeconds(),
+    e.getMilliseconds()
+  );
+}
+function v(e, r) {
+  var n = M(e, r), t = T(
+    n[0],
+    n[1] - 1,
+    n[2],
+    n[3] % 24,
+    n[4],
+    n[5],
+    0
+  ).getTime(), u = e.getTime(), a = u % 1e3;
+  return u -= a >= 0 ? a : 1e3 + a, t - u;
+}
+function m(e, r, n) {
+  var t = e.getTime(), u = t - r, a = v(new Date(u), n);
+  if (r === a)
+    return r;
+  u -= a - r;
+  var o = v(new Date(u), n);
+  return a === o ? a : Math.max(a, o);
+}
+function l(e, r) {
+  return -23 <= e && e <= 23 && (r == null || 0 <= r && r <= 59);
+}
+var s = {};
+function p(e) {
+  if (s[e]) return !0;
+  try {
+    return new Intl.DateTimeFormat(void 0, { timeZone: e }), s[e] = !0, !0;
+  } catch {
+    return !1;
+  }
+}
+export {
+  z as default
+};

package/dist/kongponents.es305.js

@@ -1,47 +1,4 @@
-import { defineComponent as r, createElementBlock as c, openBlock as u, createElementVNode as l, withKeys as s, normalizeClass as v, withModifiers as n, renderSlot as w, createTextVNode as b, toDisplayString as f } from "vue";
-const k = ["aria-selected", "data-testid"], y = { class: "select-item-container" }, $ = ["disabled", "value"], h = { class: "select-item-label" }, K = /* @__PURE__ */ r({
-  __name: "KSelectItem",
-  props: {
-    item: {}
-  },
-  emits: ["selected", "arrow-down", "arrow-up"],
-  setup(e, { emit: o }) {
-    const a = o, d = (t) => {
-      if (e.item.disabled) {
-        t.stopPropagation();
-        return;
-      }
-      a("selected", e.item);
-    };
-    return (t, i) => (u(), c("div", {
-      key: e.item.key,
-      "aria-selected": e.item.selected,
-      class: "select-item",
-      "data-testid": `select-item-${e.item.value}`,
-      role: "option"
-    }, [
-      l("div", y, [
-        l("button", {
-          class: v({ selected: e.item.selected }),
-          disabled: e.item.disabled === !0 ? !0 : void 0,
-          type: "button",
-          value: e.item.value,
-          onClick: d,
-          onKeydown: [
-            i[0] || (i[0] = s(n((m) => t.$emit("arrow-down"), ["prevent"]), ["down"])),
-            i[1] || (i[1] = s(n((m) => t.$emit("arrow-up"), ["prevent"]), ["up"]))
-          ]
-        }, [
-          l("span", h, [
-            w(t.$slots, "content", {}, () => [
-              b(f(e.item.label), 1)
-            ], !0)
-          ])
-        ], 42, $)
-      ])
-    ], 8, k));
-  }
-});
+var a = /(Z|[+-]\d{2}(?::?\d{2})?| UTC| [a-zA-Z]+\/[a-zA-Z_]+(?:\/[a-zA-Z_]+)?)$/;
 export {
-  K as default
+  a as default
 };

package/dist/kongponents.es306.js

@@ -0,0 +1,372 @@
+import { evaluate as V, getSideAxis as E, getSide as D, clamp as X, getOppositePlacement as J, getExpandedPlacements as K, getOppositeAxisPlacements as N, getAlignmentSides as G, placements as Y, getAlignment as T, getPaddingObject as Q, rectToClientRect as q, getOppositeAxis as U, getOppositeAlignmentPlacement as W, getAlignmentAxis as Z, getAxisLength as ee } from "./kongponents.es307.js";
+function z(t, i, m) {
+  let {
+    reference: n,
+    floating: e
+  } = t;
+  const l = E(i), r = Z(i), s = ee(r), y = D(i), v = l === "y", d = n.x + n.width / 2 - e.width / 2, a = n.y + n.height / 2 - e.height / 2, c = n[s] / 2 - e[s] / 2;
+  let o;
+  switch (y) {
+    case "top":
+      o = {
+        x: d,
+        y: n.y - e.height
+      };
+      break;
+    case "bottom":
+      o = {
+        x: d,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      o = {
+        x: n.x + n.width,
+        y: a
+      };
+      break;
+    case "left":
+      o = {
+        x: n.x - e.width,
+        y: a
+      };
+      break;
+    default:
+      o = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (T(i)) {
+    case "start":
+      o[r] -= c * (m && v ? -1 : 1);
+      break;
+    case "end":
+      o[r] += c * (m && v ? -1 : 1);
+      break;
+  }
+  return o;
+}
+const ie = async (t, i, m) => {
+  const {
+    placement: n = "bottom",
+    strategy: e = "absolute",
+    middleware: l = [],
+    platform: r
+  } = m, s = l.filter(Boolean), y = await (r.isRTL == null ? void 0 : r.isRTL(i));
+  let v = await r.getElementRects({
+    reference: t,
+    floating: i,
+    strategy: e
+  }), {
+    x: d,
+    y: a
+  } = z(v, n, y), c = n, o = {}, x = 0;
+  for (let h = 0; h < s.length; h++) {
+    const {
+      name: w,
+      fn: u
+    } = s[h], {
+      x: f,
+      y: A,
+      data: P,
+      reset: g
+    } = await u({
+      x: d,
+      y: a,
+      initialPlacement: n,
+      placement: c,
+      strategy: e,
+      middlewareData: o,
+      rects: v,
+      platform: r,
+      elements: {
+        reference: t,
+        floating: i
+      }
+    });
+    d = f ?? d, a = A ?? a, o = {
+      ...o,
+      [w]: {
+        ...o[w],
+        ...P
+      }
+    }, g && x <= 50 && (x++, typeof g == "object" && (g.placement && (c = g.placement), g.rects && (v = g.rects === !0 ? await r.getElementRects({
+      reference: t,
+      floating: i,
+      strategy: e
+    }) : g.rects), {
+      x: d,
+      y: a
+    } = z(v, c, y)), h = -1);
+  }
+  return {
+    x: d,
+    y: a,
+    placement: c,
+    strategy: e,
+    middlewareData: o
+  };
+};
+async function I(t, i) {
+  var m;
+  i === void 0 && (i = {});
+  const {
+    x: n,
+    y: e,
+    platform: l,
+    rects: r,
+    elements: s,
+    strategy: y
+  } = t, {
+    boundary: v = "clippingAncestors",
+    rootBoundary: d = "viewport",
+    elementContext: a = "floating",
+    altBoundary: c = !1,
+    padding: o = 0
+  } = V(i, t), x = Q(o), w = s[c ? a === "floating" ? "reference" : "floating" : a], u = q(await l.getClippingRect({
+    element: (m = await (l.isElement == null ? void 0 : l.isElement(w))) == null || m ? w : w.contextElement || await (l.getDocumentElement == null ? void 0 : l.getDocumentElement(s.floating)),
+    boundary: v,
+    rootBoundary: d,
+    strategy: y
+  })), f = a === "floating" ? {
+    x: n,
+    y: e,
+    width: r.floating.width,
+    height: r.floating.height
+  } : r.reference, A = await (l.getOffsetParent == null ? void 0 : l.getOffsetParent(s.floating)), P = await (l.isElement == null ? void 0 : l.isElement(A)) ? await (l.getScale == null ? void 0 : l.getScale(A)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, g = q(l.convertOffsetParentRelativeRectToViewportRelativeRect ? await l.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: s,
+    rect: f,
+    offsetParent: A,
+    strategy: y
+  }) : f);
+  return {
+    top: (u.top - g.top + x.top) / P.y,
+    bottom: (g.bottom - u.bottom + x.bottom) / P.y,
+    left: (u.left - g.left + x.left) / P.x,
+    right: (g.right - u.right + x.right) / P.x
+  };
+}
+function te(t, i, m) {
+  return (t ? [...m.filter((e) => T(e) === t), ...m.filter((e) => T(e) !== t)] : m.filter((e) => D(e) === e)).filter((e) => t ? T(e) === t || (i ? W(e) !== e : !1) : !0);
+}
+const le = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "autoPlacement",
+    options: t,
+    async fn(i) {
+      var m, n, e;
+      const {
+        rects: l,
+        middlewareData: r,
+        placement: s,
+        platform: y,
+        elements: v
+      } = i, {
+        crossAxis: d = !1,
+        alignment: a,
+        allowedPlacements: c = Y,
+        autoAlignment: o = !0,
+        ...x
+      } = V(t, i), h = a !== void 0 || c === Y ? te(a || null, o, c) : c, w = await I(i, x), u = ((m = r.autoPlacement) == null ? void 0 : m.index) || 0, f = h[u];
+      if (f == null)
+        return {};
+      const A = G(f, l, await (y.isRTL == null ? void 0 : y.isRTL(v.floating)));
+      if (s !== f)
+        return {
+          reset: {
+            placement: h[0]
+          }
+        };
+      const P = [w[D(f)], w[A[0]], w[A[1]]], g = [...((n = r.autoPlacement) == null ? void 0 : n.overflows) || [], {
+        placement: f,
+        overflows: P
+      }], L = h[u + 1];
+      if (L)
+        return {
+          data: {
+            index: u + 1,
+            overflows: g
+          },
+          reset: {
+            placement: L
+          }
+        };
+      const B = g.map((p) => {
+        const O = T(p.placement);
+        return [p.placement, O && d ? (
+          // Check along the mainAxis and main crossAxis side.
+          p.overflows.slice(0, 2).reduce(($, j) => $ + j, 0)
+        ) : (
+          // Check only the mainAxis.
+          p.overflows[0]
+        ), p.overflows];
+      }).sort((p, O) => p[1] - O[1]), R = ((e = B.filter((p) => p[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        T(p[0]) ? 2 : 3
+      ).every((O) => O <= 0))[0]) == null ? void 0 : e[0]) || B[0][0];
+      return R !== s ? {
+        data: {
+          index: u + 1,
+          overflows: g
+        },
+        reset: {
+          placement: R
+        }
+      } : {};
+    }
+  };
+}, oe = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(i) {
+      var m, n;
+      const {
+        placement: e,
+        middlewareData: l,
+        rects: r,
+        initialPlacement: s,
+        platform: y,
+        elements: v
+      } = i, {
+        mainAxis: d = !0,
+        crossAxis: a = !0,
+        fallbackPlacements: c,
+        fallbackStrategy: o = "bestFit",
+        fallbackAxisSideDirection: x = "none",
+        flipAlignment: h = !0,
+        ...w
+      } = V(t, i);
+      if ((m = l.arrow) != null && m.alignmentOffset)
+        return {};
+      const u = D(e), f = E(s), A = D(s) === s, P = await (y.isRTL == null ? void 0 : y.isRTL(v.floating)), g = c || (A || !h ? [J(s)] : K(s)), L = x !== "none";
+      !c && L && g.push(...N(s, h, x, P));
+      const B = [s, ...g], M = await I(i, w), R = [];
+      let p = ((n = l.flip) == null ? void 0 : n.overflows) || [];
+      if (d && R.push(M[u]), a) {
+        const k = G(e, r, P);
+        R.push(M[k[0]], M[k[1]]);
+      }
+      if (p = [...p, {
+        placement: e,
+        overflows: R
+      }], !R.every((k) => k <= 0)) {
+        var O, $;
+        const k = (((O = l.flip) == null ? void 0 : O.index) || 0) + 1, _ = B[k];
+        if (_ && (!(a === "alignment" ? f !== E(_) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        p.every((b) => E(b.placement) === f ? b.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: k,
+              overflows: p
+            },
+            reset: {
+              placement: _
+            }
+          };
+        let F = ($ = p.filter((C) => C.overflows[0] <= 0).sort((C, b) => C.overflows[1] - b.overflows[1])[0]) == null ? void 0 : $.placement;
+        if (!F)
+          switch (o) {
+            case "bestFit": {
+              var j;
+              const C = (j = p.filter((b) => {
+                if (L) {
+                  const S = E(b.placement);
+                  return S === f || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  S === "y";
+                }
+                return !0;
+              }).map((b) => [b.placement, b.overflows.filter((S) => S > 0).reduce((S, H) => S + H, 0)]).sort((b, S) => b[1] - S[1])[0]) == null ? void 0 : j[0];
+              C && (F = C);
+              break;
+            }
+            case "initialPlacement":
+              F = s;
+              break;
+          }
+        if (e !== F)
+          return {
+            reset: {
+              placement: F
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, ae = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(i) {
+      const {
+        x: m,
+        y: n,
+        placement: e
+      } = i, {
+        mainAxis: l = !0,
+        crossAxis: r = !1,
+        limiter: s = {
+          fn: (w) => {
+            let {
+              x: u,
+              y: f
+            } = w;
+            return {
+              x: u,
+              y: f
+            };
+          }
+        },
+        ...y
+      } = V(t, i), v = {
+        x: m,
+        y: n
+      }, d = await I(i, y), a = E(D(e)), c = U(a);
+      let o = v[c], x = v[a];
+      if (l) {
+        const w = c === "y" ? "top" : "left", u = c === "y" ? "bottom" : "right", f = o + d[w], A = o - d[u];
+        o = X(f, o, A);
+      }
+      if (r) {
+        const w = a === "y" ? "top" : "left", u = a === "y" ? "bottom" : "right", f = x + d[w], A = x - d[u];
+        x = X(f, x, A);
+      }
+      const h = s.fn({
+        ...i,
+        [c]: o,
+        [a]: x
+      });
+      return {
+        ...h,
+        data: {
+          x: h.x - m,
+          y: h.y - n,
+          enabled: {
+            [c]: l,
+            [a]: r
+          }
+        }
+      };
+    }
+  };
+};
+export {
+  le as autoPlacement,
+  ie as computePosition,
+  I as detectOverflow,
+  oe as flip,
+  q as rectToClientRect,
+  ae as shift
+};