@minilo/ui 0.0.6 → 0.0.8

package/minilo/lib/components/virtual-list/index.vue2.js

@@ -1,425 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var vue = require('vue');
-var index = require('../../utils/index.js');
-
-const _hoisted_1 = ["data-index"];
-var _sfc_main = /* @__PURE__ */ vue.defineComponent({
-  ...{
-    name: "MlVirtualList"
-  },
-  __name: "index",
-  props: {
-    height: { type: Number, required: false, default: 500 },
-    itemHeight: { type: Number, required: false, default: 50 },
-    estimatedItemHeight: { type: Number, required: false, default: 50 },
-    itemEqual: { type: Boolean, required: false, default: true },
-    preLoadCount: { type: Number, required: false, default: 5 },
-    threshold: { type: Number, required: false, default: 200 },
-    dataSource: { type: Array, required: false, default: () => [] },
-    loading: { type: Boolean, required: false },
-    finished: { type: Boolean, required: false }
-  },
-  emits: ["load-more"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emit = __emit;
-    const SCROLL_VIEW_HEIGHT = vue.computed(() => props.height);
-    const ITEM_HEIGHT = vue.computed(() => props.itemHeight);
-    const ESTIMATED_ITEM_HEIGHT = vue.computed(() => props.estimatedItemHeight);
-    const PRE_LOAD_COUNT = vue.computed(() => props.preLoadCount);
-    const containerRef = vue.ref(null);
-    const positions = vue.ref([]);
-    const showRange = vue.ref({
-      start: 0,
-      end: 10
-    });
-    let rafId = null;
-    let isRafPending = false;
-    let resizeObserver = null;
-    let resizeUpdateTimer = null;
-    const initPositions = () => {
-      const data = props.dataSource;
-      const height = props.itemEqual ? ITEM_HEIGHT.value : ESTIMATED_ITEM_HEIGHT.value;
-      positions.value = data.map((_, index) => ({
-        index,
-        height,
-        top: index * height,
-        bottom: (index + 1) * height
-      }));
-    };
-    const scrollViewHeight = vue.computed(() => {
-      if (props.itemEqual) {
-        return props.dataSource.length * ITEM_HEIGHT.value;
-      }
-      const len = positions.value.length;
-      const lastPos = positions.value[len - 1];
-      if (len > 0 && lastPos) {
-        return lastPos.bottom;
-      }
-      return 0;
-    });
-    const scrollViewOffset = vue.computed(() => {
-      const start = showRange.value.start;
-      if (props.itemEqual) {
-        return start * ITEM_HEIGHT.value;
-      }
-      return start > 0 && positions.value[start] ? positions.value[start].top : 0;
-    });
-    const currentViewList = vue.computed(() => {
-      return props.dataSource.slice(showRange.value.start, showRange.value.end).map((el, index) => ({
-        data: el,
-        index: showRange.value.start + index
-      }));
-    });
-    const getStartIndex = (scrollTop) => {
-      let start = 0;
-      let end = positions.value.length - 1;
-      let mid = 0;
-      while (start <= end) {
-        mid = Math.floor((start + end) / 2);
-        const midPos = positions.value[mid];
-        if (!midPos) break;
-        const midBottom = midPos.bottom;
-        const midTop = midPos.top;
-        if (midTop <= scrollTop && midBottom > scrollTop) {
-          return mid;
-        } else if (midTop > scrollTop) {
-          end = mid - 1;
-        } else {
-          start = mid + 1;
-        }
-      }
-      return 0;
-    };
-    const updatePositions = () => {
-      if (props.itemEqual) return;
-      const nodes = containerRef.value?.querySelectorAll(".virtual-list-item");
-      if (!nodes || nodes.length === 0) return;
-      nodes.forEach((node) => {
-        const rect = node.getBoundingClientRect();
-        const height = rect.height;
-        const index = parseInt(node.dataset.index || "0");
-        const pos = positions.value[index];
-        if (!pos) return;
-        const oldHeight = pos.height || 0;
-        if (oldHeight !== height) {
-          pos.height = height;
-          pos.bottom = pos.top + height;
-          for (let i = index + 1; i < positions.value.length; i++) {
-            const currentPos = positions.value[i];
-            const prevPos = positions.value[i - 1];
-            if (currentPos && prevPos) {
-              currentPos.top = prevPos.bottom;
-              currentPos.bottom = currentPos.top + currentPos.height;
-            }
-          }
-        }
-      });
-    };
-    const initResizeObserver = () => {
-      if (props.itemEqual) return;
-      if (resizeObserver) {
-        resizeObserver.disconnect();
-      }
-      resizeObserver = new ResizeObserver((entries) => {
-        let needUpdate = false;
-        const changedIndices = [];
-        for (const entry of entries) {
-          const target = entry.target;
-          const index = parseInt(target.dataset.index || "0");
-          const pos = positions.value[index];
-          if (!pos) continue;
-          const newHeight = entry.contentRect.height;
-          const oldHeight = pos.height;
-          if (Math.abs(newHeight - oldHeight) > 1) {
-            needUpdate = true;
-            changedIndices.push(index);
-            pos.height = newHeight;
-            pos.bottom = pos.top + newHeight;
-          }
-        }
-        if (needUpdate) {
-          if (resizeUpdateTimer !== null) {
-            clearTimeout(resizeUpdateTimer);
-          }
-          resizeUpdateTimer = window.setTimeout(() => {
-            const minChangedIndex = Math.min(...changedIndices);
-            for (let i = minChangedIndex + 1; i < positions.value.length; i++) {
-              const currentPos = positions.value[i];
-              const prevPos = positions.value[i - 1];
-              if (currentPos && prevPos) {
-                currentPos.top = prevPos.bottom;
-                currentPos.bottom = currentPos.top + currentPos.height;
-              }
-            }
-            changedIndices.length = 0;
-            resizeUpdateTimer = null;
-          }, 16);
-        }
-      });
-      observeVisibleItems();
-    };
-    const observeVisibleItems = () => {
-      if (!resizeObserver || props.itemEqual) return;
-      resizeObserver.disconnect();
-      const nodes = containerRef.value?.querySelectorAll(".virtual-list-item");
-      if (!nodes) return;
-      nodes.forEach((node) => {
-        resizeObserver.observe(node);
-      });
-    };
-    const calculateRange = () => {
-      const element = containerRef.value;
-      if (!element) return;
-      const scrollTop = element.scrollTop;
-      const clientHeight = element.clientHeight;
-      let start = 0;
-      let end = 0;
-      if (props.itemEqual) {
-        start = Math.floor(scrollTop / ITEM_HEIGHT.value);
-        const viewItemSize = Math.ceil(clientHeight / ITEM_HEIGHT.value);
-        end = start + viewItemSize;
-      } else {
-        if (positions.value.length === 0) return;
-        start = getStartIndex(scrollTop);
-        let totalHeight = 0;
-        const targetHeight = clientHeight + PRE_LOAD_COUNT.value * ESTIMATED_ITEM_HEIGHT.value;
-        for (let i = start; i < positions.value.length; i++) {
-          const pos = positions.value[i];
-          if (!pos) break;
-          totalHeight += pos.height;
-          if (totalHeight >= targetHeight) {
-            end = i + 1;
-            break;
-          }
-          end = i + 1;
-        }
-      }
-      const maxVisibleItems = 10;
-      if (end - start > maxVisibleItems) {
-        end = start + maxVisibleItems;
-      }
-      showRange.value = {
-        start: Math.max(0, start - PRE_LOAD_COUNT.value),
-        end: Math.min(props.dataSource.length, end + PRE_LOAD_COUNT.value)
-      };
-    };
-    const checkLoadMore = () => {
-      const element = containerRef.value;
-      if (!element || props.loading || props.finished) return;
-      const scrollTop = element.scrollTop;
-      const clientHeight = element.clientHeight;
-      const totalHeight = scrollViewHeight.value;
-      const distanceToBottom = totalHeight - scrollTop - clientHeight;
-      if (distanceToBottom < props.threshold) {
-        emit("load-more");
-      }
-    };
-    const onContainerScroll = () => {
-      if (isRafPending) return;
-      isRafPending = true;
-      rafId = requestAnimationFrame(() => {
-        updatePositions();
-        calculateRange();
-        if (props.finished !== void 0 && !props.finished) {
-          checkLoadMore();
-        }
-        isRafPending = false;
-      });
-    };
-    vue.watch(
-      () => props.dataSource.length,
-      (newLen, oldLen = 0) => {
-        if (newLen !== oldLen) {
-          if (props.itemEqual) {
-            initPositions();
-          } else {
-            if (newLen > oldLen) {
-              const height = ESTIMATED_ITEM_HEIGHT.value;
-              for (let i = oldLen; i < newLen; i++) {
-                const lastPos = positions.value[i - 1];
-                positions.value.push({
-                  index: i,
-                  height,
-                  top: lastPos ? lastPos.bottom : 0,
-                  bottom: (lastPos ? lastPos.bottom : 0) + height
-                });
-              }
-            } else {
-              positions.value = positions.value.slice(0, newLen);
-            }
-          }
-          requestAnimationFrame(() => {
-            updatePositions();
-            calculateRange();
-            if (!props.itemEqual) {
-              observeVisibleItems();
-            }
-          });
-        }
-      },
-      { immediate: true }
-    );
-    vue.watch(
-      () => showRange.value,
-      () => {
-        if (!props.itemEqual && resizeObserver) {
-          if (rafId !== null) {
-            cancelAnimationFrame(rafId);
-          }
-          rafId = requestAnimationFrame(() => {
-            observeVisibleItems();
-            rafId = null;
-          });
-        }
-      },
-      { deep: true }
-    );
-    vue.onMounted(() => {
-      initPositions();
-      initResizeObserver();
-      requestAnimationFrame(() => {
-        updatePositions();
-        calculateRange();
-      });
-    });
-    vue.onUnmounted(() => {
-      if (rafId !== null) {
-        cancelAnimationFrame(rafId);
-      }
-      if (resizeUpdateTimer !== null) {
-        clearTimeout(resizeUpdateTimer);
-      }
-      if (resizeObserver) {
-        resizeObserver.disconnect();
-        resizeObserver = null;
-      }
-    });
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock(
-        "div",
-        {
-          class: vue.normalizeClass(vue.unref(index.bem)("virtual-list"))
-        },
-        [
-          vue.createElementVNode(
-            "div",
-            {
-              class: vue.normalizeClass(vue.unref(index.bem)("virtual-list", "container")),
-              ref_key: "containerRef",
-              ref: containerRef,
-              style: vue.normalizeStyle({
-                height: SCROLL_VIEW_HEIGHT.value + "px",
-                overflow: "auto"
-              }),
-              onScroll: onContainerScroll
-            },
-            [
-              vue.createElementVNode(
-                "div",
-                {
-                  class: vue.normalizeClass(vue.unref(index.bem)("virtual-list", "phantom")),
-                  style: vue.normalizeStyle({
-                    height: scrollViewHeight.value + "px"
-                  })
-                },
-                [
-                  vue.createElementVNode(
-                    "div",
-                    {
-                      class: vue.normalizeClass(vue.unref(index.bem)("virtual-list", "content")),
-                      style: vue.normalizeStyle({
-                        transform: `translateY(${scrollViewOffset.value}px)`
-                      })
-                    },
-                    [
-                      (vue.openBlock(true), vue.createElementBlock(
-                        vue.Fragment,
-                        null,
-                        vue.renderList(currentViewList.value, (item) => {
-                          return vue.openBlock(), vue.createElementBlock("div", {
-                            key: item.index,
-                            class: vue.normalizeClass(vue.unref(index.bem)("virtual-list", "item")),
-                            "data-index": item.index,
-                            style: vue.normalizeStyle(__props.itemEqual ? { height: ITEM_HEIGHT.value + "px" } : {})
-                          }, [
-                            vue.renderSlot(_ctx.$slots, "default", {
-                              item: item.data,
-                              index: item.index
-                            })
-                          ], 14, _hoisted_1);
-                        }),
-                        128
-                        /* KEYED_FRAGMENT */
-                      ))
-                    ],
-                    6
-                    /* CLASS, STYLE */
-                  )
-                ],
-                6
-                /* CLASS, STYLE */
-              ),
-              vue.createCommentVNode(" \u52A0\u8F7D\u72B6\u6001\u63D0\u793A\uFF08\u5728\u5BB9\u5668\u5185\u90E8\uFF09 "),
-              props.loading ? (vue.openBlock(), vue.createElementBlock(
-                "div",
-                {
-                  key: 0,
-                  class: vue.normalizeClass(vue.unref(index.bem)("virtual-list", "loading-tip"))
-                },
-                [
-                  vue.renderSlot(_ctx.$slots, "loading", {}, () => [
-                    _cache[0] || (_cache[0] = vue.createElementVNode(
-                      "span",
-                      { class: "loading-spinner" },
-                      null,
-                      -1
-                      /* CACHED */
-                    )),
-                    _cache[1] || (_cache[1] = vue.createElementVNode(
-                      "span",
-                      null,
-                      "\u52A0\u8F7D\u4E2D...",
-                      -1
-                      /* CACHED */
-                    ))
-                  ])
-                ],
-                2
-                /* CLASS */
-              )) : vue.createCommentVNode("v-if", true),
-              vue.createCommentVNode(" \u52A0\u8F7D\u5B8C\u6210\u63D0\u793A "),
-              props.finished && !props.loading ? (vue.openBlock(), vue.createElementBlock(
-                "div",
-                {
-                  key: 1,
-                  class: vue.normalizeClass(vue.unref(index.bem)("virtual-list", "finished-tip"))
-                },
-                [
-                  vue.renderSlot(_ctx.$slots, "finished", {}, () => [
-                    _cache[2] || (_cache[2] = vue.createTextVNode(
-                      "\u5DF2\u52A0\u8F7D\u5168\u90E8\u6570\u636E",
-                      -1
-                      /* CACHED */
-                    ))
-                  ])
-                ],
-                2
-                /* CLASS */
-              )) : vue.createCommentVNode("v-if", true)
-            ],
-            38
-            /* CLASS, STYLE, NEED_HYDRATION */
-          )
-        ],
-        2
-        /* CLASS */
-      );
-    };
-  }
-});
-
-exports.default = _sfc_main;

package/minilo/lib/components/virtual-list/type.d.ts

@@ -1,20 +0,0 @@
-export interface MlVirtualListProps {
-    /** 容器高度，默认 500px */
-    height?: number;
-    /** 列表项高度（定高模式必传） */
-    itemHeight?: number;
-    /** 列表项预估高度（不定高模式使用），默认 50px */
-    estimatedItemHeight?: number;
-    /** 是否为等高列表，true=定高，false=不定高，默认 true */
-    itemEqual?: boolean;
-    /** 预加载数量（上下各预加载几个） */
-    preLoadCount?: number;
-    /** 距离底部多少像素时触发加载 */
-    threshold?: number;
-    /** 数据源 */
-    dataSource?: any[];
-    /** 是否正在加载 */
-    loading?: boolean;
-    /** 是否已加载完所有数据 */
-    finished?: boolean;
-}