@bdsoft/element 1.1.25 → 1.1.27

package/dist/es/src/components/contextMenu/index.vue.js

@@ -0,0 +1,153 @@
+const { ref: ref, computed: computed, provide: provide, onMounted: onMounted, onUnmounted: onUnmounted, watch: watch, createElementBlock: createElementBlock, openBlock: openBlock, renderSlot: renderSlot, createBlock: createBlock, Teleport: Teleport, createVNode: createVNode, Transition: Transition, withCtx: withCtx, createCommentVNode: createCommentVNode, normalizeStyle: normalizeStyle, createElementVNode: createElementVNode, Fragment: Fragment, renderList: renderList, createTextVNode: createTextVNode, toDisplayString: toDisplayString, normalizeClass: normalizeClass } = Vue;
+import "./index.vue2.js";
+import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.js";
+const _hoisted_1 = { class: "context-menu-container" };
+const _hoisted_2 = ["onClick"];
+const _sfc_main = {
+  __name: "index",
+  props: {
+    options: {
+      type: Array,
+      default: () => []
+    }
+  },
+  emits: ["menu-click", "show-menu", "hide-menu"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const menuRef = ref(null);
+    const isMenuVisible = ref(false);
+    const menuX = ref(0);
+    const menuY = ref(0);
+    const currentItem = ref(null);
+    const menuOptions = computed(() => props.options);
+    const currentItemData = ref(null);
+    provide("showContextMenu", (itemData, event) => {
+      event.preventDefault();
+      currentItemData.value = itemData;
+      const { clientX, clientY } = event;
+      const menuWidth = 180;
+      const menuHeight = props.options.length * 40;
+      let x = clientX;
+      if (x + menuWidth > window.innerWidth) {
+        x = Math.max(0, window.innerWidth - menuWidth);
+      }
+      let y = clientY;
+      if (y + menuHeight > window.innerHeight) {
+        y = Math.max(0, window.innerHeight - menuHeight);
+      }
+      menuX.value = x;
+      menuY.value = y;
+      isMenuVisible.value = true;
+    });
+    const showMenu = (item, event) => {
+      event.preventDefault();
+      currentItem.value = item;
+      const { x, y } = calculateMenuPosition(event.clientX, event.clientY);
+      menuX.value = x;
+      menuY.value = y;
+      isMenuVisible.value = true;
+      emit("show-menu", { item, x, y });
+    };
+    const calculateMenuPosition = (clientX, clientY) => {
+      const menuWidth = 180;
+      const menuHeight = 40 * menuOptions.value.length;
+      let x = clientX;
+      let y = clientY;
+      if (x + menuWidth > window.innerWidth) {
+        x = window.innerWidth - menuWidth;
+      }
+      if (y + menuHeight > window.innerHeight) {
+        y = window.innerHeight - menuHeight;
+      }
+      return { x, y };
+    };
+    const handleMenuItemClick = (item, index2) => {
+      isMenuVisible.value = false;
+      emit("menu-click", { item, index: index2, data: currentItem.value });
+      if (typeof item.click === "function") {
+        item.click(currentItem.value);
+      }
+    };
+    const handleEnter = (el) => {
+      el.style.opacity = "0";
+      el.style.transform = "translateY(-10px)";
+      el.style.transition = "opacity 0.2s, transform 0.2s";
+      setTimeout(() => {
+        el.style.opacity = "1";
+        el.style.transform = "translateY(0)";
+      }, 10);
+    };
+    const closeMenuOnClickOutside = (event) => {
+      if (menuRef.value && !menuRef.value.contains(event.target)) {
+        isMenuVisible.value = false;
+        emit("hide-menu");
+      }
+    };
+    const closeMenuOnEsc = (event) => {
+      if (event.key === "Escape") {
+        isMenuVisible.value = false;
+        emit("hide-menu");
+      }
+    };
+    onMounted(() => {
+      document.addEventListener("click", closeMenuOnClickOutside);
+      document.addEventListener("keydown", closeMenuOnEsc);
+    });
+    onUnmounted(() => {
+      document.removeEventListener("click", closeMenuOnClickOutside);
+      document.removeEventListener("keydown", closeMenuOnEsc);
+    });
+    __expose({
+      showMenu
+    });
+    watch(() => props.options, (newOptions) => {
+      if (isMenuVisible.value && menuRef.value) {
+        const menuHeight = 40 * newOptions.length;
+        menuRef.value.style.height = `${menuHeight}px`;
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true),
+        (openBlock(), createBlock(Teleport, { to: "body" }, [
+          createVNode(Transition, {
+            name: "menu-fade",
+            onEnter: handleEnter
+          }, {
+            default: withCtx(() => [
+              isMenuVisible.value ? (openBlock(), createElementBlock("div", {
+                key: 0,
+                class: "context-menu",
+                ref_key: "menuRef",
+                ref: menuRef,
+                style: normalizeStyle({ top: menuY.value + "px", left: menuX.value + "px" })
+              }, [
+                createElementVNode("ul", null, [
+                  (openBlock(true), createElementBlock(Fragment, null, renderList(menuOptions.value, (item, index2) => {
+                    return openBlock(), createElementBlock("li", {
+                      key: index2,
+                      class: "menu-item",
+                      onClick: ($event) => handleMenuItemClick(item, index2)
+                    }, [
+                      createTextVNode(toDisplayString(item.label) + " ", 1),
+                      item.icon ? (openBlock(), createElementBlock("span", {
+                        key: 0,
+                        class: normalizeClass(item.icon)
+                      }, null, 2)) : createCommentVNode("", true)
+                    ], 8, _hoisted_2);
+                  }), 128))
+                ])
+              ], 4)) : createCommentVNode("", true)
+            ]),
+            _: 1
+          })
+        ]))
+      ]);
+    };
+  }
+};
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-d29d1e99"]]);
+export {
+  index as default
+};

package/dist/es/src/components/contextMenu/index.vue2.js

@@ -0,0 +1 @@
+

package/dist/es/src/components/countup/countUp.js

@@ -0,0 +1,165 @@
+var CountUp = function(target, startVal, endVal, decimals, duration, options) {
+  var lastTime = 0;
+  var vendors = ["webkit", "moz", "ms", "o"];
+  for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
+    window.requestAnimationFrame = window[vendors[x] + "RequestAnimationFrame"];
+    window.cancelAnimationFrame = window[vendors[x] + "CancelAnimationFrame"] || window[vendors[x] + "CancelRequestAnimationFrame"];
+  }
+  if (!window.requestAnimationFrame) {
+    window.requestAnimationFrame = function(callback, element) {
+      var currTime = (/* @__PURE__ */ new Date()).getTime();
+      var timeToCall = Math.max(0, 16 - (currTime - lastTime));
+      var id = window.setTimeout(function() {
+        callback(currTime + timeToCall);
+      }, timeToCall);
+      lastTime = currTime + timeToCall;
+      return id;
+    };
+  }
+  if (!window.cancelAnimationFrame) {
+    window.cancelAnimationFrame = function(id) {
+      clearTimeout(id);
+    };
+  }
+  var self = this;
+  self.options = {
+    useEasing: true,
+    // toggle easing
+    useGrouping: true,
+    // 1,000,000 vs 1000000
+    separator: ",",
+    // character to use as a separator
+    decimal: ".",
+    // character to use as a decimal
+    easingFn: null,
+    // optional custom easing closure function, default is Robert Penner's easeOutExpo
+    formattingFn: null
+    // optional custom formatting function, default is self.formatNumber below
+  };
+  for (var key in options) {
+    if (options.hasOwnProperty(key)) {
+      self.options[key] = options[key];
+    }
+  }
+  if (self.options.separator === "") {
+    self.options.useGrouping = false;
+  }
+  if (!self.options.prefix)
+    self.options.prefix = "";
+  if (!self.options.suffix)
+    self.options.suffix = "";
+  self.d = typeof target === "string" ? document.getElementById(target) : target;
+  self.startVal = Number(startVal);
+  self.endVal = Number(endVal);
+  self.countDown = self.startVal > self.endVal;
+  self.frameVal = self.startVal;
+  self.decimals = Math.max(0, decimals || 0);
+  self.dec = Math.pow(10, self.decimals);
+  self.duration = Number(duration) * 1e3 || 2e3;
+  self.formatNumber = function(nStr) {
+    nStr = nStr.toFixed(self.decimals);
+    nStr += "";
+    var x2, x1, x22, rgx;
+    x2 = nStr.split(".");
+    x1 = x2[0];
+    x22 = x2.length > 1 ? self.options.decimal + x2[1] : "";
+    rgx = /(\d+)(\d{3})/;
+    if (self.options.useGrouping) {
+      while (rgx.test(x1)) {
+        x1 = x1.replace(rgx, "$1" + self.options.separator + "$2");
+      }
+    }
+    return self.options.prefix + x1 + x22 + self.options.suffix;
+  };
+  self.easeOutExpo = function(t, b, c, d) {
+    return c * (-Math.pow(2, -10 * t / d) + 1) * 1024 / 1023 + b;
+  };
+  self.easingFn = self.options.easingFn ? self.options.easingFn : self.easeOutExpo;
+  self.formattingFn = self.options.formattingFn ? self.options.formattingFn : self.formatNumber;
+  self.version = function() {
+    return "1.7.1";
+  };
+  self.printValue = function(value) {
+    var _a, _b, _c;
+    var result = self.formattingFn(value);
+    if (((_a = self.d) == null ? void 0 : _a.tagName) === "INPUT") {
+      this.d.value = result;
+    } else if (((_b = self.d) == null ? void 0 : _b.tagName) === "text" || ((_c = self.d) == null ? void 0 : _c.tagName) === "tspan") {
+      this.d.textContent = result;
+    } else {
+      this.d.innerHTML = result;
+    }
+  };
+  self.count = function(timestamp) {
+    if (!self.startTime) {
+      self.startTime = timestamp;
+    }
+    self.timestamp = timestamp;
+    var progress = timestamp - self.startTime;
+    self.remaining = self.duration - progress;
+    if (self.options.useEasing) {
+      if (self.countDown) {
+        self.frameVal = self.startVal - self.easingFn(progress, 0, self.startVal - self.endVal, self.duration);
+      } else {
+        self.frameVal = self.easingFn(progress, self.startVal, self.endVal - self.startVal, self.duration);
+      }
+    } else {
+      if (self.countDown) {
+        self.frameVal = self.startVal - (self.startVal - self.endVal) * (progress / self.duration);
+      } else {
+        self.frameVal = self.startVal + (self.endVal - self.startVal) * (progress / self.duration);
+      }
+    }
+    if (self.countDown) {
+      self.frameVal = self.frameVal < self.endVal ? self.endVal : self.frameVal;
+    } else {
+      self.frameVal = self.frameVal > self.endVal ? self.endVal : self.frameVal;
+    }
+    self.frameVal = Math.round(self.frameVal * self.dec) / self.dec;
+    self.printValue(self.frameVal);
+    if (progress < self.duration) {
+      self.rAF = requestAnimationFrame(self.count);
+    } else {
+      if (self.callback) {
+        self.callback();
+      }
+    }
+  };
+  self.start = function(callback) {
+    self.callback = callback;
+    self.rAF = requestAnimationFrame(self.count);
+    return false;
+  };
+  self.pauseResume = function() {
+    if (!self.paused) {
+      self.paused = true;
+      cancelAnimationFrame(self.rAF);
+    } else {
+      self.paused = false;
+      delete self.startTime;
+      self.duration = self.remaining;
+      self.startVal = self.frameVal;
+      requestAnimationFrame(self.count);
+    }
+  };
+  self.reset = function() {
+    self.paused = false;
+    delete self.startTime;
+    self.startVal = startVal;
+    cancelAnimationFrame(self.rAF);
+    self.printValue(self.startVal);
+  };
+  self.update = function(newEndVal) {
+    cancelAnimationFrame(self.rAF);
+    self.paused = false;
+    delete self.startTime;
+    self.startVal = self.frameVal;
+    self.endVal = Number(newEndVal);
+    self.countDown = self.startVal > self.endVal;
+    self.rAF = requestAnimationFrame(self.count);
+  };
+  self.printValue(self.startVal);
+};
+export {
+  CountUp
+};

package/dist/es/src/components/countup/index.vue.js

@@ -0,0 +1,117 @@
+const { ref: ref, watch: watch, onMounted: onMounted, nextTick: nextTick, createElementBlock: createElementBlock, openBlock: openBlock, createCommentVNode: createCommentVNode, createElementVNode: createElementVNode, renderSlot: renderSlot, toDisplayString: toDisplayString, normalizeStyle: normalizeStyle, normalizeClass: normalizeClass } = Vue;
+import { CountUp } from "./countUp.js";
+const _hoisted_1 = {
+  key: 0,
+  style: { "color": "#606266" }
+};
+const _hoisted_2 = ["id"];
+const _sfc_main = {
+  __name: "index",
+  props: {
+    idName: {
+      type: String,
+      default: ""
+    },
+    // 标题显示
+    title: {
+      type: String,
+      default: ""
+    },
+    startVal: {
+      type: Number,
+      default: 0
+    },
+    endVal: {
+      type: Number,
+      default: 0
+    },
+    iconType: {
+      type: String,
+      default: ""
+    },
+    color: {
+      type: String,
+      default: "#3b3a3a"
+      // D9524E
+    },
+    introText: {
+      type: String,
+      default: ""
+    },
+    docTypeText: {
+      type: String,
+      default: ""
+    },
+    countSize: {
+      type: String,
+      default: `30px`
+    },
+    countWeight: {
+      type: Number,
+      default: 700
+    },
+    delay: {
+      type: Number,
+      default: 500
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const className = ref("");
+    function transformValue(val) {
+      let endVal = 0;
+      let unit = "";
+      if (val < 1e3) {
+        endVal = val;
+      } else if (val >= 1e3 && val < 1e6) {
+        endVal = parseInt(val / 1e3);
+        unit = "K+";
+      } else if (val >= 1e6 && val < 1e10) {
+        endVal = parseInt(val / 1e6);
+        unit = "M+";
+      } else {
+        endVal = parseInt(val / 1e9);
+        unit = "B+";
+      }
+      return {
+        val: endVal,
+        unit
+      };
+    }
+    let demo = {};
+    watch(() => props.endVal, (val) => {
+      const endVal = val;
+      if (demo.update) {
+        demo.update(endVal);
+      }
+    });
+    onMounted(() => {
+      nextTick(() => {
+        setTimeout(() => {
+          transformValue(props.endVal);
+          const endVal = props.endVal;
+          props.idName;
+          demo = new CountUp(props.idName, props.startVal, endVal, props.decimals, props.duration, props.options);
+          if (!demo.error) {
+            demo.start();
+          }
+        }, props.delay);
+      });
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        __props.title ? (openBlock(), createElementBlock("div", _hoisted_1, toDisplayString(__props.title), 1)) : createCommentVNode("", true),
+        createElementVNode("div", {
+          class: normalizeClass(className.value),
+          style: normalizeStyle({ textAlign: "center", color: __props.color, fontSize: __props.countSize, fontWeight: __props.countWeight, fontFamily: "PingFang SC" })
+        }, [
+          createElementVNode("span", { id: __props.idName }, toDisplayString(__props.startVal), 9, _hoisted_2)
+        ], 6),
+        renderSlot(_ctx.$slots, "intro")
+      ]);
+    };
+  }
+};
+export {
+  _sfc_main as default
+};