asiaint-lowcode 3.1.1 → 3.1.3

package/package.json

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

package/dist/lazy/Component-BMyo9RcE.js

@@ -1,35 +0,0 @@
-import { defineComponent as s, mergeModels as p, useModel as u, resolveComponent as i, openBlock as t, createElementBlock as d, toDisplayString as c, createBlock as y, mergeProps as f } from "vue";
-import { u as v } from "./index-ByB0wyc-.js";
-import "element-plus";
-const k = { key: 0 }, K = /* @__PURE__ */ s({
-  __name: "Component",
-  props: /* @__PURE__ */ p({
-    min: {},
-    read: { type: Boolean },
-    precision: {}
-  }, {
-    modelValue: {},
-    modelModifiers: {}
-  }),
-  emits: ["update:modelValue"],
-  setup(l) {
-    const o = u(l, "modelValue");
-    v();
-    const r = (e) => {
-      ["E", "e", "+", "-"].includes(e.key) && e.preventDefault();
-    };
-    return (e, n) => {
-      const m = i("el-input-number");
-      return e.read ? (t(), d("span", k, c(typeof o.value == "number" ? o.value.toFixed(e.precision || 0).replace(".", ",") : "--"), 1)) : (t(), y(m, f({ key: 1 }, e.$attrs, {
-        modelValue: o.value,
-        "onUpdate:modelValue": n[0] || (n[0] = (a) => o.value = a),
-        style: { width: "100%" },
-        min: e.min || 0,
-        onKeydown: r
-      }), null, 16, ["modelValue", "min"]));
-    };
-  }
-});
-export {
-  K as default
-};

package/dist/lazy/DatePicker-CGxtZ6pR.js

@@ -1,32 +0,0 @@
-import { defineComponent as m, mergeModels as p, useModel as i, useAttrs as c, computed as v, resolveComponent as f, openBlock as l, createElementBlock as k, toDisplayString as y, createBlock as _, mergeProps as V } from "vue";
-import { dayjs as B } from "element-plus";
-const g = { key: 0 }, h = /* @__PURE__ */ m({
-  __name: "DatePicker",
-  props: /* @__PURE__ */ p({
-    read: { type: Boolean }
-  }, {
-    modelValue: {},
-    modelModifiers: {}
-  }),
-  emits: ["update:modelValue"],
-  setup(r) {
-    const e = i(r, "modelValue"), t = c(), u = v(() => e.value ? t.valueFormat ? B(e.value).format(t.valueFormat) : e.value : "--"), n = [
-      {
-        text: "Today",
-        value: /* @__PURE__ */ new Date()
-      }
-    ];
-    return (o, a) => {
-      const s = f("el-date-picker");
-      return o.read ? (l(), k("span", g, y(u.value), 1)) : (l(), _(s, V({ key: 1 }, o.$attrs, {
-        modelValue: e.value,
-        "onUpdate:modelValue": a[0] || (a[0] = (d) => e.value = d),
-        style: { width: "100%" },
-        shortcuts: n
-      }), null, 16, ["modelValue"]));
-    };
-  }
-});
-export {
-  h as default
-};

package/dist/lazy/DragList-BaXe5qJv.js

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