asiaint-lowcode 3.1.29 → 3.1.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asiaint-lowcode",
-  "version": "3.1.29",
+  "version": "3.1.32",
   "private": false,
   "type": "module",
   "scripts": {

package/dist/lazy/DragList-B0bZTVHu.js

@@ -1,328 +0,0 @@
-import { defineComponent as G, reactive as W, ref as F, onBeforeMount as le, onMounted as ie, nextTick as v, onBeforeUnmount as re, watch as u, provide as T, toRefs as V, openBlock as S, createElementBlock as j, normalizeStyle as ne, renderSlot as q, Fragment as se, renderList as ue, createBlock as P, mergeProps as de, withCtx as J, withDirectives as ce, createVNode as K, vShow as me, mergeModels as pe, useModel as ge, onUnmounted as ye, unref as A, readonly as O } from "vue";
-import { w as ve, m as fe, n as he, o as b, T as we, v as xe, p as k, A as Be, q as X, x as be, L as ke, y as Ce, r as De, Y as Le, s as Me, t as Y, V as Se, c as ze, j as Re, a as Ne, b as $e } from "./index-Cg7LKdr9.js";
-import "element-plus";
-const Ie = /* @__PURE__ */ G({
-  __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(C, { expose: z, emit: f }) {
-    const a = C, s = f, t = W({
-      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(), l = F(a.layout), d = F(), { observeResize: R, unobserveResize: N } = ve(), o = Se();
-    o.on("resizeEvent", c), o.on("dragEvent", x), le(() => {
-      s("layout-before-mount", l.value);
-    }), ie(() => {
-      s("layout-mounted", l.value), v(() => {
-        fe(l.value), t.originalLayout = l.value, v(() => {
-          U(), d.value && R(d.value, he($, 16)), b(l.value, a.verticalCompact), s("layout-updated", l.value), h(), $();
-        });
-      });
-    }), re(() => {
-      o.clearAll(), d.value && N(d.value);
-    });
-    function c(e, n, r, g, m, p) {
-      H(e, n, r, g, m, p);
-    }
-    function x(e, n, r, g, m, p) {
-      _(e, n, r, g, m, p);
-    }
-    u(
-      () => t.width,
-      (e, n) => {
-        v(() => {
-          o.emit("updateWidth", e), n === -1 && v(() => {
-            s("layout-ready", l.value);
-          }), h();
-        });
-      }
-    ), u(
-      () => [a.layout, a.layout.length],
-      () => {
-        l.value = a.layout, E();
-      }
-    ), u(
-      () => a.colNum,
-      (e) => {
-        o.emit("setColNum", e);
-      }
-    ), u(
-      () => a.rowHeight,
-      (e) => {
-        o.emit("setRowHeight", e);
-      }
-    ), u(
-      () => a.isDraggable,
-      (e) => {
-        o.emit("setDraggable", e);
-      }
-    ), u(
-      () => a.isResizable,
-      (e) => {
-        o.emit("setResizable", e);
-      }
-    ), u(
-      () => a.isBounded,
-      (e) => {
-        o.emit("setBounded", e);
-      }
-    ), u(
-      () => a.transformScale,
-      (e) => {
-        o.emit("setTransformScale", e);
-      }
-    ), u(
-      () => a.responsive,
-      (e) => {
-        e || (s("update:layout", t.originalLayout), o.emit("setColNum", a.colNum)), $();
-      }
-    ), u(
-      () => a.maxRows,
-      (e) => {
-        o.emit("setMaxRows", e);
-      }
-    ), u([() => a.margin, () => a.margin[1]], h), T(
-      we,
-      W({
-        ...V(a),
-        ...V(t),
-        increaseItem: Q,
-        decreaseItem: Z
-      })
-    ), T(xe, o), z({ state: t, getItem: ee, resizeEvent: H, dragEvent: _, layoutUpdate: E });
-    function Q(e) {
-      D.set(e.i, e);
-    }
-    function Z(e) {
-      D.delete(e.i);
-    }
-    function ee(e) {
-      return D.get(e);
-    }
-    function E() {
-      if (!k(l.value) && !k(t.originalLayout)) {
-        if (l.value.length !== t.originalLayout.length) {
-          const e = oe(l.value, t.originalLayout);
-          if (e.length > 0)
-            if (l.value.length > t.originalLayout.length)
-              t.originalLayout = t.originalLayout.concat(e);
-            else {
-              const n = new Set(e.map((r) => r.i));
-              t.originalLayout = t.originalLayout.filter((r) => !n.has(r.i));
-            }
-          t.lastLayoutLength = l.value.length, U();
-        }
-        b(l.value, a.verticalCompact), o.emit("updateWidth", t.width), h(), s("layout-updated", l.value);
-      }
-    }
-    function h() {
-      t.mergedStyle = {
-        height: te()
-      };
-    }
-    function $() {
-      d.value && (t.width = d.value.offsetWidth), o.emit("resizeEvent");
-    }
-    function te() {
-      if (!a.autoSize) return;
-      const e = parseFloat(a.margin[1]);
-      return Be(l.value) * (a.rowHeight + e) + e + "px";
-    }
-    let I;
-    function _(e, n, r, g, m, p) {
-      let i = X(l.value, n);
-      k(i) && (i = { h: 0, w: 0, x: 0, y: 0, i: "" }), e === "dragstart" && !a.verticalCompact && (I = l.value.reduce(
-        (B, { i: L, x: y, y: w }) => ({
-          ...B,
-          [L]: { x: y, y: w }
-        }),
-        {}
-      )), e === "dragmove" || e === "dragstart" ? (t.placeholder.i = n, t.placeholder.x = i.x, t.placeholder.y = i.y, t.placeholder.w = p, t.placeholder.h = m, v(() => {
-        t.isDragging = !0;
-      }), o.emit("updateWidth", t.width)) : v(() => {
-        t.isDragging = !1;
-      }), l.value = be(l.value, i, r, g, !0, a.preventCollision), a.restoreOnDrag ? (i.static = !0, b(l.value, a.verticalCompact, I), i.static = !1) : b(l.value, a.verticalCompact), o.emit("compact"), h(), e === "dragend" && (I = void 0, s("layout-updated", l.value));
-    }
-    function H(e, n, r, g, m, p) {
-      let i = X(l.value, n);
-      k(i) && (i = { h: 0, w: 0, x: 0, y: 0, i: "" });
-      let B;
-      if (a.preventCollision) {
-        const L = ke(l.value, { ...i, w: p, h: m }).filter(
-          (y) => y.i !== i.i
-        );
-        if (B = L.length > 0, B) {
-          let y = 1 / 0, w = 1 / 0;
-          L.forEach((M) => {
-            M.x > i.x && (y = Math.min(y, M.x)), M.y > i.y && (w = Math.min(w, M.y));
-          }), Number.isFinite(y) && (i.w = y - i.x), Number.isFinite(w) && (i.h = w - i.y);
-        }
-      }
-      B || (i.w = p, i.h = m), e === "resizestart" || e === "resizemove" ? (t.placeholder.i = n, t.placeholder.x = r, t.placeholder.y = g, t.placeholder.w = i.w, t.placeholder.h = i.h, v(() => {
-        t.isDragging = !0;
-      }), o.emit("updateWidth", t.width)) : e && v(() => {
-        t.isDragging = !1;
-      }), a.responsive && ae(), b(l.value, a.verticalCompact), o.emit("compact"), h(), e === "resizeend" && s("layout-updated", l.value);
-    }
-    function ae() {
-      const e = Ce(a.breakpoints, t.width);
-      if (e === t.lastBreakpoint)
-        return;
-      const n = De(e, a.cols);
-      !k(t.lastBreakpoint) && !t.layouts[t.lastBreakpoint] && (t.layouts[t.lastBreakpoint] = Le(l.value));
-      const r = Me(
-        t.originalLayout,
-        t.layouts,
-        a.breakpoints,
-        e,
-        t.lastBreakpoint,
-        n,
-        a.verticalCompact
-      );
-      t.layouts[e] = r, t.lastBreakpoint !== e && s("breakpoint-changed", e, r), l.value = r, s("update:layout", r), t.lastBreakpoint = e, o.emit("setColNum", n);
-    }
-    function U() {
-      t.layouts = Object.assign({}, a.responsiveLayouts);
-    }
-    function oe(e, n) {
-      const r = new Set(n.map((i) => i.i)), g = new Set(e.map((i) => i.i)), m = e.filter((i) => !r.has(i.i)), p = n.filter((i) => !g.has(i.i));
-      return m.concat(p);
-    }
-    return (e, n) => (S(), j("div", {
-      ref_key: "wrapper",
-      ref: d,
-      class: "vgl-layout",
-      style: ne(t.mergedStyle)
-    }, [
-      e.$slots.default ? q(e.$slots, "default", { key: 0 }) : (S(!0), j(se, { key: 1 }, ue(l.value, (r) => (S(), P(Y, de({
-        key: r.i,
-        ref_for: !0
-      }, r), {
-        default: J(() => [
-          q(e.$slots, "item", { item: r })
-        ]),
-        _: 2
-      }, 1040))), 128)),
-      ce(K(Y, {
-        class: "vgl-item--placeholder",
-        x: t.placeholder.x,
-        y: t.placeholder.y,
-        w: t.placeholder.w,
-        h: t.placeholder.h,
-        i: t.placeholder.i
-      }, null, 8, ["x", "y", "w", "h", "i"]), [
-        [me, t.isDragging]
-      ])
-    ], 4));
-  }
-}), Ee = /* @__PURE__ */ G({
-  __name: "DragList",
-  props: /* @__PURE__ */ pe({
-    children: {},
-    rowHeight: {},
-    colNum: {},
-    maxRows: {},
-    isDraggable: { type: Boolean },
-    name: {},
-    onMoved: {}
-  }, {
-    gridlayout: { required: !0 },
-    gridlayoutModifiers: {}
-  }),
-  emits: ["update:gridlayout"],
-  setup(C, { expose: z }) {
-    const f = C, a = ge(C, "gridlayout"), l = {
-      getLayout: () => O(a),
-      setItemX: (o, c) => {
-        a.value[o].x = c;
-      },
-      setItemY: (o, c) => {
-        a.value[o].y = c;
-      },
-      type: "draglist"
-    }, { ruleModule: d, pageMethodMap: R } = ze(), N = () => {
-      if (f.onMoved && d)
-        try {
-          d[f.onMoved](R, O(a.value));
-        } catch (o) {
-          console.error(o + `
-onMoved: ${f.onMoved}`);
-        }
-    };
-    if (z(l), f.name) {
-      const o = Re(f.name, l);
-      ye(() => {
-        o();
-      });
-    }
-    return (o, c) => (S(), P(A(Ie), {
-      layout: a.value,
-      "onUpdate:layout": c[1] || (c[1] = (x) => a.value = x),
-      "col-num": o.colNum || 12,
-      "row-height": o.rowHeight || 30,
-      "max-rows": o.maxRows,
-      margin: [8, 8],
-      "is-draggable": o.isDraggable,
-      "is-bounded": "",
-      "is-resizable": !1,
-      "vertical-compact": "",
-      "use-css-transforms": ""
-    }, {
-      default: J(() => [
-        K(A(Ne), {
-          list: o.children,
-          gridData: a.value,
-          "onUpdate:gridData": c[0] || (c[0] = (x) => a.value = x),
-          onGridItemMoved: N
-        }, null, 8, ["list", "gridData"])
-      ]),
-      _: 1
-    }, 8, ["layout", "col-num", "row-height", "max-rows", "is-draggable"]));
-  }
-}), We = /* @__PURE__ */ $e(Ee, [["__scopeId", "data-v-4c9d1c4f"]]);
-export {
-  We as default
-};