@ued_fpi/data-visual 1.0.5 → 1.0.7

package/dist/es/vendor/@ued_fpi_element-plus-expand@0.7.19.mjs

@@ -0,0 +1,243 @@
+import { defineComponent, ref, computed, watch, onMounted, nextTick, onUnmounted, openBlock, createElementBlock, createElementVNode, normalizeClass, normalizeStyle, unref, renderSlot, createCommentVNode } from 'vue';
+import './dayjs@1.11.9.mjs';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const __default__ = {
+  name: "FpiElRolling"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__), {
+  props: {
+    direction: {
+      type: String,
+      default: "x"
+    },
+    modelValue: {
+      type: Boolean,
+      default: void 0
+    },
+    time: {
+      type: Number,
+      default: 10
+    },
+    action: {
+      type: String,
+      default: "hover"
+    },
+    scrollAble: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["update:modelValue", "domChange", "change"],
+  setup(__props, { expose, emit: emits }) {
+    const props = __props;
+    const rollingBody = ref();
+    const rollingBoxBody = ref();
+    const staticModelValue = ref(true);
+    const forcedStop = ref(false);
+    const animationName = `rollingsAnnualTasks${Math.floor(Math.random() * 1e5)}`;
+    let distance = 0;
+    let hasAnimation = false;
+    let observer = null;
+    const isRolling = computed({
+      get() {
+        return props.modelValue === void 0 ? staticModelValue.value : props.modelValue;
+      },
+      set(val) {
+        props.modelValue === void 0 ? staticModelValue.value = val : emits("update:modelValue", val);
+      }
+    });
+    watch(() => isRolling.value, (val) => {
+      !hasAnimation && val && controlAnimation();
+    });
+    watch(() => props.time, () => {
+      isRolling.value && controlAnimation();
+    });
+    onMounted(() => {
+      checkDistance();
+      observer = new MutationObserver((MutationObserver2) => {
+        checkDistance(MutationObserver2);
+      });
+      nextTick(() => {
+        rollingBody.value && observer.observe(rollingBody.value, {
+          attributes: true,
+          childList: true,
+          characterData: true,
+          subtree: true
+        });
+      });
+    });
+    onUnmounted(() => {
+      clearAnimation();
+      observer && observer.disconnect();
+    });
+    const checkDistance = (MutationObserver2) => {
+      const { fatherDistance, currDistance } = getDistance();
+      if (currDistance === distance)
+        return;
+      distance = currDistance;
+      MutationObserver2 && emits("domChange", currDistance, MutationObserver2);
+      if (!isRolling.value)
+        return;
+      changeForcedStop(fatherDistance > currDistance);
+    };
+    const startAnimation = () => {
+      isRolling.value = true;
+      controlAnimation();
+    };
+    const getDistance = () => {
+      const dom = rollingBody.value;
+      const domFather = rollingBoxBody.value;
+      const currDistance = (props.direction === "x" ? dom.offsetWidth : dom.offsetHeight) / (forcedStop.value ? 1 : 2);
+      const fatherDistance = props.direction === "x" ? domFather.offsetWidth : domFather.offsetHeight;
+      return { fatherDistance, currDistance };
+    };
+    const controlAnimation = () => {
+      const dom = rollingBody.value;
+      if (!dom)
+        return;
+      const { currDistance } = getDistance();
+      distance = currDistance;
+      const style = clearAnimation();
+      if (!isRolling.value || !style)
+        return;
+      dom.style.animationPlayState = "";
+      style.insertRule(`@keyframes ${animationName} {0%{ transform: translateX(0%);}100%{transform: translate${props.direction === "x" ? "X" : "Y"}(-${distance}px);}}`, 0);
+      hasAnimation = true;
+    };
+    const clearAnimation = () => {
+      const style = document.styleSheets[0];
+      if (!style)
+        return;
+      const styleArray = [].slice.call(style.cssRules);
+      const index = styleArray.findIndex((item) => item.name === animationName);
+      if (index !== -1)
+        style.deleteRule(index);
+      hasAnimation = false;
+      return style;
+    };
+    const mousewheel = (e) => {
+      if (!props.scrollAble)
+        return;
+      e.preventDefault();
+      let offset = props.direction === "y" ? e.wheelDeltaY : e.wheelDeltaX;
+      const { fatherDistance } = getDistance();
+      const currMaxDis = fatherDistance / 5 * 2;
+      offset = offset > currMaxDis ? currMaxDis : offset < -currMaxDis ? -currMaxDis : offset;
+      const element = document.getElementById(animationName);
+      if (!element)
+        return;
+      const animation = element.getAnimations();
+      animation.forEach((item) => {
+        const currTime = (item.currentTime || 0) - offset * 10;
+        item.currentTime = currTime < 0 ? props.time * 1e3 + currTime : currTime;
+      });
+    };
+    const mouseenter = () => {
+      if (forcedStop.value)
+        return;
+      if (props.action === "hover") {
+        isRolling.value = false;
+        emits("change", false);
+      }
+    };
+    const mouseleave = () => {
+      if (forcedStop.value)
+        return;
+      if (props.action === "hover") {
+        isRolling.value = true;
+        emits("change", true);
+      }
+    };
+    const handleClick = () => {
+      if (forcedStop.value)
+        return;
+      if (props.action === "click") {
+        emits("change", !isRolling.value);
+        isRolling.value = !isRolling.value;
+      }
+    };
+    const handleDblclick = () => {
+      if (forcedStop.value)
+        return;
+      if (props.action === "dblclick") {
+        emits("change", !isRolling.value);
+        isRolling.value = !isRolling.value;
+      }
+    };
+    const changeForcedStop = (val) => {
+      forcedStop.value = val;
+      if (forcedStop.value)
+        clearAnimation();
+      else
+        controlAnimation();
+      return forcedStop;
+    };
+    expose({
+      clearAnimation,
+      controlAnimation,
+      changeForcedStop,
+      startAnimation,
+      animationName,
+      isRolling,
+      forcedStop
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "rollingBoxBody",
+        ref: rollingBoxBody,
+        class: "fpi-el-rolling-box"
+      }, [
+        createElementVNode("div", {
+          id: animationName,
+          ref_key: "rollingBody",
+          ref: rollingBody,
+          class: normalizeClass(["fpi-el-rolling", { "fpi-el-rolling-flex": __props.direction === "x" }]),
+          style: normalizeStyle({
+            animation: `${animationName} ${__props.time}s linear infinite`,
+            animationPlayState: unref(isRolling) ? "running" : "paused",
+            height: __props.direction === "x" ? "100%" : void 0,
+            width: __props.direction === "y" ? "100%" : void 0
+          }),
+          onMouseenter: mouseenter,
+          onMouseleave: mouseleave,
+          onDblclick: handleDblclick,
+          onClick: handleClick,
+          onMousewheel: mousewheel
+        }, [
+          renderSlot(_ctx.$slots, "default"),
+          !forcedStop.value ? renderSlot(_ctx.$slots, "default", { key: 0 }) : createCommentVNode("", true)
+        ], 38)
+      ], 512);
+    };
+  }
+}));
+
+const install = (comp) => {
+  comp.install = (app) => {
+    const name = comp.name || comp.__name;
+    app.component(name, comp);
+  };
+  return comp;
+};
+const FpiElRolling = install(_sfc_main);
+
+export { FpiElRolling as F };

package/dist/es/vendor/@vue_reactivity@3.3.4.mjs

@@ -0,0 +1 @@
+

package/dist/es/vendor/@vue_shared@3.3.4.mjs

@@ -0,0 +1,29 @@
+!!(process.env.NODE_ENV !== "production") ? Object.freeze({}) : {};
+!!(process.env.NODE_ENV !== "production") ? Object.freeze([]) : [];
+const NOOP = () => {
+};
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty.call(val, key);
+const isArray = Array.isArray;
+const isDate = (val) => toTypeString(val) === "[object Date]";
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const isObject = (val) => val !== null && typeof val === "object";
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const toRawType = (value) => {
+  return toTypeString(value).slice(8, -1);
+};
+const cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+};
+const camelizeRE = /-(\w)/g;
+const camelize = cacheStringFunction((str) => {
+  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+
+export { NOOP as N, isArray as a, isObject as b, camelize as c, isFunction as d, isDate as e, hasOwn as h, isString as i, toRawType as t };

package/dist/es/vendor/@vueuse_core@9.13.0_vue@3.3.4.mjs

@@ -0,0 +1,214 @@
+import { i as isString, n as noop, r as resolveUnref, t as tryOnScopeDispose, a as isClient, b as tryOnMounted, c as identity, d as isIOS } from './@vueuse_shared@9.13.0_vue@3.3.4.mjs';
+import { watch, ref } from 'vue';
+
+function unrefElement(elRef) {
+  var _a;
+  const plain = resolveUnref(elRef);
+  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
+}
+
+const defaultWindow = isClient ? window : void 0;
+
+function useEventListener(...args) {
+  let target;
+  let events;
+  let listeners;
+  let options;
+  if (isString(args[0]) || Array.isArray(args[0])) {
+    [events, listeners, options] = args;
+    target = defaultWindow;
+  } else {
+    [target, events, listeners, options] = args;
+  }
+  if (!target)
+    return noop;
+  if (!Array.isArray(events))
+    events = [events];
+  if (!Array.isArray(listeners))
+    listeners = [listeners];
+  const cleanups = [];
+  const cleanup = () => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  };
+  const register = (el, event, listener, options2) => {
+    el.addEventListener(event, listener, options2);
+    return () => el.removeEventListener(event, listener, options2);
+  };
+  const stopWatch = watch(() => [unrefElement(target), resolveUnref(options)], ([el, options2]) => {
+    cleanup();
+    if (!el)
+      return;
+    cleanups.push(...events.flatMap((event) => {
+      return listeners.map((listener) => register(el, event, listener, options2));
+    }));
+  }, { immediate: true, flush: "post" });
+  const stop = () => {
+    stopWatch();
+    cleanup();
+  };
+  tryOnScopeDispose(stop);
+  return stop;
+}
+
+let _iOSWorkaround = false;
+function onClickOutside(target, handler, options = {}) {
+  const { window = defaultWindow, ignore = [], capture = true, detectIframe = false } = options;
+  if (!window)
+    return;
+  if (isIOS && !_iOSWorkaround) {
+    _iOSWorkaround = true;
+    Array.from(window.document.body.children).forEach((el) => el.addEventListener("click", noop));
+  }
+  let shouldListen = true;
+  const shouldIgnore = (event) => {
+    return ignore.some((target2) => {
+      if (typeof target2 === "string") {
+        return Array.from(window.document.querySelectorAll(target2)).some((el) => el === event.target || event.composedPath().includes(el));
+      } else {
+        const el = unrefElement(target2);
+        return el && (event.target === el || event.composedPath().includes(el));
+      }
+    });
+  };
+  const listener = (event) => {
+    const el = unrefElement(target);
+    if (!el || el === event.target || event.composedPath().includes(el))
+      return;
+    if (event.detail === 0)
+      shouldListen = !shouldIgnore(event);
+    if (!shouldListen) {
+      shouldListen = true;
+      return;
+    }
+    handler(event);
+  };
+  const cleanup = [
+    useEventListener(window, "click", listener, { passive: true, capture }),
+    useEventListener(window, "pointerdown", (e) => {
+      const el = unrefElement(target);
+      if (el)
+        shouldListen = !e.composedPath().includes(el) && !shouldIgnore(e);
+    }, { passive: true }),
+    detectIframe && useEventListener(window, "blur", (event) => {
+      var _a;
+      const el = unrefElement(target);
+      if (((_a = window.document.activeElement) == null ? void 0 : _a.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(window.document.activeElement)))
+        handler(event);
+    })
+  ].filter(Boolean);
+  const stop = () => cleanup.forEach((fn) => fn());
+  return stop;
+}
+
+function useSupported(callback, sync = false) {
+  const isSupported = ref();
+  const update = () => isSupported.value = Boolean(callback());
+  update();
+  tryOnMounted(update, sync);
+  return isSupported;
+}
+
+const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+const globalKey = "__vueuse_ssr_handlers__";
+_global[globalKey] = _global[globalKey] || {};
+
+var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
+var __hasOwnProp$g = Object.prototype.hasOwnProperty;
+var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
+var __objRest$2 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$g.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$g)
+    for (var prop of __getOwnPropSymbols$g(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$g.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function useResizeObserver(target, callback, options = {}) {
+  const _a = options, { window = defaultWindow } = _a, observerOptions = __objRest$2(_a, ["window"]);
+  let observer;
+  const isSupported = useSupported(() => window && "ResizeObserver" in window);
+  const cleanup = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = void 0;
+    }
+  };
+  const stopWatch = watch(() => unrefElement(target), (el) => {
+    cleanup();
+    if (isSupported.value && window && el) {
+      observer = new ResizeObserver(callback);
+      observer.observe(el, observerOptions);
+    }
+  }, { immediate: true, flush: "post" });
+  const stop = () => {
+    cleanup();
+    stopWatch();
+  };
+  tryOnScopeDispose(stop);
+  return {
+    isSupported,
+    stop
+  };
+}
+
+var SwipeDirection;
+(function(SwipeDirection2) {
+  SwipeDirection2["UP"] = "UP";
+  SwipeDirection2["RIGHT"] = "RIGHT";
+  SwipeDirection2["DOWN"] = "DOWN";
+  SwipeDirection2["LEFT"] = "LEFT";
+  SwipeDirection2["NONE"] = "NONE";
+})(SwipeDirection || (SwipeDirection = {}));
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+const _TransitionPresets = {
+  easeInSine: [0.12, 0, 0.39, 0],
+  easeOutSine: [0.61, 1, 0.88, 1],
+  easeInOutSine: [0.37, 0, 0.63, 1],
+  easeInQuad: [0.11, 0, 0.5, 0],
+  easeOutQuad: [0.5, 1, 0.89, 1],
+  easeInOutQuad: [0.45, 0, 0.55, 1],
+  easeInCubic: [0.32, 0, 0.67, 0],
+  easeOutCubic: [0.33, 1, 0.68, 1],
+  easeInOutCubic: [0.65, 0, 0.35, 1],
+  easeInQuart: [0.5, 0, 0.75, 0],
+  easeOutQuart: [0.25, 1, 0.5, 1],
+  easeInOutQuart: [0.76, 0, 0.24, 1],
+  easeInQuint: [0.64, 0, 0.78, 0],
+  easeOutQuint: [0.22, 1, 0.36, 1],
+  easeInOutQuint: [0.83, 0, 0.17, 1],
+  easeInExpo: [0.7, 0, 0.84, 0],
+  easeOutExpo: [0.16, 1, 0.3, 1],
+  easeInOutExpo: [0.87, 0, 0.13, 1],
+  easeInCirc: [0.55, 0, 1, 0.45],
+  easeOutCirc: [0, 0.55, 0.45, 1],
+  easeInOutCirc: [0.85, 0, 0.15, 1],
+  easeInBack: [0.36, 0, 0.66, -0.56],
+  easeOutBack: [0.34, 1.56, 0.64, 1],
+  easeInOutBack: [0.68, -0.6, 0.32, 1.6]
+};
+__spreadValues({
+  linear: identity
+}, _TransitionPresets);
+
+export { useEventListener as a, unrefElement as b, onClickOutside as o, useResizeObserver as u };

package/dist/es/vendor/@vueuse_shared@9.13.0_vue@3.3.4.mjs

@@ -0,0 +1,72 @@
+import { unref, getCurrentScope, onScopeDispose, getCurrentInstance, onMounted, nextTick, ref, readonly } from 'vue';
+
+var _a;
+const isClient = typeof window !== "undefined";
+const isString = (val) => typeof val === "string";
+const noop = () => {
+};
+const isIOS = isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /iP(ad|hone|od)/.test(window.navigator.userAgent);
+
+function resolveUnref(r) {
+  return typeof r === "function" ? r() : unref(r);
+}
+function identity(arg) {
+  return arg;
+}
+
+function tryOnScopeDispose(fn) {
+  if (getCurrentScope()) {
+    onScopeDispose(fn);
+    return true;
+  }
+  return false;
+}
+
+function tryOnMounted(fn, sync = true) {
+  if (getCurrentInstance())
+    onMounted(fn);
+  else if (sync)
+    fn();
+  else
+    nextTick(fn);
+}
+
+function useTimeoutFn(cb, interval, options = {}) {
+  const {
+    immediate = true
+  } = options;
+  const isPending = ref(false);
+  let timer = null;
+  function clear() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function stop() {
+    isPending.value = false;
+    clear();
+  }
+  function start(...args) {
+    clear();
+    isPending.value = true;
+    timer = setTimeout(() => {
+      isPending.value = false;
+      timer = null;
+      cb(...args);
+    }, resolveUnref(interval));
+  }
+  if (immediate) {
+    isPending.value = true;
+    if (isClient)
+      start();
+  }
+  tryOnScopeDispose(stop);
+  return {
+    isPending: readonly(isPending),
+    start,
+    stop
+  };
+}
+
+export { isClient as a, tryOnMounted as b, identity as c, isIOS as d, isString as i, noop as n, resolveUnref as r, tryOnScopeDispose as t, useTimeoutFn as u };

package/dist/es/vendor/async-validator@4.2.5.mjs

@@ -0,0 +1 @@
+