@kong/kongponents 9.46.5 → 9.46.6-pr.2979.bf6977b.0

package/dist/kongponents.es324.js

@@ -0,0 +1,178 @@
+import { defineComponent as $, ref as u, computed as D, watch as L, onMounted as T, onBeforeMount as H, createElementBlock as h, openBlock as c, createVNode as o, withCtx as r, unref as b, createBlock as g, createCommentVNode as K, createElementVNode as w, withModifiers as f, createSlots as N, Fragment as P, renderList as E, createTextVNode as C, toDisplayString as U, nextTick as q } from "vue";
+import { debounce as z } from "./kongponents.es166.js";
+import A from "./kongponents.es172.js";
+import J from "./kongponents.es188.js";
+import R from "./kongponents.es272.js";
+import p from "./kongponents.es33.js";
+import F from "./kongponents.es37.js";
+import O from "./kongponents.es42.js";
+import j from "./kongponents.es43.js";
+import G from "./kongponents.es46.js";
+import Q from "./kongponents.es24.js";
+/* empty css                 */
+import W from "./kongponents.es48.js";
+const X = { class: "table-column-visibility-menu" }, Y = { class: "apply-button-wrapper" }, me = /* @__PURE__ */ $({
+  __name: "ColumnVisibilityMenu",
+  props: {
+    columns: {},
+    tableId: {},
+    visibilityPreferences: {},
+    disabled: { type: Boolean }
+  },
+  emits: ["update"],
+  setup(i, { emit: V }) {
+    const x = V, y = u(!1), s = u({}), d = u(!1), n = u(), a = u(""), v = () => {
+      s.value = i.columns.reduce((e, t) => (e[t.key] = i.visibilityPreferences[t.key] === void 0 ? !0 : i.visibilityPreferences[t.key], e), {}), d.value = !1;
+    }, I = z((e) => {
+      a.value = e, n.value && m(n.value);
+    }, 500), k = D(() => a.value ? i.columns.filter((e) => (e.label ? e.label : e.key).toLowerCase().includes(a.value.toLowerCase())) : i.columns), S = () => {
+      x("update", JSON.parse(JSON.stringify(s.value))), d.value = !1, a.value = "";
+    }, B = (e) => {
+      y.value = e, e && n.value && q(() => {
+        n.value && m(n.value);
+      }), !e && d.value && v(), e || (a.value = "");
+    }, m = (e) => {
+      if (!(e.scrollHeight > e.clientHeight)) {
+        e.classList.remove("is-bottom-overflowing");
+        return;
+      }
+      const l = e.scrollHeight < e.clientHeight + e.scrollTop + 1;
+      e.classList.toggle("is-bottom-overflowing", !l);
+    };
+    return L(() => i.visibilityPreferences, () => {
+      v();
+    }, { immediate: !0 }), T(() => {
+      n.value && (n.value.addEventListener("scroll", (e) => {
+        const t = e.currentTarget;
+        m(t);
+      }), m(n.value));
+    }), H(() => {
+      v();
+    }), (e, t) => (c(), h("div", X, [
+      o(O, {
+        "data-testid": "table-column-visibility-menu",
+        disabled: i.disabled,
+        "kpop-attributes": { placement: "bottom-end" },
+        onToggleDropdown: B
+      }, {
+        items: r(() => [
+          a.value || k.value.length > 5 ? (c(), g(G, {
+            key: 0,
+            modelValue: a.value,
+            "onUpdate:modelValue": t[1] || (t[1] = (l) => a.value = l),
+            modelModifiers: { trim: !0 },
+            autocomplete: "off",
+            class: "search-input",
+            "data-testid": "search-input",
+            placeholder: "Search columns",
+            type: "search",
+            onClick: t[2] || (t[2] = f(() => {
+            }, ["stop"])),
+            onInput: b(I)
+          }, N({
+            before: r(() => [
+              o(b(J), { decorative: "" })
+            ]),
+            _: 2
+          }, [
+            a.value ? {
+              name: "after",
+              fn: r(() => [
+                o(p, {
+                  appearance: "tertiary",
+                  "aria-label": "Clear search",
+                  class: "clear-search",
+                  "data-testid": "clear-search-button",
+                  icon: "",
+                  size: "small",
+                  onClick: t[0] || (t[0] = f(() => a.value = "", ["stop"]))
+                }, {
+                  default: r(() => [
+                    o(b(A), { decorative: "" })
+                  ]),
+                  _: 1
+                })
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1032, ["modelValue", "onInput"])) : K("", !0),
+          w("div", {
+            ref_key: "menuItemsRef",
+            ref: n,
+            class: "menu-items-wrapper"
+          }, [
+            (c(!0), h(P, null, E(k.value, (l) => (c(), g(j, {
+              key: l.key,
+              class: "column-visibility-menu-item",
+              "data-testid": `column-visibility-menu-item-${l.key}`,
+              onClick: f(() => {
+                s.value[l.key] = !s.value[l.key], d.value = !0;
+              }, ["stop"])
+            }, {
+              default: r(() => [
+                o(F, {
+                  modelValue: s.value[l.key],
+                  "onUpdate:modelValue": (M) => s.value[l.key] = M,
+                  "aria-labelledby": `${i.tableId}-${l.key}-visibility-checkbox-label`,
+                  "data-testid": `column-visibility-checkbox-${l.key}`
+                }, null, 8, ["modelValue", "onUpdate:modelValue", "aria-labelledby", "data-testid"]),
+                o(W, {
+                  id: `${i.tableId}-${l.key}-visibility-checkbox-label`,
+                  class: "visibility-checkbox-label",
+                  title: l.label
+                }, {
+                  default: r(() => [
+                    C(U(l.label), 1)
+                  ]),
+                  _: 2
+                }, 1032, ["id", "title"])
+              ]),
+              _: 2
+            }, 1032, ["data-testid", "onClick"]))), 128))
+          ], 512),
+          w("div", Y, [
+            o(p, {
+              appearance: "tertiary",
+              class: "apply-button",
+              "data-testid": "apply-button",
+              onClick: S
+            }, {
+              default: r(() => [...t[3] || (t[3] = [
+                C(" Apply ", -1)
+              ])]),
+              _: 1
+            })
+          ])
+        ]),
+        default: r(() => [
+          o(Q, {
+            placement: "bottom-end",
+            text: y.value ? void 0 : "Show/Hide Columns"
+          }, {
+            default: r(() => [
+              o(p, {
+                appearance: "tertiary",
+                "aria-label": "Show/Hide Columns",
+                class: "menu-button",
+                "data-testid": "column-visibility-menu-button",
+                disabled: i.disabled,
+                icon: "",
+                size: "large"
+              }, {
+                default: r(() => [
+                  o(b(R), { decorative: "" })
+                ]),
+                _: 1
+              }, 8, ["disabled"])
+            ]),
+            _: 1
+          }, 8, ["text"])
+        ]),
+        _: 1
+      }, 8, ["disabled"])
+    ]));
+  }
+});
+export {
+  me as default
+};

package/dist/kongponents.es326.js

@@ -1,54 +1,372 @@
-import { defineComponent as c, computed as n, createElementBlock as m, openBlock as l, createElementVNode as a, normalizeClass as d, createBlock as r, createCommentVNode as u, unref as e, normalizeStyle as f, toDisplayString as p } from "vue";
-import z from "./kongponents.es265.js";
-import k from "./kongponents.es172.js";
-import v from "./kongponents.es189.js";
-import { KUI_ICON_SIZE_40 as o, KUI_COLOR_TEXT_INVERSE as i, KUI_COLOR_TEXT_PRIMARY as x } from "./kongponents.es173.js";
-import { normalizeSize as y } from "./kongponents.es174.js";
-const E = ["aria-current", "data-testid"], C = { class: "step-circle" }, $ = /* @__PURE__ */ c({
-  __name: "KStep",
-  props: {
-    label: {},
-    state: { default: "default" },
-    maxLabelWidth: {}
-  },
-  setup(t) {
-    const s = n(() => ({
-      maxWidth: y(t.maxLabelWidth)
-    }));
-    return (I, S) => (l(), m("li", {
-      "aria-current": t.state === "active" ? "step" : "false",
-      class: "step",
-      "data-testid": `step-${t.state}`
-    }, [
-      a("div", {
-        class: d(["step-container", `${t.state}`])
-      }, [
-        a("div", C, [
-          t.state === "completed" ? (l(), r(e(z), {
-            key: 0,
-            color: `var(--kui-color-text-inverse, ${e(i)})`,
-            size: e(o),
-            title: "Completed"
-          }, null, 8, ["color", "size"])) : t.state === "pending" ? (l(), r(e(v), {
-            key: 1,
-            color: `var(--kui-color-text-primary, ${e(x)})`,
-            size: e(o),
-            title: "Pending"
-          }, null, 8, ["color", "size"])) : t.state === "error" ? (l(), r(e(k), {
-            key: 2,
-            color: `var(--kui-color-text-inverse, ${e(i)})`,
-            size: e(o),
-            title: "Error"
-          }, null, 8, ["color", "size"])) : u("", !0)
-        ]),
-        a("span", {
-          class: "step-label",
-          style: f(s.value)
-        }, p(t.label), 5)
-      ], 2)
-    ], 8, E));
+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.es327.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 {
-  $ as default
+  le as autoPlacement,
+  ie as computePosition,
+  I as detectOverflow,
+  oe as flip,
+  q as rectToClientRect,
+  ae as shift
 };