evui 3.4.214 → 3.5.0

package/dist/components/chartBrush/chartBrush.core.js

@@ -0,0 +1,265 @@
+import { throttle as E, debounce as X } from "lodash-es";
+const n = {
+  WHEEL: {
+    UP: "MOVEUP_WHEEL",
+    DOWN: "MOVEDOWN_WHEEL"
+  },
+  GRAB: {
+    UP: "MOVEUP_GRAB",
+    DOWN: "MOVEDOWN_GRAB"
+  },
+  BUTTON: {
+    INCREASE: "INCREASE",
+    DECREASE: "DECREASE"
+  }
+}, a = {
+  LEFT: "leftX",
+  RIGHT: "rightX"
+};
+class T {
+  constructor(s, e, i, t, h) {
+    this.evChart = s, this.evChartBrushOptions = i, this.evChartBrushRef = h, this.evChartData = e, this.brushIdx = t, i.value.useDebounce && (this.debounceBrushIdx = { start: t.start, end: t.end });
+  }
+  init(s) {
+    var e;
+    if (this.brushIdx.start > this.brushIdx.end) {
+      this.removeBrushCanvas();
+      return;
+    }
+    if ((e = this.evChartBrushRef) != null && e.value) {
+      const i = this.evChartBrushRef.value.querySelector(".brush-canvas");
+      if (i)
+        this.drawBrushRect({ brushCanvas: i, isResize: s });
+      else {
+        const t = document.createElement("canvas");
+        t.setAttribute("class", "brush-canvas"), t.setAttribute("style", "display: block; z-index: 1;");
+        const h = this.evChartBrushRef.value.querySelector(
+          ".ev-chart-brush-container"
+        );
+        h && (this.brushCanvas = t, h.appendChild(t), this.evChartBrushContainer = h, this.drawBrushRect({ brushCanvas: t }), this.addEvent(t));
+      }
+    }
+  }
+  drawBrushRect({ brushCanvas: s, isResize: e, isDebounce: i, mode: t, offsetX: h }) {
+    const { chartRect: r, labelOffset: o } = this.evChart;
+    if (!r && !o)
+      return;
+    const d = this.evChartData.value.labels.length - 1;
+    this.labelEndIdx = d;
+    const u = {
+      x1: r.x1 + o.left,
+      x2: r.x2 - o.right,
+      y1: r.y1 + o.top,
+      y2: r.y2 - o.bottom
+    }, c = this.setCanvasWidthHeight(u, s);
+    if (!(e && this.isEqualWidth) && d >= 0) {
+      const b = this.setBrushXAndWidth(c, h, i, t);
+      c && b && this.drawBrush(c, b, u, s);
+    }
+  }
+  setCanvasWidthHeight(s, e) {
+    const t = s.x2 - s.x1 + 6, h = s.y2 - s.y1, r = (s.x2 - s.x1) / this.labelEndIdx, o = window.devicePixelRatio || 1;
+    return this.isEqualWidth = e.width === Math.floor(t * o), {
+      brushButtonWidth: 6,
+      brushCanvasHeight: h,
+      brushCanvasWidth: t,
+      axesXInterval: r,
+      pixelRatio: o
+    };
+  }
+  setBrushXAndWidth(s, e = 0, i, t) {
+    const { brushButtonWidth: h, brushCanvasWidth: r, axesXInterval: o, pixelRatio: d } = s;
+    !i && this.debounceBrushIdx && (this.debounceBrushIdx.start = this.brushIdx.start, this.debounceBrushIdx.end = this.brushIdx.end);
+    const u = this.debounceBrushIdx ?? this.brushIdx;
+    switch (t) {
+      case n.BUTTON.INCREASE:
+      case n.BUTTON.DECREASE:
+        this.brushRectWidth = r * d, this.curBrushButtonType === a.LEFT ? (this.brushRectWidth = this.beforeBrushRectWidth ? this.beforeBrushRectWidth - e : this.brushRectWidth - e, this.brushRectWidth <= h ? this.brushRectWidth = h : (this.brushRectX = e * d, this.beforeBrushRectX = this.brushRectX)) : this.curBrushButtonType === a.RIGHT && (this.brushRectWidth = e - this.beforeBrushRectX, this.brushRectWidth <= h ? this.brushRectWidth = h : (this.brushRectX = this.beforeBrushRectX, this.beforeBrushRectWidth = this.brushRectWidth + this.brushRectX));
+        break;
+      case n.GRAB.UP:
+      case n.GRAB.DOWN:
+        this.brushRectX <= 0 && t === n.GRAB.DOWN || this.brushRectX + this.brushRectWidth >= r && t === n.GRAB.UP ? this.offsetXAndRectXInterval = null : (this.offsetXAndRectXInterval || (this.offsetXAndRectXInterval = e - this.brushRectX), this.brushRectX = e - this.offsetXAndRectXInterval);
+        break;
+      default:
+        e || (this.brushRectX = u.start * o * d, this.brushRectWidth = (r - (this.labelEndIdx - (u.end - u.start)) * o) * d, this.beforeBrushRectX = this.brushRectX, this.beforeBrushRectWidth = this.brushRectWidth + this.brushRectX);
+        break;
+    }
+    return {
+      brushRectX: this.brushRectX,
+      brushRectWidth: this.brushRectWidth
+    };
+  }
+  drawBrush(s, e, i, t) {
+    const { brushButtonWidth: h, brushCanvasHeight: r, brushCanvasWidth: o, axesXInterval: d, pixelRatio: u } = s, { brushRectX: c, brushRectWidth: b } = e, {
+      height: v,
+      selection: { fillColor: x, opacity: R }
+    } = this.evChartBrushOptions.value, f = v - i.y1, B = c, I = c + b;
+    t.style.position || (t.style.position = "absolute", t.style.top = `${i.y1}px`, t.style.left = `${i.x1 - h / 2}px`), this.isEqualWidth || (t.width = o * u, t.style.width = `${o}px`, t.height = r * u, t.style.height = `${r}px`);
+    const l = t.getContext("2d");
+    l.clearRect(0, 0, o * u, r * u), l.fillStyle = x, l.globalAlpha = R, l.fillRect(c, 0, b, f), l.fillRect(B, 0, h, f), l.fillRect(I - h, 0, h, f), this.brushPosInfo = {
+      leftX: B / u,
+      rightX: I / u,
+      buttonWidth: h,
+      axesXInterval: d,
+      ...s,
+      ...e
+    };
+  }
+  addEvent() {
+    let s;
+    this.onMouseDown = (t) => {
+      t.preventDefault(), s.isInsideButton ? this.clickBrushInsideX = -1 : s.isInsideBrush ? this.clickBrushInsideX = t.offsetX : s.isOutsideBrush && this.teleportBrush(t);
+    };
+    const e = (t) => {
+      this.clickBrushInsideX ? this.mouseDownAndMove(t) : (s = this.getMousePosition(t), this.changeCursor(s));
+    };
+    this.onMouseMove = E(e, 5), this.onWheel = (t) => {
+      t.preventDefault();
+      const h = t.deltaY > 0 ? n.WHEEL.DOWN : n.WHEEL.UP;
+      this.updateBrushIdx(h), this.debounceBrushIdx && this.drawBrushRect({
+        brushCanvas: this.brushCanvas,
+        isDebounce: !0,
+        mode: h
+      }), this.brushIdx.isUseScroll = !0;
+    }, this.onMouseUp = () => {
+      this.initEventState();
+    }, this.onMouseLeave = () => {
+      this.clickBrushInsideX && this.initEventState();
+    };
+    const i = () => {
+      this.initEventState();
+    };
+    this.onWheelDebounce = X(i, 100), this.setEventListener("addEventListener");
+  }
+  getMousePosition(s) {
+    const e = (u) => Math.abs(this.brushPosInfo[u] - s.offsetX), i = e(a.RIGHT) > e(a.LEFT) ? a.LEFT : a.RIGHT, t = (u) => s.offsetX > this.brushPosInfo[u], h = (u) => s.offsetX < this.brushPosInfo[u], r = h(a.LEFT) || t(a.RIGHT), o = t(a.LEFT) && h(a.RIGHT), d = s.offsetX + this.brushPosInfo.buttonWidth >= this.brushPosInfo[i] && s.offsetX - this.brushPosInfo.buttonWidth <= this.brushPosInfo[i];
+    return this.curBrushButtonType = d && i, {
+      isInsideButton: d,
+      isInsideBrush: o,
+      isOutsideBrush: r
+    };
+  }
+  destroy() {
+    if (this.brushCanvas && (this.setEventListener("removeEventListener"), this.brushCanvas = null), this.evChartBrushContainer) {
+      const s = this.evChartBrushContainer;
+      for (; s.hasChildNodes(); )
+        s.removeChild(s.firstChild);
+    }
+  }
+  /**
+   * @param {string} type eventListener setting type.
+   *
+   * @returns {undefined}
+   */
+  setEventListener(s) {
+    this.brushCanvas[s]("mousemove", this.onMouseMove), this.brushCanvas[s]("mousedown", this.onMouseDown), this.brushCanvas[s]("mouseup", this.onMouseUp), this.brushCanvas[s]("mouseleave", this.onMouseLeave), this.evChartBrushOptions.value.useWheelMove && (this.brushCanvas[s]("wheel", this.onWheel), this.brushCanvas[s]("wheel", this.onWheelDebounce));
+  }
+  removeBrushWrapper() {
+    if (this.evChartBrushRef.value) {
+      const s = this.evChartBrushRef.value.querySelector(".ev-chart-brush-wrapper");
+      s && this.evChartBrushRef.value.removeChild(s);
+    }
+  }
+  removeBrushCanvas() {
+    if (this.evChartBrushContainer) {
+      const s = this.evChartBrushContainer.querySelector(".brush-canvas");
+      s && this.evChartBrushContainer.removeChild(s);
+    }
+  }
+  teleportBrush(s) {
+    const e = this.debounceBrushIdx ?? this.brushIdx, i = (e.end - e.start) / 2;
+    let t, h, r;
+    i > 0.5 ? (e.end - e.start) % 2 === 0 ? (r = Math.round(s.offsetX / this.brushPosInfo.axesXInterval), t = Math.ceil(i), h = Math.floor(i)) : (r = Math.ceil(s.offsetX / this.brushPosInfo.axesXInterval), t = Math.ceil(i), h = Math.floor(i)) : (r = Math.floor(s.offsetX / this.brushPosInfo.axesXInterval), s.offsetX - r * this.brushPosInfo.axesXInterval > this.brushPosInfo.axesXInterval / 2 ? (t = Math.floor(i), h = Math.ceil(i)) : (t = Math.ceil(i), h = Math.floor(i), i < 1 && (r += 1))), r - t <= 0 ? (e.start = 0, e.end = h + t) : r + h >= this.labelEndIdx ? (e.start = this.labelEndIdx - h - t, e.end = this.labelEndIdx) : (e.start = r - t, e.end = r + h), this.brushIdx.isUseScroll = !0;
+  }
+  changeCursor(s) {
+    s.isOutsideBrush ? this.brushCanvas.style.cursor = "pointer" : s.isInsideBrush && (s.isInsideButton ? this.brushCanvas.style.cursor = "ew-resize" : this.brushCanvas.style.cursor = "grab");
+  }
+  mouseDownAndMove(s) {
+    const e = this.debounceBrushIdx ? 0 : this.brushPosInfo.axesXInterval / 3;
+    let i;
+    s.offsetX > this.beforeMouseXPos ? this.clickBrushInsideX > 0 ? this.clickBrushInsideX < s.offsetX - e && (i = n.GRAB.UP, this.isUseBrushGrab = !0, this.brushIdx.isUseScroll = !0, this.clickBrushInsideX = s.offsetX + e) : s.offsetX - this.brushPosInfo[this.curBrushButtonType] > e && (i = this.curBrushButtonType === a.LEFT ? n.BUTTON.DECREASE : n.BUTTON.INCREASE, this.brushIdx.isUseButton = !0) : s.offsetX < this.beforeMouseXPos && (this.clickBrushInsideX > 0 ? this.clickBrushInsideX > s.offsetX + e && (i = n.GRAB.DOWN, this.isUseBrushGrab = !0, this.brushIdx.isUseScroll = !0, this.clickBrushInsideX = s.offsetX - e) : this.brushPosInfo[this.curBrushButtonType] - s.offsetX > e && (i = this.curBrushButtonType === a.LEFT ? n.BUTTON.INCREASE : n.BUTTON.DECREASE, this.brushIdx.isUseButton = !0)), this.debounceBrushIdx ? this.drawBrushRect({
+      brushCanvas: this.brushCanvas,
+      isDebounce: !0,
+      mode: i,
+      offsetX: s.offsetX
+    }) : this.updateBrushIdx(i), this.beforeMouseXPos = s.offsetX;
+  }
+  /**
+   * @param {string} mode determines how to update the brush index value.
+   *
+   * @returns {undefined}
+   */
+  updateBrushIdx(s) {
+    const e = this.debounceBrushIdx ?? this.brushIdx;
+    switch (s) {
+      case n.WHEEL.UP:
+      case n.GRAB.UP:
+        if (e.end >= this.labelEndIdx)
+          return;
+        e.start += 1, e.end += 1;
+        break;
+      case n.WHEEL.DOWN:
+      case n.GRAB.DOWN:
+        if (e.start <= 0)
+          return;
+        e.start -= 1, e.end -= 1;
+        break;
+      case n.BUTTON.INCREASE:
+        if (this.curBrushButtonType === a.LEFT) {
+          if (!e.start)
+            return;
+          e.start -= 1;
+        } else {
+          if (e.end === this.labelEndIdx)
+            return;
+          e.end += 1;
+        }
+        break;
+      case n.BUTTON.DECREASE:
+        if (e.start === e.end - 1)
+          return;
+        this.curBrushButtonType === a.LEFT ? e.start += 1 : e.end -= 1;
+        break;
+    }
+  }
+  updateBrushIdxUseXPos() {
+    if (!this.debounceBrushIdx)
+      return;
+    const s = () => {
+      let t, h;
+      if (this.brushPosInfo) {
+        const { brushRectX: r, brushRectWidth: o, brushCanvasWidth: d, axesXInterval: u } = this.brushPosInfo;
+        if (this.brushIdx.isUseButton || this.isUseBrushGrab) {
+          if (t = r / u, h = this.labelEndIdx - (d - (r + o)) / u, this.curBrushButtonType === a.LEFT ? (t = Math.round(t), h = this.brushIdx.end, t === h && (t -= 1)) : this.curBrushButtonType === a.RIGHT ? (t = this.brushIdx.start, h = Math.round(h), t === h && (h += 1)) : (t = Math.round(t), h = Math.round(h)), h > this.labelEndIdx) {
+            const c = h - this.labelEndIdx;
+            t -= c, h -= c;
+          }
+          if (t < 0) {
+            const c = Math.abs(t);
+            t = 0, h += c;
+          }
+        }
+      }
+      return {
+        brushStartIdx: t,
+        brushEndIdx: h
+      };
+    }, { brushStartIdx: e, brushEndIdx: i } = s();
+    this.brushIdx.start === e && this.brushIdx.end === i && this.drawBrushRect({ brushCanvas: this.brushCanvas }), this.brushIdx.start = e ?? this.debounceBrushIdx.start, this.brushIdx.end = i ?? this.debounceBrushIdx.end;
+  }
+  /**
+   * @param {boolean} updateBrushIdxUseXPos to initialize state after update brush index value
+   *
+   * @returns {undefined}
+   */
+  initEventState() {
+    new Promise((e) => {
+      this.updateBrushIdxUseXPos(), e(!0);
+    }).then((e) => {
+      e && (this.clickBrushInsideX = null, this.beforeMouseXPos = null, this.curBrushButtonType = null, this.isUseBrushGrab = !1, this.offsetXAndRectXInterval = null, this.brushIdx.isUseButton = !1, this.brushIdx.isUseScroll = !1);
+    });
+  }
+}
+export {
+  T as default
+};

package/dist/components/chartBrush/index.js

@@ -0,0 +1,7 @@
+import t from "./ChartBrush.vue.js";
+t.install = (a) => {
+  a.component(t.name, t);
+};
+export {
+  t as default
+};

package/dist/components/chartBrush/uses.js

@@ -0,0 +1,18 @@
+import { defaultsDeep as o } from "lodash-es";
+const t = {
+  show: !0,
+  useDebounce: !0,
+  chartIdx: 0,
+  height: 100,
+  showLabel: !1,
+  selection: {
+    fillColor: "#38ACEC",
+    opacity: 0.65
+  },
+  useWheelMove: !0
+}, u = () => ({
+  getNormalizedBrushOptions: (e) => o({}, e, t)
+});
+export {
+  u as useBrushModel
+};

package/dist/components/chartGroup/ChartGroup.vue.js

@@ -0,0 +1,128 @@
+import { resolveComponent as E, openBlock as f, createElementBlock as h, Fragment as L, createVNode as G, createCommentVNode as Z, createElementVNode as k, renderSlot as T, provide as e, computed as y, ref as N, watch as n, onMounted as w, toRef as R } from "vue";
+import H from "../chart/ChartToolbar.vue.js";
+import { useGroupModel as U } from "./uses.js";
+import { useZoomModel as B } from "../chart/uses.js";
+/* empty css                */
+import F from "../../_virtual/_plugin-vue_export-helper.js";
+const M = {
+  name: "EvChartGroup",
+  components: {
+    evChartToolbar: H
+  },
+  props: {
+    options: {
+      type: Object,
+      default: () => ({})
+    },
+    zoomStartIdx: {
+      type: Number,
+      default: 0
+    },
+    zoomEndIdx: {
+      type: Number,
+      default: 0
+    },
+    groupSelectedLabel: {
+      type: Object,
+      default: null
+    }
+  },
+  emits: [
+    "update:groupSelectedLabel",
+    "update:zoomStartIdx",
+    "update:zoomEndIdx",
+    "update:groupHoveredLabel"
+  ],
+  setup(t, { emit: c }) {
+    const {
+      getNormalizedOptions: l,
+      isExecuteZoom: r,
+      brushSeries: m,
+      evChartGroupRef: s,
+      evChartPropsInGroup: a
+    } = U(), v = l(t.options);
+    e("isExecuteZoom", r), e("isChartGroup", !0), e("brushSeries", m), e("evChartPropsInGroup", a);
+    const i = y({
+      get: () => t.groupSelectedLabel,
+      set: (o) => c("update:groupSelectedLabel", o)
+    });
+    e("groupSelectedLabel", i);
+    const u = N(null);
+    e("groupHoveredLabel", u), n(
+      () => t.options.syncHover,
+      (o) => {
+        o ? u.value = { label: "", horizontal: !1 } : u.value = null;
+      },
+      {
+        immediate: !0
+      }
+    );
+    const {
+      evChartZoomOptions: C,
+      evChartInfo: b,
+      evChartToolbarRef: _,
+      evChartClone: I,
+      brushIdx: d,
+      createEvChartZoom: g,
+      setOptionsForUseZoom: x,
+      setDataForUseZoom: z,
+      controlZoomIdx: S,
+      onClickToolbar: O
+    } = B(
+      v,
+      { wrapper: null, evChartGroupRef: s },
+      i,
+      a
+    );
+    return e("evChartClone", I), e("evChartInfo", b), e("brushIdx", d), w(() => {
+      g();
+    }), n(
+      () => b.props.data,
+      (o) => {
+        z(o);
+      },
+      { deep: !0 }
+    ), n(
+      () => t.options,
+      (o) => {
+        const p = l(o);
+        x(p);
+      },
+      { deep: !0 }
+    ), n(
+      () => [t.zoomStartIdx, t.zoomEndIdx],
+      ([o, p]) => {
+        d.isUseButton || d.isUseScroll || S(o, p);
+      }
+    ), {
+      evChartGroupRef: s,
+      evChartToolbarRef: _,
+      zoomOptions: R(C, "zoom"),
+      onClickToolbar: O
+    };
+  }
+}, V = {
+  key: 0,
+  ref: "evChartToolbarRef"
+}, j = {
+  ref: "evChartGroupRef",
+  class: "ev-chart-group__wrapper"
+};
+function P(t, c, l, r, m, s) {
+  const a = E("ev-chart-toolbar");
+  return f(), h(L, null, [
+    r.zoomOptions.toolbar.show ? (f(), h("div", V, [
+      G(a, {
+        toolbar: r.zoomOptions.toolbar,
+        onOnClickToolbar: r.onClickToolbar
+      }, null, 8, ["toolbar", "onOnClickToolbar"])
+    ], 512)) : Z("", !0),
+    k("div", j, [
+      T(t.$slots, "default", {}, void 0, !0)
+    ], 512)
+  ], 64);
+}
+const Q = /* @__PURE__ */ F(M, [["render", P], ["__scopeId", "data-v-b1c0c322"]]);
+export {
+  Q as default
+};

package/dist/components/chartGroup/index.js

@@ -0,0 +1,7 @@
+import o from "./ChartGroup.vue.js";
+o.install = (t) => {
+  t.component(o.name, o);
+};
+export {
+  o as default
+};

package/dist/components/chartGroup/uses.js

@@ -0,0 +1,47 @@
+import { ref as e, reactive as n } from "vue";
+import { defaultsDeep as m } from "lodash-es";
+const l = {
+  zoom: {
+    bufferMemoryCnt: 100,
+    keepZoomStatus: !1,
+    useAnimation: !0,
+    useWheelMove: !0,
+    toolbar: {
+      show: !1,
+      items: {
+        previous: {
+          icon: "ev-icon-allow2-left",
+          size: "medium",
+          title: "Previous"
+        },
+        latest: {
+          icon: "ev-icon-allow2-right",
+          size: "medium",
+          title: "Latest"
+        },
+        reset: {
+          icon: "ev-icon-redo",
+          size: "medium",
+          title: "Reset"
+        },
+        dragZoom: {
+          icon: "ev-icon-zoomin",
+          size: "medium",
+          title: "Drag Zoom"
+        }
+      }
+    }
+  }
+}, p = () => {
+  const o = e(!1), t = e(), i = e([]), s = n({ list: [], chartIdx: null });
+  return {
+    getNormalizedOptions: (r) => m({}, r, l),
+    isExecuteZoom: o,
+    brushSeries: s,
+    evChartGroupRef: t,
+    evChartPropsInGroup: i
+  };
+};
+export {
+  p as useGroupModel
+};

package/dist/components/checkbox/Checkbox.vue.js

@@ -0,0 +1,99 @@
+import { openBlock as r, createElementBlock as u, normalizeClass as h, withDirectives as k, createElementVNode as s, vModelCheckbox as y, renderSlot as x, Fragment as g, createTextVNode as p, toDisplayString as B, ref as b, onMounted as C, inject as m, computed as c, nextTick as f, watch as S } from "vue";
+/* empty css              */
+import V from "../../_virtual/_plugin-vue_export-helper.js";
+const E = {
+  name: "EvCheckbox",
+  props: {
+    modelValue: {
+      type: [String, Number, Boolean, Symbol, Array],
+      default: !1
+    },
+    label: {
+      type: [String, Number, Boolean, Symbol, Object],
+      default: null
+    },
+    tooltipTitle: {
+      type: String,
+      default: ""
+    },
+    disabled: {
+      type: Boolean,
+      default: !1
+    },
+    readonly: {
+      type: Boolean,
+      default: !1
+    },
+    indeterminate: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: {
+    "update:modelValue": null,
+    "update:indeterminate": [Boolean],
+    change: null
+  },
+  setup(a, { emit: t }) {
+    const l = b();
+    C(() => {
+      l.value && a.tooltipTitle && (l.value.title = a.tooltipTitle);
+    });
+    const e = b(null), n = m(
+      "EvCheckboxGroupMv",
+      c({
+        get: () => a.modelValue,
+        set: (o) => {
+          o && !e.value.indeterminate && t("update:indeterminate", !1), t("update:modelValue", o);
+        }
+      })
+    ), i = c(() => a.label), d = c(() => Array.isArray(n.value) ? n.value.includes(i.value) : n.value), v = m("EvCheckboxGroupChange", async (o) => {
+      await f(), t("change", n.value, o);
+    });
+    return S(
+      () => a.indeterminate,
+      (o) => {
+        f(() => {
+          e.value && (e.value.indeterminate = o);
+        });
+      },
+      { immediate: !0 }
+    ), {
+      mv: n,
+      checkboxLabel: l,
+      checkbox: e,
+      checked: d,
+      changeMv: v
+    };
+  }
+}, M = ["disabled", "value", "readonly"], _ = {
+  ref: "checkboxLabel",
+  class: "ev-checkbox-label"
+};
+function T(a, t, l, e, n, i) {
+  return r(), u("label", {
+    class: h(["ev-checkbox", [{ disabled: l.disabled }, { checked: e.checked }]])
+  }, [
+    k(s("input", {
+      ref: "checkbox",
+      "onUpdate:modelValue": t[0] || (t[0] = (d) => e.mv = d),
+      type: "checkbox",
+      class: "ev-checkbox-input",
+      disabled: l.disabled,
+      value: l.label,
+      readonly: l.readonly,
+      onChange: t[1] || (t[1] = (...d) => e.changeMv && e.changeMv(...d))
+    }, null, 40, M), [
+      [y, e.mv]
+    ]),
+    s("span", _, [
+      a.$slots.default ? x(a.$slots, "default", { key: 0 }) : (r(), u(g, { key: 1 }, [
+        p(B(l.label), 1)
+      ], 64))
+    ], 512)
+  ], 2);
+}
+const L = /* @__PURE__ */ V(E, [["render", T]]);
+export {
+  L as default
+};

package/dist/components/checkbox/index.js

@@ -0,0 +1,7 @@
+import o from "./Checkbox.vue.js";
+o.install = (e) => {
+  e.component(o.name, o);
+};
+export {
+  o as default
+};

package/dist/components/checkboxGroup/CheckboxGroup.vue.js

@@ -0,0 +1,40 @@
+import { openBlock as r, createElementBlock as l, normalizeClass as u, renderSlot as p, computed as s, provide as c, nextTick as d } from "vue";
+import m from "../../_virtual/_plugin-vue_export-helper.js";
+const h = {
+  name: "EvCheckboxGroup",
+  props: {
+    modelValue: {
+      type: Array,
+      default: () => []
+    },
+    type: {
+      type: String,
+      default: "checkbox"
+    }
+  },
+  emits: {
+    "update:modelValue": null,
+    change: null
+  },
+  setup(t, { emit: a }) {
+    const e = s({
+      get: () => t.modelValue,
+      set: (o) => a("update:modelValue", o)
+    });
+    c("EvCheckboxGroupMv", e), c("EvCheckboxGroupChange", async (o) => {
+      await d(), a("change", e.value, o);
+    });
+  }
+};
+function i(t, a, e, n, o, f) {
+  return r(), l("div", {
+    class: u(["ev-checkbox-group", { "type-button": e.type === "button" }]),
+    role: "group"
+  }, [
+    p(t.$slots, "default")
+  ], 2);
+}
+const k = /* @__PURE__ */ m(h, [["render", i]]);
+export {
+  k as default
+};

package/dist/components/checkboxGroup/index.js

@@ -0,0 +1,7 @@
+import o from "./CheckboxGroup.vue.js";
+o.install = (e) => {
+  e.component(o.name, o);
+};
+export {
+  o as default
+};