@ued_fpi/data-visual 1.0.5 → 1.0.6

package/dist/lib/vendor/lodash-unified@1.0.3_tknf7errc3xdqocd3ryzzla7vq.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/lib/vendor/memoize-one@6.0.0.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/lib/vendor/normalize-wheel-es@1.2.0.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/lib/vendor/tslib@2.3.0.js

@@ -0,0 +1,34 @@
+'use strict';
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+exports.__extends = __extends;

package/dist/lib/vendor/vue-demi@0.14.5_vue@3.3.4.js

@@ -0,0 +1,4 @@
+'use strict';
+
+require('vue');
+

package/dist/lib/vendor/vue3-seamless-scroll@2.0.1.js

@@ -0,0 +1,564 @@
+'use strict';
+
+const vue = require('vue');
+
+/* eslint-disable no-undefined,no-param-reassign,no-shadow */
+
+/**
+ * Throttle execution of a function. Especially useful for rate limiting
+ * execution of handlers on events like resize and scroll.
+ *
+ * @param  {number}    delay -          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+ * @param  {boolean}   [noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds while the
+ *                                    throttled-function is being called. If noTrailing is false or unspecified, callback will be executed one final time
+ *                                    after the last throttled-function call. (After the throttled-function has not been called for `delay` milliseconds,
+ *                                    the internal counter is reset).
+ * @param  {Function}  callback -       A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
+ *                                    to `callback` when the throttled-function is executed.
+ * @param  {boolean}   [debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is false (at end),
+ *                                    schedule `callback` to execute after `delay` ms.
+ *
+ * @returns {Function}  A new, throttled, function.
+ */
+function throttle (delay, noTrailing, callback, debounceMode) {
+  /*
+   * After wrapper has stopped being called, this timeout ensures that
+   * `callback` is executed at the proper times in `throttle` and `end`
+   * debounce modes.
+   */
+  var timeoutID;
+  var cancelled = false; // Keep track of the last time `callback` was executed.
+
+  var lastExec = 0; // Function to clear existing timeout
+
+  function clearExistingTimeout() {
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+    }
+  } // Function to cancel next exec
+
+
+  function cancel() {
+    clearExistingTimeout();
+    cancelled = true;
+  } // `noTrailing` defaults to falsy.
+
+
+  if (typeof noTrailing !== 'boolean') {
+    debounceMode = callback;
+    callback = noTrailing;
+    noTrailing = undefined;
+  }
+  /*
+   * The `wrapper` function encapsulates all of the throttling / debouncing
+   * functionality and when executed will limit the rate at which `callback`
+   * is executed.
+   */
+
+
+  function wrapper() {
+    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+      arguments_[_key] = arguments[_key];
+    }
+
+    var self = this;
+    var elapsed = Date.now() - lastExec;
+
+    if (cancelled) {
+      return;
+    } // Execute `callback` and update the `lastExec` timestamp.
+
+
+    function exec() {
+      lastExec = Date.now();
+      callback.apply(self, arguments_);
+    }
+    /*
+     * If `debounceMode` is true (at begin) this is used to clear the flag
+     * to allow future `callback` executions.
+     */
+
+
+    function clear() {
+      timeoutID = undefined;
+    }
+
+    if (debounceMode && !timeoutID) {
+      /*
+       * Since `wrapper` is being called for the first time and
+       * `debounceMode` is true (at begin), execute `callback`.
+       */
+      exec();
+    }
+
+    clearExistingTimeout();
+
+    if (debounceMode === undefined && elapsed > delay) {
+      /*
+       * In throttle mode, if `delay` time has been exceeded, execute
+       * `callback`.
+       */
+      exec();
+    } else if (noTrailing !== true) {
+      /*
+       * In trailing throttle mode, since `delay` time has not been
+       * exceeded, schedule `callback` to execute `delay` ms after most
+       * recent execution.
+       *
+       * If `debounceMode` is true (at begin), schedule `clear` to execute
+       * after `delay` ms.
+       *
+       * If `debounceMode` is false (at end), schedule `callback` to
+       * execute after `delay` ms.
+       */
+      timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);
+    }
+  }
+
+  wrapper.cancel = cancel; // Return the wrapper function.
+
+  return wrapper;
+}
+
+function useExpose(apis) {
+  const instance = vue.getCurrentInstance();
+
+  if (instance) {
+    Object.assign(instance.proxy, apis);
+  }
+}
+
+const Props = {
+  // 是否开启自动滚动
+  modelValue: {
+    type: Boolean,
+    default: true
+  },
+  // 原始数据列表
+  list: {
+    type: Array,
+    required: true,
+    default: []
+  },
+  // 步进速度，step 需是单步大小的约数
+  step: {
+    type: Number,
+    default: 1
+  },
+  // 开启滚动的数据量
+  limitScrollNum: {
+    type: Number,
+    default: 3
+  },
+  // 是否开启鼠标悬停
+  hover: {
+    type: Boolean,
+    default: false
+  },
+  // 控制滚动方向
+  direction: {
+    type: String,
+    default: "up"
+  },
+  // 单步运动停止的高度
+  singleHeight: {
+    type: Number,
+    default: 0
+  },
+  // 单步运动停止的宽度
+  singleWidth: {
+    type: Number,
+    default: 0
+  },
+  // 单步停止等待时间 (默认值 1000ms)
+  singleWaitTime: {
+    type: Number,
+    default: 1000
+  },
+  // 是否开启 rem 度量
+  isRemUnit: {
+    type: Boolean,
+    default: false
+  },
+  // 开启数据更新监听
+  isWatch: {
+    type: Boolean,
+    default: true
+  },
+  // 动画时间
+  delay: {
+    type: Number,
+    default: 0
+  },
+  // 动画方式
+  ease: {
+    type: [String, Object],
+    default: "ease-in"
+  },
+  // 动画循环次数，-1 表示一直动画
+  count: {
+    type: Number,
+    default: -1
+  },
+  // 拷贝几份滚动列表
+  copyNum: {
+    type: Number,
+    default: 1
+  },
+  // 开启鼠标悬停时支持滚轮滚动
+  wheel: {
+    type: Boolean,
+    default: false
+  },
+  // 启用单行滚动
+  singleLine: {
+    type: Boolean,
+    default: false
+  }
+};
+
+globalThis.window.cancelAnimationFrame = function () {
+  return globalThis.window.cancelAnimationFrame || // @ts-ignore
+  globalThis.window.webkitCancelAnimationFrame || // @ts-ignore
+  globalThis.window.mozCancelAnimationFrame || // @ts-ignore
+  globalThis.window.oCancelAnimationFrame || // @ts-ignore
+  globalThis.window.msCancelAnimationFrame || function (id) {
+    return globalThis.window.clearTimeout(id);
+  };
+}();
+
+globalThis.window.requestAnimationFrame = function () {
+  return globalThis.window.requestAnimationFrame || // @ts-ignore
+  globalThis.window.webkitRequestAnimationFrame || // @ts-ignore
+  globalThis.window.mozRequestAnimationFrame || // @ts-ignore
+  globalThis.window.oRequestAnimationFrame || // @ts-ignore
+  globalThis.window.msRequestAnimationFrame || function (callback) {
+    return globalThis.window.setTimeout(callback, 1000 / 60);
+  };
+}();
+
+function dataWarm(list) {
+  if (list && typeof list !== "boolean" && list.length > 100) {
+    console.warn(`数据达到了${list.length}条有点多哦~,可能会造成部分老旧浏览器卡顿。`);
+  }
+}
+
+const Vue3SeamlessScroll = vue.defineComponent({
+  name: "vue3-seamless-scroll",
+  inheritAttrs: false,
+  props: Props,
+  emits: ["stop", "count", "move"],
+
+  setup(_props, {
+    slots,
+    emit,
+    attrs
+  }) {
+    const props = _props;
+    const scrollRef = vue.ref(null);
+    const slotListRef = vue.ref(null);
+    const realBoxRef = vue.ref(null);
+    const reqFrame = vue.ref(null);
+    const singleWaitTimeout = vue.ref(null);
+    const realBoxWidth = vue.ref(0);
+    const realBoxHeight = vue.ref(0);
+    const xPos = vue.ref(0);
+    const yPos = vue.ref(0);
+    const isHover = vue.ref(false);
+
+    const _count = vue.ref(0);
+
+    const isScroll = vue.computed(() => props.list ? props.list.length >= props.limitScrollNum : false);
+    const realBoxStyle = vue.computed(() => {
+      return {
+        width: realBoxWidth.value ? `${realBoxWidth.value}px` : "auto",
+        transform: `translate(${xPos.value}px,${yPos.value}px)`,
+        // @ts-ignore
+        transition: `all ${typeof props.ease === "string" ? props.ease : "cubic-bezier(" + props.ease.x1 + "," + props.ease.y1 + "," + props.ease.x2 + "," + props.ease.y2 + ")"} ${props.delay}ms`,
+        overflow: "hidden",
+        display: props.singleLine ? "flex" : "block"
+      };
+    });
+    const isHorizontal = vue.computed(() => props.direction == "left" || props.direction == "right");
+    const floatStyle = vue.computed(() => {
+      return isHorizontal.value ? {
+        float: "left",
+        overflow: "hidden",
+        display: props.singleLine ? "flex" : "block",
+        flexShrink: props.singleLine ? 0 : 1
+      } : {
+        overflow: "hidden"
+      };
+    });
+    const baseFontSize = vue.computed(() => {
+      return props.isRemUnit ? parseInt(globalThis.window.getComputedStyle(globalThis.document.documentElement, null).fontSize) : 1;
+    });
+    const realSingleStopWidth = vue.computed(() => props.singleWidth * baseFontSize.value);
+    const realSingleStopHeight = vue.computed(() => props.singleHeight * baseFontSize.value);
+    const step = vue.computed(() => {
+      let singleStep;
+      let _step = props.step;
+
+      if (isHorizontal.value) {
+        singleStep = realSingleStopWidth.value;
+      } else {
+        singleStep = realSingleStopHeight.value;
+      }
+
+      if (singleStep > 0 && singleStep % _step > 0) {
+        console.error("如果设置了单步滚动，step 需是单步大小的约数，否则无法保证单步滚动结束的位置是否准确。~~~~~");
+      }
+
+      return _step;
+    });
+
+    const cancle = () => {
+      cancelAnimationFrame(reqFrame.value);
+      reqFrame.value = null;
+    };
+
+    const animation = (_direction, _step, isWheel) => {
+      reqFrame.value = requestAnimationFrame(function () {
+        const h = realBoxHeight.value / 2;
+        const w = realBoxWidth.value / 2;
+
+        if (_direction === "up") {
+          if (Math.abs(yPos.value) >= h) {
+            yPos.value = 0;
+            _count.value += 1;
+            emit("count", _count.value);
+          }
+
+          yPos.value -= _step;
+        } else if (_direction === "down") {
+          if (yPos.value >= 0) {
+            yPos.value = h * -1;
+            _count.value += 1;
+            emit("count", _count.value);
+          }
+
+          yPos.value += _step;
+        } else if (_direction === "left") {
+          if (Math.abs(xPos.value) >= w) {
+            xPos.value = 0;
+            _count.value += 1;
+            emit("count", _count.value);
+          }
+
+          xPos.value -= _step;
+        } else if (_direction === "right") {
+          if (xPos.value >= 0) {
+            xPos.value = w * -1;
+            _count.value += 1;
+            emit("count", _count.value);
+          }
+
+          xPos.value += _step;
+        }
+
+        if (isWheel) {
+          return;
+        }
+
+        let {
+          singleWaitTime
+        } = props;
+
+        if (singleWaitTimeout.value) {
+          clearTimeout(singleWaitTimeout.value);
+        }
+
+        if (!!realSingleStopHeight.value) {
+          if (Math.abs(yPos.value) % realSingleStopHeight.value < _step) {
+            singleWaitTimeout.value = setTimeout(() => {
+              move();
+            }, singleWaitTime);
+          } else {
+            move();
+          }
+        } else if (!!realSingleStopWidth.value) {
+          if (Math.abs(xPos.value) % realSingleStopWidth.value < _step) {
+            singleWaitTimeout.value = setTimeout(() => {
+              move();
+            }, singleWaitTime);
+          } else {
+            move();
+          }
+        } else {
+          move();
+        }
+      });
+    };
+
+    const move = () => {
+      cancle();
+
+      if (isHover.value || !isScroll.value || _count.value === props.count) {
+        emit("stop", _count.value);
+        _count.value = 0;
+        return;
+      }
+
+      animation(props.direction, step.value, false);
+    };
+
+    const initMove = () => {
+      dataWarm(props.list);
+
+      if (isHorizontal.value) {
+        let slotListWidth = slotListRef.value.offsetWidth;
+        slotListWidth = slotListWidth * 2 + 1;
+        realBoxWidth.value = slotListWidth;
+      }
+
+      if (isScroll.value) {
+        realBoxHeight.value = realBoxRef.value.offsetHeight;
+
+        if (props.modelValue) {
+          move();
+        }
+      } else {
+        cancle();
+        yPos.value = xPos.value = 0;
+      }
+    };
+
+    const startMove = () => {
+      isHover.value = false;
+      move();
+    };
+
+    const stopMove = () => {
+      isHover.value = true;
+
+      if (singleWaitTimeout.value) {
+        clearTimeout(singleWaitTimeout.value);
+      }
+
+      cancle();
+    };
+
+    const hoverStop = vue.computed(() => props.hover && props.modelValue && isScroll.value);
+    const throttleFunc = throttle(30, e => {
+      cancle();
+      const singleHeight = !!realSingleStopHeight.value ? realSingleStopHeight.value : 15;
+
+      if (e.deltaY < 0) {
+        animation("down", singleHeight, true);
+      }
+
+      if (e.deltaY > 0) {
+        animation("up", singleHeight, true);
+      }
+    });
+
+    const onWheel = e => {
+      throttleFunc(e);
+    };
+
+    const reset = () => {
+      cancle();
+      isHover.value = false;
+      initMove();
+    };
+
+    const Reset = () => {
+      reset();
+    };
+
+    useExpose({
+      Reset
+    });
+    vue.watch(() => props.list, () => {
+      if (props.isWatch) {
+        vue.nextTick(() => {
+          reset();
+        });
+      }
+    }, {
+      deep: true
+    });
+    vue.watch(() => props.modelValue, newValue => {
+      if (newValue) {
+        startMove();
+      } else {
+        stopMove();
+      }
+    });
+    vue.watch(() => props.count, newValue => {
+      if (newValue !== 0) {
+        startMove();
+      }
+    });
+    vue.onBeforeMount(() => {
+      cancle();
+      clearTimeout(singleWaitTimeout.value);
+    });
+    vue.onMounted(() => {
+      if (isScroll.value) {
+        initMove();
+      }
+    });
+    const {
+      default: $default,
+      html
+    } = slots;
+    const copyNum = new Array(props.copyNum).fill(null);
+
+    const getHtml = () => {
+      return vue.createVNode(vue.Fragment, null, [vue.createVNode("div", {
+        "ref": slotListRef,
+        "style": floatStyle.value
+      }, [$default && $default()]), isScroll.value ? copyNum.map(() => {
+        if (html && typeof html === "function") {
+          return vue.createVNode("div", {
+            "style": floatStyle.value
+          }, [html()]);
+        } else {
+          return vue.createVNode("div", {
+            "style": floatStyle.value
+          }, [$default && $default()]);
+        }
+      }) : null]);
+    };
+
+    return () => vue.createVNode("div", {
+      "ref": scrollRef,
+      "class": attrs.class
+    }, [props.wheel && props.hover ? vue.createVNode("div", {
+      "ref": realBoxRef,
+      "style": realBoxStyle.value,
+      "onMouseenter": () => {
+        if (hoverStop.value) {
+          stopMove();
+        }
+      },
+      "onMouseleave": () => {
+        if (hoverStop.value) {
+          startMove();
+        }
+      },
+      "onWheel": e => {
+        if (hoverStop.value) {
+          onWheel(e);
+        }
+      }
+    }, [getHtml()]) : vue.createVNode("div", {
+      "ref": realBoxRef,
+      "style": realBoxStyle.value,
+      "onMouseenter": () => {
+        if (hoverStop.value) {
+          stopMove();
+        }
+      },
+      "onMouseleave": () => {
+        if (hoverStop.value) {
+          startMove();
+        }
+      }
+    }, [getHtml()])]);
+  }
+
+});
+
+exports.Vue3SeamlessScroll = Vue3SeamlessScroll;