asiaint-lowcode 3.1.93 → 3.1.95

package/dist/lazy/DragList-zLDHmPDQ.js

@@ -0,0 +1,914 @@
+import { defineComponent as ze, inject as He, ref as ge, reactive as ce, toRef as gt, onBeforeMount as Ge, onMounted as Pe, watchEffect as ct, onBeforeUnmount as Ue, computed as ie, watch as z, openBlock as Q, createElementBlock as fe, normalizeClass as Le, normalizeStyle as je, renderSlot as we, createCommentVNode as ft, nextTick as G, provide as Ne, toRefs as Ee, Fragment as mt, renderList as ht, createBlock as Ke, mergeProps as pt, withCtx as qe, withDirectives as yt, createVNode as Je, vShow as vt, mergeModels as wt, useModel as bt, onUnmounted as xt, unref as Te, readonly as We } from "vue";
+import { o as E, r as D, S as Ie, t as _e, w as zt, m as Mt, V as Rt, c as St, j as Bt, b as Ct, _ as Dt } from "./index-BQVdPFcV.js";
+import "element-plus";
+const Qe = Symbol("LAYOUT_KEY"), Ze = Symbol("EMITTER_KEY");
+function kt(o) {
+  let i = 0, n;
+  for (let e = 0, s = o.length; e < s; e++)
+    n = o[e].y + o[e].h, n > i && (i = n);
+  return i;
+}
+function be(o) {
+  const i = Array(o.length);
+  for (let n = 0, e = o.length; n < e; n++)
+    i[n] = $t(o[n]);
+  return i;
+}
+function $t(o) {
+  return { ...o };
+}
+function et(o, i) {
+  return !(o === i || o.x + o.w <= i.x || o.x >= i.x + i.w || o.y + o.h <= i.y || o.y >= i.y + i.h);
+}
+function J(o, i, n) {
+  const e = at(o), s = ot(o), a = Array(o.length);
+  for (let d = 0, u = s.length; d < u; d++) {
+    let t = s[d];
+    t.static || (t = Ht(e, t, i, n), e.push(t)), a[o.findIndex((S) => S.i === t.i)] = t, t.moved = !1;
+  }
+  return a;
+}
+function Ht(o, i, n, e) {
+  if (n)
+    for (; i.y > 0 && !re(o, i); )
+      i.y--;
+  else if (e) {
+    const a = e[i.i].y;
+    for (; i.y > a && !re(o, i); )
+      i.y--;
+  }
+  let s;
+  for (; s = re(o, i); )
+    i.y = s.y + s.h;
+  return i;
+}
+function Lt(o, i) {
+  const n = at(o);
+  for (let e = 0, s = o.length; e < s; e++) {
+    const a = o[e];
+    if (a.x + a.w > i.cols && (a.x = i.cols - a.w), a.x < 0 && (a.x = 0, a.w = i.cols), !a.static) n.push(a);
+    else
+      for (; re(n, a); )
+        a.y++;
+  }
+  return o;
+}
+function Ae(o, i) {
+  for (let n = 0, e = o.length; n < e; n++)
+    if (o[n].i === i) return o[n];
+}
+function re(o, i) {
+  for (let n = 0, e = o.length; n < e; n++)
+    if (et(o[n], i)) return o[n];
+}
+function tt(o, i) {
+  return o.filter((n) => et(n, i));
+}
+function at(o) {
+  return o.filter((i) => i.static);
+}
+function xe(o, i, n, e, s = !1, a = !1) {
+  if (i.static) return o;
+  const d = i.x, u = i.y, t = e && i.y > e;
+  typeof n == "number" && (i.x = n), typeof e == "number" && (i.y = e), i.moved = !0;
+  let S = ot(o);
+  t && (S = S.reverse());
+  const k = tt(S, i);
+  if (a && k.length)
+    return i.x = d, i.y = u, i.moved = !1, o;
+  for (let h = 0, y = k.length; h < y; h++) {
+    const b = k[h];
+    b.moved || i.y > b.y && i.y - b.y > b.h / 4 || (b.static ? o = Oe(o, b, i, s) : o = Oe(o, i, b, s));
+  }
+  return o;
+}
+function Oe(o, i, n, e) {
+  if (e) {
+    const s = {
+      x: n.x,
+      y: n.y,
+      w: n.w,
+      h: n.h
+    };
+    if (s.y = Math.max(i.y - n.h, 0), !re(o, s))
+      return xe(o, n, void 0, s.y, !1);
+  }
+  return xe(o, n, void 0, n.y + 1, !1);
+}
+function Nt(o, i, n, e) {
+  const s = "translate3d(" + i + "px," + o + "px, 0)";
+  return {
+    transform: s,
+    WebkitTransform: s,
+    MozTransform: s,
+    msTransform: s,
+    OTransform: s,
+    width: n + "px",
+    height: e + "px",
+    position: "absolute"
+  };
+}
+function Et(o, i, n, e) {
+  const s = "translate3d(" + i * -1 + "px," + o + "px, 0)";
+  return {
+    transform: s,
+    WebkitTransform: s,
+    MozTransform: s,
+    msTransform: s,
+    OTransform: s,
+    width: n + "px",
+    height: e + "px",
+    position: "absolute"
+  };
+}
+function Tt(o, i, n, e) {
+  return {
+    top: o + "px",
+    left: i + "px",
+    width: n + "px",
+    height: e + "px",
+    position: "absolute"
+  };
+}
+function Wt(o, i, n, e) {
+  return {
+    top: o + "px",
+    right: i + "px",
+    width: n + "px",
+    height: e + "px",
+    position: "absolute"
+  };
+}
+function ot(o) {
+  return Array.from(o).sort(function(i, n) {
+    return i.y === n.y && i.x === n.x ? 0 : i.y > n.y || i.y === n.y && i.x > n.x ? 1 : -1;
+  });
+}
+function It(o, i) {
+  i = i || "Layout";
+  const n = ["x", "y", "w", "h"], e = [];
+  if (!Array.isArray(o)) throw new Error(i + " must be an array!");
+  for (let s = 0, a = o.length; s < a; s++) {
+    const d = o[s];
+    for (let u = 0; u < n.length; u++)
+      if (typeof d[n[u]] != "number")
+        throw new Error(
+          "VueGridLayout: " + i + "[" + s + "]." + n[u] + " must be a number!"
+        );
+    if (d.i === void 0 || d.i === null)
+      throw new Error("VueGridLayout: " + i + "[" + s + "].i cannot be null!");
+    if (typeof d.i != "number" && typeof d.i != "string")
+      throw new Error("VueGridLayout: " + i + "[" + s + "].i must be a string or number!");
+    if (e.indexOf(d.i) >= 0)
+      throw new Error("VueGridLayout: " + i + "[" + s + "].i must be unique!");
+    if (e.push(d.i), d.static !== void 0 && typeof d.static != "boolean")
+      throw new Error("VueGridLayout: " + i + "[" + s + "].static must be a boolean!");
+  }
+}
+function _t(o, i = "vgl") {
+  const n = () => `${i}-${o}`;
+  return {
+    b: n,
+    be: (e) => `${n()}__${e}`,
+    bm: (e) => `${n()}--${e}`,
+    bem: (e, s) => `${n()}__${e}--${s}`
+  };
+}
+function Ye(o) {
+  return At(o);
+}
+function At(o) {
+  var i;
+  const n = ((i = o.target) == null ? void 0 : i.offsetParent) || document.body, e = o.offsetParent === document.body ? { left: 0, top: 0 } : n.getBoundingClientRect(), s = o.clientX + n.scrollLeft - e.left, a = o.clientY + n.scrollTop - e.top;
+  return { x: s, y: a };
+}
+function Fe(o, i, n, e) {
+  return Ot(o) ? {
+    deltaX: n - o,
+    deltaY: e - i,
+    lastX: o,
+    lastY: i,
+    x: n,
+    y: e
+  } : {
+    deltaX: 0,
+    deltaY: 0,
+    lastX: n,
+    lastY: e,
+    x: n,
+    y: e
+  };
+}
+function Ot(o) {
+  return typeof o == "number" && !Number.isNaN(o);
+}
+function Yt(o, i) {
+  const n = rt(o);
+  let e = n[0];
+  for (let s = 1, a = n.length; s < a; s++) {
+    const d = n[s];
+    i > o[d] && (e = d);
+  }
+  return e;
+}
+function it(o, i) {
+  if (!i[o])
+    throw new Error(
+      "ResponsiveGridLayout: `cols` entry for breakpoint " + o + " is missing!"
+    );
+  return i[o];
+}
+function Ft(o, i, n, e, s, a, d) {
+  if (i[e]) return be(i[e]);
+  let u = o;
+  const t = rt(n), S = t.slice(t.indexOf(e));
+  for (let k = 0, h = S.length; k < h; k++) {
+    const y = S[k];
+    if (i[y]) {
+      u = i[y];
+      break;
+    }
+  }
+  return u = be(u || []), J(Lt(u, { cols: a }), d);
+}
+function rt(o) {
+  return Object.keys(o).sort((i, n) => o[i] - o[n]);
+}
+let Vt = "auto";
+function Xt() {
+  return typeof document < "u";
+}
+function Ve() {
+  return Xt() ? typeof document.dir < "u" ? document.dir : document.getElementsByTagName("html")[0].getAttribute("dir") : Vt;
+}
+const Xe = /* @__PURE__ */ ze({
+  __name: "grid-item",
+  props: {
+    isDraggable: { type: Boolean, default: void 0 },
+    isResizable: { type: Boolean, default: void 0 },
+    isBounded: { type: Boolean, default: void 0 },
+    static: { type: Boolean, default: !1 },
+    minH: { default: 1 },
+    minW: { default: 1 },
+    maxH: { default: 1 / 0 },
+    maxW: { default: 1 / 0 },
+    x: {},
+    y: {},
+    w: {},
+    h: {},
+    i: {},
+    dragIgnoreFrom: { default: "a, button" },
+    dragAllowFrom: { default: void 0 },
+    resizeIgnoreFrom: { default: "a, button" },
+    preserveAspectRatio: { type: Boolean, default: !1 },
+    dragOption: { default: () => ({}) },
+    resizeOption: { default: () => ({}) }
+  },
+  emits: ["container-resized", "resize", "resized", "move", "moved"],
+  setup(o, { expose: i, emit: n }) {
+    const e = o, s = n, a = He(Qe), d = He(Ze);
+    if (!a)
+      throw new Error("[grid-layout-plus]: missing layout store, GridItem must under a GridLayout.");
+    const u = ge(null), t = ce({
+      cols: 1,
+      containerWidth: 100,
+      rowHeight: 30,
+      margin: [10, 10],
+      maxRows: 1 / 0,
+      draggable: void 0,
+      resizable: void 0,
+      bounded: void 0,
+      transformScale: 1,
+      useCssTransforms: !0,
+      useStyleCursor: !0,
+      isDragging: !1,
+      dragging: {
+        top: -1,
+        left: -1
+      },
+      isResizing: !1,
+      resizing: {
+        width: -1,
+        height: -1
+      },
+      style: {},
+      rtl: !1
+    });
+    let S = !1, k = !1, h = NaN, y = NaN, b = NaN, $ = NaN, P = -1, ne = -1, Z = -1, Y = -1, B = e.x, I = e.y, C = e.w, T = e.h;
+    const V = ge(), se = ce({
+      i: gt(e, "i"),
+      state: t,
+      wrapper: V,
+      calcXY: Se
+    });
+    function ee(r) {
+      lt(r);
+    }
+    function le() {
+      De();
+    }
+    function l(r) {
+      E(e.isDraggable) && (t.draggable = r);
+    }
+    function x(r) {
+      E(e.isResizable) && (t.resizable = r);
+    }
+    function v(r) {
+      E(e.isBounded) && (t.bounded = r);
+    }
+    function W(r) {
+      t.transformScale = r;
+    }
+    function H(r) {
+      t.rowHeight = r;
+    }
+    function L(r) {
+      t.maxRows = r;
+    }
+    function f() {
+      t.rtl = Ve() === "rtl", De();
+    }
+    function X(r) {
+      t.cols = Math.floor(r);
+    }
+    a.increaseItem(se), Ge(() => {
+      t.rtl = Ve() === "rtl";
+    }), Pe(() => {
+      a.responsive && a.lastBreakpoint ? t.cols = it(a.lastBreakpoint, a.cols) : t.cols = a.colNum, t.rowHeight = a.rowHeight, t.containerWidth = a.width !== null ? a.width : 100, t.margin = a.margin !== void 0 ? a.margin.map(Number) : [10, 10], t.maxRows = a.maxRows, E(e.isDraggable) ? t.draggable = a.isDraggable : t.draggable = e.isDraggable, E(e.isResizable) ? t.resizable = a.isResizable : t.resizable = e.isResizable, E(e.isBounded) ? t.bounded = a.isBounded : t.bounded = e.isBounded, t.transformScale = a.transformScale, t.useCssTransforms = a.useCssTransforms, t.useStyleCursor = a.useStyleCursor, ct(() => {
+        B = e.x, I = e.y, T = e.h, C = e.w, D(K);
+      }), d.on("updateWidth", ee), d.on("compact", le), d.on("setDraggable", l), d.on("setResizable", x), d.on("setBounded", v), d.on("setTransformScale", W), d.on("setRowHeight", H), d.on("setMaxRows", L), d.on("directionchange", f), d.on("setColNum", X);
+    }), Ue(() => {
+      d.off("updateWidth", ee), d.off("compact", le), d.off("setDraggable", l), d.off("setResizable", x), d.off("setBounded", v), d.off("setTransformScale", W), d.off("setRowHeight", H), d.off("setMaxRows", L), d.off("directionchange", f), d.off("setColNum", X), u.value && (u.value.unset(), u.value = null), a.decreaseItem(se);
+    }), i({ state: t, wrapper: V });
+    const U = typeof navigator < "u" ? navigator.userAgent.toLowerCase().includes("android") : !1, _ = ie(() => t.resizable && !e.static), M = ie(() => a.isMirrored ? !t.rtl : t.rtl), j = ie(() => (t.draggable || t.resizable) && !e.static), O = _t("item"), nt = ie(() => ({
+      [O.b()]: !0,
+      [O.bm("resizable")]: _.value,
+      [O.bm("static")]: e.static,
+      [O.bm("resizing")]: t.isResizing,
+      [O.bm("dragging")]: t.isDragging,
+      [O.bm("transform")]: t.useCssTransforms,
+      [O.bm("rtl")]: M.value,
+      [O.bm("no-touch")]: U && j.value
+    })), ue = ie(() => [O.be("resizer"), M.value && O.bem("resizer", "rtl")].filter(Boolean));
+    z(
+      () => e.isDraggable,
+      (r) => {
+        t.draggable = r;
+      }
+    ), z(
+      () => e.static,
+      () => {
+        D($e), D(q);
+      }
+    ), z(
+      () => t.draggable,
+      () => {
+        D($e);
+      }
+    ), z(
+      () => e.isResizable,
+      (r) => {
+        t.resizable = r;
+      }
+    ), z(
+      () => e.isBounded,
+      (r) => {
+        t.bounded = r;
+      }
+    ), z(
+      () => t.resizable,
+      () => {
+        D(q);
+      }
+    ), z(
+      () => t.rowHeight,
+      () => {
+        D(K), D(me);
+      }
+    ), z([() => t.cols, () => t.containerWidth], () => {
+      D(q), D(K), D(me);
+    }), z([() => e.minH, () => e.maxH, () => e.minW, () => e.maxW], () => {
+      D(q);
+    }), z(M, () => {
+      D(q), D(K);
+    }), z([() => a.margin, () => a.margin[0], () => a.margin[1]], () => {
+      const r = a.margin;
+      !r || r[0] === t.margin[0] && r[1] === t.margin[1] || (t.margin = r.map(Number), D(K), D(me));
+    });
+    function K() {
+      e.x + e.w > t.cols ? (B = 0, C = e.w > t.cols ? t.cols : e.w) : (B = e.x, C = e.w);
+      const r = te(B, I, C, T);
+      t.isDragging && (r.top = t.dragging.top, M.value ? r.right = t.dragging.left : r.left = t.dragging.left), t.isResizing && (r.width = t.resizing.width, r.height = t.resizing.height);
+      let c;
+      t.useCssTransforms ? M.value ? c = Et(r.top, r.right, r.width, r.height) : c = Nt(r.top, r.left, r.width, r.height) : M.value ? c = Wt(r.top, r.right, r.width, r.height) : c = Tt(r.top, r.left, r.width, r.height), t.style = c;
+    }
+    function me() {
+      const r = {};
+      for (const c of ["width", "height"]) {
+        const p = t.style[c].match(/^(\d+)px$/);
+        if (!p)
+          return;
+        r[c] = p[1];
+      }
+      s("container-resized", e.i, e.h, e.w, r.height, r.width);
+    }
+    function Me(r) {
+      if (e.static) return;
+      const c = r.type;
+      if (c === "resizestart" && t.isResizing || c !== "resizestart" && !t.isResizing)
+        return;
+      const p = Ye(r);
+      if (E(p)) return;
+      const { x: w, y: R } = p, m = { width: 0, height: 0 };
+      let g;
+      switch (c) {
+        case "resizestart": {
+          q(), P = C, ne = T, g = te(B, I, C, T), m.width = g.width, m.height = g.height, t.resizing = m, t.isResizing = !0;
+          break;
+        }
+        case "resizemove": {
+          !r.edges.right && !r.edges.left && (b = w), !r.edges.top && !r.edges.bottom && ($ = R);
+          const N = Fe(b, $, w, R);
+          M.value ? m.width = t.resizing.width - N.deltaX / t.transformScale : m.width = t.resizing.width + N.deltaX / t.transformScale, m.height = t.resizing.height + N.deltaY / t.transformScale, t.resizing = m;
+          break;
+        }
+        case "resizeend": {
+          g = te(B, I, C, T), m.width = g.width, m.height = g.height, t.resizing = { width: -1, height: -1 }, t.isResizing = !1;
+          break;
+        }
+      }
+      g = st(m.height, m.width), g.w < e.minW && (g.w = e.minW), g.w > e.maxW && (g.w = e.maxW), g.h < e.minH && (g.h = e.minH), g.h > e.maxH && (g.h = e.maxH), g.h < 1 && (g.h = 1), g.w < 1 && (g.w = 1), b = w, $ = R, (C !== g.w || T !== g.h) && s("resize", e.i, g.h, g.w, m.height, m.width), r.type === "resizeend" && (P !== C || ne !== T) && s("resized", e.i, g.h, g.w, m.height, m.width), d.emit("resizeEvent", r.type, e.i, B, I, g.h, g.w);
+    }
+    function Re(r) {
+      if (e.static || t.isResizing) return;
+      const c = r.type;
+      if (c === "dragstart" && t.isDragging || c !== "dragstart" && !t.isDragging)
+        return;
+      const p = Ye(r);
+      if (E(p)) return;
+      const { x: w, y: R } = p, m = r.target;
+      if (!m.offsetParent) return;
+      const g = { top: 0, left: 0 };
+      switch (c) {
+        case "dragstart": {
+          Z = B, Y = I;
+          const A = m.offsetParent.getBoundingClientRect(), F = m.getBoundingClientRect(), ae = F.left / t.transformScale, oe = A.left / t.transformScale, he = F.right / t.transformScale, pe = A.right / t.transformScale, ye = F.top / t.transformScale, ve = A.top / t.transformScale;
+          M.value ? g.left = (he - pe) * -1 : g.left = ae - oe, g.top = ye - ve, t.dragging = g, t.isDragging = !0;
+          break;
+        }
+        case "dragmove": {
+          const A = Fe(h, y, w, R);
+          if (M.value ? g.left = t.dragging.left - A.deltaX / t.transformScale : g.left = t.dragging.left + A.deltaX / t.transformScale, g.top = t.dragging.top + A.deltaY / t.transformScale, t.bounded) {
+            const F = m.offsetParent.clientHeight - Be(e.h, t.rowHeight, t.margin[1]);
+            g.top = Ce(g.top, 0, F);
+            const ae = de(), oe = t.containerWidth - Be(e.w, ae, t.margin[0]);
+            g.left = Ce(g.left, 0, oe);
+          }
+          t.dragging = g;
+          break;
+        }
+        case "dragend": {
+          const A = m.offsetParent.getBoundingClientRect(), F = m.getBoundingClientRect(), ae = F.left / t.transformScale, oe = A.left / t.transformScale, he = F.right / t.transformScale, pe = A.right / t.transformScale, ye = F.top / t.transformScale, ve = A.top / t.transformScale;
+          M.value ? g.left = (he - pe) * -1 : g.left = ae - oe, g.top = ye - ve, t.dragging = { top: -1, left: -1 }, t.isDragging = !1;
+          break;
+        }
+      }
+      let N;
+      M.value, N = Se(g.top, g.left), h = w, y = R, (B !== N.x || I !== N.y) && s("move", e.i, N.x, N.y), r.type === "dragend" && (Z !== B || Y !== I) && s("moved", e.i, N.x, N.y), d.emit("dragEvent", r.type, e.i, N.x, N.y, T, C);
+    }
+    function te(r, c, p, w) {
+      const R = de();
+      let m;
+      return M.value ? m = {
+        right: Math.round(R * r + (r + 1) * t.margin[0]),
+        top: Math.round(t.rowHeight * c + (c + 1) * t.margin[1]),
+        // 0 * Infinity === NaN, which causes problems with resize constraints;
+        // Fix this if it occurs.
+        // Note we do it here rather than later because Math.round(Infinity) causes depot
+        width: p === 1 / 0 ? p : Math.round(R * p + Math.max(0, p - 1) * t.margin[0]),
+        height: w === 1 / 0 ? w : Math.round(t.rowHeight * w + Math.max(0, w - 1) * t.margin[1])
+      } : m = {
+        left: Math.round(R * r + (r + 1) * t.margin[0]),
+        top: Math.round(t.rowHeight * c + (c + 1) * t.margin[1]),
+        // 0 * Infinity === NaN, which causes problems with resize constraints;
+        // Fix this if it occurs.
+        // Note we do it here rather than later because Math.round(Infinity) causes depot
+        width: p === 1 / 0 ? p : Math.round(R * p + Math.max(0, p - 1) * t.margin[0]),
+        height: w === 1 / 0 ? w : Math.round(t.rowHeight * w + Math.max(0, w - 1) * t.margin[1])
+      }, m;
+    }
+    function Se(r, c) {
+      const p = de();
+      let w = Math.round((c - t.margin[0]) / (p + t.margin[0])), R = Math.round((r - t.margin[1]) / (t.rowHeight + t.margin[1]));
+      return w = Math.max(Math.min(w, t.cols - C), 0), R = Math.max(Math.min(R, t.maxRows - T), 0), { x: w, y: R };
+    }
+    function de() {
+      return (t.containerWidth - t.margin[0] * (t.cols + 1)) / t.cols;
+    }
+    function Be(r, c, p) {
+      return Number.isFinite(r) ? Math.round(c * r + Math.max(0, r - 1) * p) : r;
+    }
+    function Ce(r, c, p) {
+      return Math.max(Math.min(r, p), c);
+    }
+    function st(r, c, p = !1) {
+      const w = de();
+      let R = Math.round((c + t.margin[0]) / (w + t.margin[0])), m = 0;
+      return p ? m = Math.ceil((r + t.margin[1]) / (t.rowHeight + t.margin[1])) : m = Math.round((r + t.margin[1]) / (t.rowHeight + t.margin[1])), R = Math.max(Math.min(R, t.cols - B), 0), m = Math.max(Math.min(m, t.maxRows - I), 0), { w: R, h: m };
+    }
+    function lt(r, c) {
+      t.containerWidth = r;
+    }
+    function De() {
+      K();
+    }
+    function ke() {
+      !u.value && V.value && (u.value = Ie(V.value), t.useStyleCursor || u.value.styleCursor(!1));
+    }
+    const ut = _e(Re);
+    function $e() {
+      if (ke(), !!u.value)
+        if (t.draggable && !e.static) {
+          const r = {
+            ignoreFrom: e.dragIgnoreFrom,
+            allowFrom: e.dragAllowFrom,
+            ...e.dragOption
+          };
+          u.value.draggable(r), S || (S = !0, u.value.on("dragstart dragmove dragend", (c) => {
+            c.type === "dragmove" ? ut(c) : Re(c);
+          }));
+        } else
+          u.value.draggable({ enabled: !1 });
+    }
+    const dt = _e(Me);
+    function q() {
+      if (ke(), !!u.value)
+        if (t.resizable && !e.static) {
+          const r = te(0, 0, e.maxW, e.maxH), c = te(0, 0, e.minW, e.minH), p = {
+            edges: {
+              left: M.value ? `.${ue.value[0]}` : !1,
+              right: M.value ? !1 : `.${ue.value[0]}`,
+              bottom: `.${ue.value[0]}`,
+              top: !1
+            },
+            ignoreFrom: e.resizeIgnoreFrom,
+            restrictSize: {
+              min: {
+                height: c.height * t.transformScale,
+                width: c.width * t.transformScale
+              },
+              max: {
+                height: r.height * t.transformScale,
+                width: r.width * t.transformScale
+              }
+            },
+            ...e.resizeOption
+          };
+          e.preserveAspectRatio && (p.modifiers = [Ie.modifiers.aspectRatio({ ratio: "preserve" })]), u.value.resizable(p), k || (k = !0, u.value.on("resizestart resizemove resizeend", (w) => {
+            w.type === "resizemove" ? dt(w) : Me(w);
+          }));
+        } else
+          u.value.resizable({ enabled: !1 });
+    }
+    return (r, c) => (Q(), fe("section", {
+      ref_key: "wrapper",
+      ref: V,
+      class: Le(nt.value),
+      style: je(t.style)
+    }, [
+      we(r.$slots, "default"),
+      _.value ? (Q(), fe("span", {
+        key: 0,
+        class: Le(ue.value)
+      }, null, 2)) : ft("", !0)
+    ], 6));
+  }
+}), Gt = /* @__PURE__ */ ze({
+  __name: "grid-layout",
+  props: {
+    autoSize: { type: Boolean, default: !0 },
+    colNum: { default: 12 },
+    rowHeight: { default: 150 },
+    maxRows: { default: 1 / 0 },
+    margin: { default: () => [10, 10] },
+    isDraggable: { type: Boolean, default: !0 },
+    isResizable: { type: Boolean, default: !0 },
+    isMirrored: { type: Boolean, default: !1 },
+    isBounded: { type: Boolean, default: !1 },
+    useCssTransforms: { type: Boolean, default: !0 },
+    verticalCompact: { type: Boolean, default: !0 },
+    restoreOnDrag: { type: Boolean, default: !1 },
+    layout: {},
+    responsive: { type: Boolean, default: !1 },
+    responsiveLayouts: { default: () => ({}) },
+    transformScale: { default: 1 },
+    breakpoints: { default: () => ({ lg: 1200, md: 996, sm: 768, xs: 480, xxs: 0 }) },
+    cols: { default: () => ({ lg: 12, md: 10, sm: 6, xs: 4, xxs: 2 }) },
+    preventCollision: { type: Boolean, default: !1 },
+    useStyleCursor: { type: Boolean, default: !0 }
+  },
+  emits: [
+    "layout-before-mount",
+    "layout-mounted",
+    "layout-updated",
+    "breakpoint-changed",
+    "update:layout",
+    "layout-ready"
+  ],
+  setup(o, { expose: i, emit: n }) {
+    const e = o, s = n, a = ce({
+      width: -1,
+      mergedStyle: {},
+      lastLayoutLength: 0,
+      isDragging: !1,
+      placeholder: {
+        x: 0,
+        y: 0,
+        w: 0,
+        h: 0,
+        i: ""
+      },
+      layouts: {},
+      // array to store all layouts from different breakpoints
+      lastBreakpoint: null,
+      // store last active breakpoint
+      originalLayout: null
+      // store original Layout
+    }), d = /* @__PURE__ */ new Map(), u = ge(e.layout), t = ge(), { observeResize: S, unobserveResize: k } = zt(), h = Rt();
+    h.on("resizeEvent", y), h.on("dragEvent", b), Ge(() => {
+      s("layout-before-mount", u.value);
+    }), Pe(() => {
+      s("layout-mounted", u.value), G(() => {
+        It(u.value), a.originalLayout = u.value, G(() => {
+          ee(), t.value && S(t.value, Mt(B, 16)), J(u.value, e.verticalCompact), s("layout-updated", u.value), Y(), B();
+        });
+      });
+    }), Ue(() => {
+      h.clearAll(), t.value && k(t.value);
+    });
+    function y(l, x, v, W, H, L) {
+      V(l, x, v, W, H, L);
+    }
+    function b(l, x, v, W, H, L) {
+      T(l, x, v, W, H, L);
+    }
+    z(
+      () => a.width,
+      (l, x) => {
+        G(() => {
+          h.emit("updateWidth", l), x === -1 && G(() => {
+            s("layout-ready", u.value);
+          }), Y();
+        });
+      }
+    ), z(
+      () => [e.layout, e.layout.length],
+      () => {
+        u.value = e.layout, Z();
+      }
+    ), z(
+      () => e.colNum,
+      (l) => {
+        h.emit("setColNum", l);
+      }
+    ), z(
+      () => e.rowHeight,
+      (l) => {
+        h.emit("setRowHeight", l);
+      }
+    ), z(
+      () => e.isDraggable,
+      (l) => {
+        h.emit("setDraggable", l);
+      }
+    ), z(
+      () => e.isResizable,
+      (l) => {
+        h.emit("setResizable", l);
+      }
+    ), z(
+      () => e.isBounded,
+      (l) => {
+        h.emit("setBounded", l);
+      }
+    ), z(
+      () => e.transformScale,
+      (l) => {
+        h.emit("setTransformScale", l);
+      }
+    ), z(
+      () => e.responsive,
+      (l) => {
+        l || (s("update:layout", a.originalLayout), h.emit("setColNum", e.colNum)), B();
+      }
+    ), z(
+      () => e.maxRows,
+      (l) => {
+        h.emit("setMaxRows", l);
+      }
+    ), z([() => e.margin, () => e.margin[1]], Y), Ne(
+      Qe,
+      ce({
+        ...Ee(e),
+        ...Ee(a),
+        increaseItem: $,
+        decreaseItem: P
+      })
+    ), Ne(Ze, h), i({ state: a, getItem: ne, resizeEvent: V, dragEvent: T, layoutUpdate: Z });
+    function $(l) {
+      d.set(l.i, l);
+    }
+    function P(l) {
+      d.delete(l.i);
+    }
+    function ne(l) {
+      return d.get(l);
+    }
+    function Z() {
+      if (!E(u.value) && !E(a.originalLayout)) {
+        if (u.value.length !== a.originalLayout.length) {
+          const l = le(u.value, a.originalLayout);
+          if (l.length > 0)
+            if (u.value.length > a.originalLayout.length)
+              a.originalLayout = a.originalLayout.concat(l);
+            else {
+              const x = new Set(l.map((v) => v.i));
+              a.originalLayout = a.originalLayout.filter((v) => !x.has(v.i));
+            }
+          a.lastLayoutLength = u.value.length, ee();
+        }
+        J(u.value, e.verticalCompact), h.emit("updateWidth", a.width), Y(), s("layout-updated", u.value);
+      }
+    }
+    function Y() {
+      a.mergedStyle = {
+        height: I()
+      };
+    }
+    function B() {
+      t.value && (a.width = t.value.offsetWidth), h.emit("resizeEvent");
+    }
+    function I() {
+      if (!e.autoSize) return;
+      const l = parseFloat(e.margin[1]);
+      return kt(u.value) * (e.rowHeight + l) + l + "px";
+    }
+    let C;
+    function T(l, x, v, W, H, L) {
+      let f = Ae(u.value, x);
+      E(f) && (f = { h: 0, w: 0, x: 0, y: 0, i: "" }), l === "dragstart" && !e.verticalCompact && (C = u.value.reduce(
+        (X, { i: U, x: _, y: M }) => ({
+          ...X,
+          [U]: { x: _, y: M }
+        }),
+        {}
+      )), l === "dragmove" || l === "dragstart" ? (a.placeholder.i = x, a.placeholder.x = f.x, a.placeholder.y = f.y, a.placeholder.w = L, a.placeholder.h = H, G(() => {
+        a.isDragging = !0;
+      }), h.emit("updateWidth", a.width)) : G(() => {
+        a.isDragging = !1;
+      }), u.value = xe(u.value, f, v, W, !0, e.preventCollision), e.restoreOnDrag ? (f.static = !0, J(u.value, e.verticalCompact, C), f.static = !1) : J(u.value, e.verticalCompact), h.emit("compact"), Y(), l === "dragend" && (C = void 0, s("layout-updated", u.value));
+    }
+    function V(l, x, v, W, H, L) {
+      let f = Ae(u.value, x);
+      E(f) && (f = { h: 0, w: 0, x: 0, y: 0, i: "" });
+      let X;
+      if (e.preventCollision) {
+        const U = tt(u.value, { ...f, w: L, h: H }).filter(
+          (_) => _.i !== f.i
+        );
+        if (X = U.length > 0, X) {
+          let _ = 1 / 0, M = 1 / 0;
+          U.forEach((j) => {
+            j.x > f.x && (_ = Math.min(_, j.x)), j.y > f.y && (M = Math.min(M, j.y));
+          }), Number.isFinite(_) && (f.w = _ - f.x), Number.isFinite(M) && (f.h = M - f.y);
+        }
+      }
+      X || (f.w = L, f.h = H), l === "resizestart" || l === "resizemove" ? (a.placeholder.i = x, a.placeholder.x = v, a.placeholder.y = W, a.placeholder.w = f.w, a.placeholder.h = f.h, G(() => {
+        a.isDragging = !0;
+      }), h.emit("updateWidth", a.width)) : l && G(() => {
+        a.isDragging = !1;
+      }), e.responsive && se(), J(u.value, e.verticalCompact), h.emit("compact"), Y(), l === "resizeend" && s("layout-updated", u.value);
+    }
+    function se() {
+      const l = Yt(e.breakpoints, a.width);
+      if (l === a.lastBreakpoint)
+        return;
+      const x = it(l, e.cols);
+      !E(a.lastBreakpoint) && !a.layouts[a.lastBreakpoint] && (a.layouts[a.lastBreakpoint] = be(u.value));
+      const v = Ft(
+        a.originalLayout,
+        a.layouts,
+        e.breakpoints,
+        l,
+        a.lastBreakpoint,
+        x,
+        e.verticalCompact
+      );
+      a.layouts[l] = v, a.lastBreakpoint !== l && s("breakpoint-changed", l, v), u.value = v, s("update:layout", v), a.lastBreakpoint = l, h.emit("setColNum", x);
+    }
+    function ee() {
+      a.layouts = Object.assign({}, e.responsiveLayouts);
+    }
+    function le(l, x) {
+      const v = new Set(x.map((f) => f.i)), W = new Set(l.map((f) => f.i)), H = l.filter((f) => !v.has(f.i)), L = x.filter((f) => !W.has(f.i));
+      return H.concat(L);
+    }
+    return (l, x) => (Q(), fe("div", {
+      ref_key: "wrapper",
+      ref: t,
+      class: "vgl-layout",
+      style: je(a.mergedStyle)
+    }, [
+      l.$slots.default ? we(l.$slots, "default", { key: 0 }) : (Q(!0), fe(mt, { key: 1 }, ht(u.value, (v) => (Q(), Ke(Xe, pt({
+        key: v.i,
+        ref_for: !0
+      }, v), {
+        default: qe(() => [
+          we(l.$slots, "item", { item: v })
+        ]),
+        _: 2
+      }, 1040))), 128)),
+      yt(Je(Xe, {
+        class: "vgl-item--placeholder",
+        x: a.placeholder.x,
+        y: a.placeholder.y,
+        w: a.placeholder.w,
+        h: a.placeholder.h,
+        i: a.placeholder.i
+      }, null, 8, ["x", "y", "w", "h", "i"]), [
+        [vt, a.isDragging]
+      ])
+    ], 4));
+  }
+}), Pt = /* @__PURE__ */ ze({
+  __name: "DragList",
+  props: /* @__PURE__ */ wt({
+    children: {},
+    rowHeight: {},
+    colNum: {},
+    maxRows: {},
+    isDraggable: { type: Boolean },
+    name: {},
+    onMoved: {}
+  }, {
+    gridlayout: { required: !0 },
+    gridlayoutModifiers: {}
+  }),
+  emits: ["update:gridlayout"],
+  setup(o, { expose: i }) {
+    const n = o, e = bt(o, "gridlayout"), t = {
+      getLayout: () => We(e),
+      setItemX: (y, b) => {
+        e.value[y].x = b;
+      },
+      setItemY: (y, b) => {
+        e.value[y].y = b;
+      },
+      setItemVisible: (y, b) => {
+        const $ = e.value.find((P) => P.i === y);
+        $ && ($.h = b ? $.contentHeight || 1 : 0);
+      },
+      type: "draglist"
+    }, { ruleModule: S, pageMethodMap: k } = St(), h = () => {
+      if (n.onMoved && S)
+        try {
+          S[n.onMoved](k, We(e.value));
+        } catch (y) {
+          console.error(y + `
+onMoved: ${n.onMoved}`);
+        }
+    };
+    if (i(t), n.name) {
+      const y = Bt(n.name, t);
+      xt(() => {
+        y();
+      });
+    }
+    return (y, b) => (Q(), Ke(Te(Gt), {
+      layout: e.value,
+      "onUpdate:layout": b[1] || (b[1] = ($) => e.value = $),
+      "col-num": y.colNum || 12,
+      "row-height": y.rowHeight || 30,
+      "max-rows": y.maxRows,
+      margin: [8, 8],
+      "is-draggable": y.isDraggable,
+      "is-bounded": "",
+      "is-resizable": !1,
+      "vertical-compact": "",
+      "use-css-transforms": ""
+    }, {
+      default: qe(() => [
+        Je(Te(Ct), {
+          list: y.children,
+          gridData: e.value,
+          "onUpdate:gridData": b[0] || (b[0] = ($) => e.value = $),
+          onGridItemMoved: h
+        }, null, 8, ["list", "gridData"])
+      ]),
+      _: 1
+    }, 8, ["layout", "col-num", "row-height", "max-rows", "is-draggable"]));
+  }
+}), qt = /* @__PURE__ */ Dt(Pt, [["__scopeId", "data-v-869881f7"]]);
+export {
+  qt as default
+};