plain-design 1.0.0-beta.10 → 1.0.0-beta.100

package/src/packages/components/VirtualList/useVirtualList.tsx

@@ -1,31 +1,52 @@
-import {computed, getComponentCls, onMounted, onUpdated, reactive, useClasses, useStyles, watch} from "plain-design-composition";
+import {computed, getComponentCls, onBeforeUnmount, onMounted, onUpdated, reactive, useClasses, useStyles, watch} from "plain-design-composition";
+import {createCounter} from 'plain-utils/utils/createCounter';
 import {delay} from "plain-utils/utils/delay";
 import './virtual-list.scss';
 import Scroll from "../Scroll";
 import {unit} from "plain-utils/string/unit";
+import {createEnum} from "plain-utils/utils/createEnum";
+import {PlainObject} from "plain-utils/utils/event";
+import {addWindowListener} from "plain-utils/dom/addWindowListener";
 
 interface DataNode {
-  top: number;
-  bottom: number;
-  height: number;
-
-  data: any;
-  index: number;
+  start: number;
+  end: number;
+  size: number;
+  item: any;
+  id: string;
+  index: number,
 }
 
+/**
+ * 滚动的方向
+ * 纵向：start表示往上滚动，end表示往下滚动
+ * 横向：start表示往左滚动，end表示往右滚动
+ * @author  韦胜健
+ * @date    2024/1/10 14:37
+ */
+const ScrollDirection = createEnum(['start', 'end', 'none'] as const);
+
+const nextRowId = createCounter('__v__');
+
 export function useVirtualList(
   {
+    dataModel,
     props,
     refs,
     emit,
     transform,
   }: {
+    dataModel: { value: any[] | undefined | null },
     props: {
-      data: any[],
       size: number,
       disabled?: boolean,
       dynamicSize?: boolean,
+      /*纵向虚拟滚动，需要横向滚动的时候必须指定宽度*/
       width?: string | number,
+      /*横向虚拟滚动，需要纵向滚动的时候必须指定高度*/
+      height?: string | number,
+      /*启用横向虚拟滚动*/
+      horizontal?: boolean,
     },
     refs: {
       scroll?: typeof Scroll.use.class | null,
@@ -33,7 +54,7 @@ export function useVirtualList(
     },
     emit: {
       onScroll: (e: Event) => void,
-      onPageIndexChange: (data: { pageIndex: number, start: number }) => void,
+      onPageIndexChange: (data: { pageIndex: number, startIndex: number, endIndex: number }) => void,
     },
     transform?: boolean,
   }
@@ -41,18 +62,58 @@ export function useVirtualList(
 
   /*非响应式属性*/
   const freezeState = {
-    scrollTop: 0,                               // 实时的scrollTop值
-    current: {                                  // 当前的页面信息
+    scrollValue: 0,                               // 实时的scrollTop值
+    current: {                                    // 当前的页面信息
       pageIndex: 0,
-      start: 0,
-      end: 0,
+      startIndex: 0,
+      endIndex: 0,
     },
   };
   /*响应式属性*/
   const state = reactive({
-    nodes: [] as DataNode[],                    // 格式化的data数组数据
-    scrollTop: 0,                               // 当前滚动scrollTop（非实时的）
-    pageSize: 0,                                // 页大小
+    scrollValue: 0,                               // 当前滚动scrollTop（非实时的）
+    hostSize: null as null | number,              // 容器高度
+    scrollDirection: ScrollDirection.none as typeof ScrollDirection.TYPE,
+    id2size: {} as Record<string, number | undefined>,
+  });
+
+  const _avgSize = computed((): number => {
+    const total = Object.values(state.id2size).reduce((prev, item) => {
+      if (item != null) {
+        prev.total += item;
+        prev.count++;
+      }
+      return prev;
+    }, { total: 0, count: 0 });
+    if (!!total.count) {
+      return Math.floor(total.total / total.count);
+    } else {
+      return props.size;
+    }
+  });
+
+  const _pageSize = computed(() => {
+    if (state.hostSize == null) {return null;}
+    return Math.floor(state.hostSize / _avgSize.value);
+  });
+
+  const idMap = new WeakMap<PlainObject, string>();
+  let prevEnd = 0;
+
+  const nodes = computed((): iVirtualNode[] => {
+    prevEnd = 0;
+    return (dataModel.value || []).map((item, index): DataNode => {
+      let id = idMap.get(item);
+      if (!id) {
+        id = nextRowId();
+        idMap.set(item, id);
+      }
+      const size: number = state.id2size[id] || _avgSize.value;
+      let start = prevEnd;
+      let end = start + size;
+      prevEnd = end;
+      return { id: id!, item, size, start, end, index };
+    });
   });
 
   /**
@@ -60,24 +121,24 @@ export function useVirtualList(
    * @author  韦胜健
    * @date    2020/11/15 9:28
    */
-  const offsetData = computed((): { list: { item: any, index: number }[], startPageIndex: number, start: number } => {
-    const { pageSize, scrollTop } = state;
-    const data = props.data || [];
+  const offsetData = computed((): { list: { item: any, id: string, index: number }[], startPageIndex: number, startIndex: number } => {
+    const pageSize = _pageSize.value;
+    const { scrollValue } = state;
     if (!pageSize) {
-      return { list: [], startPageIndex: 0, start: 0 };
+      return { list: [], startPageIndex: 0, startIndex: 0 };
     }
     if (props.disabled) {
       return {
-        list: data.map((item, index) => ({ item, index })),
-        start: 0,
+        list: nodes.value,
+        startIndex: 0,
         startPageIndex: 0,
       };
     }
-    const { start, end, pageIndex } = utils.getPageIndex(scrollTop, pageSize);
+    const { startIndex, endIndex, pageIndex } = utils.getPageIndex(scrollValue);
     return {
-      list: data.map((item, index) => ({ item, index })).slice(start, end),
+      list: nodes.value.slice(startIndex, endIndex),
       startPageIndex: pageIndex,
-      start,
+      startIndex,
     };
   });
 
@@ -90,7 +151,10 @@ export function useVirtualList(
    */
   const classes = useClasses(() => [
     getComponentCls('virtual-list'),
-    { 'virtual-list-disabled': props.disabled, }
+    {
+      'virtual-list-disabled': props.disabled,
+      'virtual-list-horizontal': props.horizontal,
+    },
   ]);
 
   /**
@@ -99,20 +163,34 @@ export function useVirtualList(
    * @date    2020/12/16 10:48
    */
   const strutStyles = useStyles(style => {
-    if (!state.pageSize) {
+    if (!_pageSize.value) {
       return;
     }
     if (props.disabled) {
       return;
     }
-    if (!!props.width) {
-      style.width = unit(props.width);
-      style.minWidth = '100%';
-    }
-    if (!props.dynamicSize) {
-      style.height = `${(props.data || []).length * props.size}px`;
+    if (!props.horizontal) {
+      /*纵向*/
+      if (!!props.width) {
+        style.width = unit(props.width);
+        style.minWidth = '100%';
+      }
+      if (!props.dynamicSize) {
+        style.height = `${(dataModel.value || []).length * props.size}px`;
+      } else {
+        style.height = `${nodes.value[nodes.value.length - 1].end}px`;
+      }
     } else {
-      style.height = `${state.nodes[state.nodes.length - 1].bottom}px`;
+      /*横向*/
+      if (!!props.height) {
+        style.height = unit(props.height);
+        style.minHeight = '100%';
+      }
+      if (!props.dynamicSize) {
+        style.width = `${(dataModel.value || []).length * props.size}px`;
+      } else {
+        style.width = `${nodes.value[nodes.value.length - 1].end}px`;
+      }
     }
   });
 
@@ -123,28 +201,40 @@ export function useVirtualList(
    */
   const contentStyles = useStyles(style => {
 
-    if (!state.pageSize) {
+    if (!_pageSize.value) {
       return;
     }
     if (props.disabled) {
       return;
     }
 
-    const { start } = offsetData.value;
+    const { startIndex } = offsetData.value;
 
-    let top;
+    let start;
     if (!props.dynamicSize) {
-      top = start * props.size;
+      start = startIndex * props.size;
     } else {
-      top = state.nodes[start].top;
+      start = nodes.value[startIndex].start;
     }
 
-    if (transform !== false) {
-      /*transform定位*/
-      style.transform = `translateY(${top}px)`;
+    if (!props.horizontal) {
+      /*纵向定位*/
+      if (transform !== false) {
+        /*transform定位*/
+        style.transform = `translateY(${start}px)`;
+      } else {
+        /*top定位*/
+        style.top = `${start}px`;
+      }
     } else {
-      /*top定位*/
-      style.top = `${top}px`;
+      /*横向定位*/
+      if (transform !== false) {
+        /*transform定位*/
+        style.transform = `translateX(${start}px)`;
+      } else {
+        /*top定位*/
+        style.left = `${start}px`;
+      }
     }
   });
 
@@ -156,23 +246,23 @@ export function useVirtualList(
      * @author  韦胜健
      * @date    2020/11/15 9:29
      */
-    getIndex: (top: number) => {
+    getIndex: (scrollValue: number) => {
       if (!props.dynamicSize) {
         // console.log('not dynamic》》》getIndex', top / props.size)
-        return Math.floor(top / props.size);
+        return Math.floor(scrollValue / props.size);
       } else {
-        const { nodes } = state;
+        const _nodes = nodes.value;
         let start = 0;
-        let end = nodes.length - 1;
+        let end = _nodes.length - 1;
         let temp = 0;
         while (start <= end) {
           let middle = Math.floor((start + end) / 2);
-          let middleBottom = nodes[middle].bottom;
-          if (middleBottom === top) {
+          let middleBottom = _nodes[middle].end;
+          if (middleBottom === scrollValue) {
             return middle + 1;
-          } else if (middleBottom < top) {
+          } else if (middleBottom < scrollValue) {
             start = middle + 1;
-          } else if (middleBottom > top) {
+          } else if (middleBottom > scrollValue) {
             if (!temp || temp > middle) {
               temp = middle;
             }
@@ -188,50 +278,75 @@ export function useVirtualList(
      * @author  韦胜健
      * @date    2020/12/14 22:44
      */
-    getPageIndex: (scrollTop: number, pageSize: number) => {
-      const data = props.data || [];
+    getPageIndex: (scrollValue: number) => {
+      if (scrollValue < 0) {
+        scrollValue = 0;
+      }
+      const pageSize = _pageSize.value;
+      const data = dataModel.value || [];
+      if (pageSize == null) {
+        return {
+          data,
+          startIndex: 0,
+          endIndex: 0,
+          pageIndex: 0,
+        };
+      }
       /*当前scrollTop对应的数据中数据的索引*/
-      let scrollIndex = utils.getIndex(scrollTop);
+      let scrollIndex = utils.getIndex(scrollValue);
       let pageIndex = Math.floor(scrollIndex / pageSize);
-      let start = pageIndex === 0 ? 0 : (pageIndex - 1) * pageSize;
-      let end = start + pageSize * 3;
+      let startIndex = (() => {
+        if (state.scrollDirection === 'none') {
+          return scrollIndex - Math.floor(pageSize * 0.5);
+        } else if (state.scrollDirection === ScrollDirection.start) {
+          /*这里多减去2，避免出现空白的间隙*/
+          return scrollIndex - (pageSize - 2);
+        } else {
+          return scrollIndex;
+        }
+      })();
+      let endIndex = startIndex + pageSize * 2;
+      startIndex -= 1;
+      endIndex += 1;
+      if (startIndex < 0) {
+        endIndex -= startIndex;
+        startIndex = 0;
+      }
       /*console.log({
-          scrollIndex,
-          pageIndex,
-          start,
-          end,
-      })*/
-      const exceed = end - data.length;
+        scrollIndex,
+        pageIndex,
+        start,
+        end,
+        pageSize,
+        scrollDirection: state.scrollDirection
+      });*/
+      const exceed = endIndex - data.length;
       if (exceed > 0) {
-        end = data.length;
-        start -= exceed;
-        if (start < 0) {
-          start = 0;
+        endIndex = data.length;
+        startIndex -= exceed;
+        if (startIndex < 0) {
+          startIndex = 0;
         }
       }
-      pageIndex = Math.floor(start / pageSize);
+      pageIndex = Math.floor(startIndex / pageSize);
       return {
         data,
-        start,
-        end,
+        startIndex,
+        endIndex,
         pageIndex,
       };
     },
-    /**
-     * 格式化props.data为 DataNode数组
-     * @author  韦胜健
-     * @date    2020/11/15 9:29
-     */
-    resetData: (data: any[]) => {
-      // console.log('resetData')
-      state.nodes = data.map((item, index) => ({
-        data: item,
-        index,
-        top: props.size * index,
-        height: props.size,
-        bottom: props.size * (index + 1),
-      }));
-    }
+    resetHostSize: () => {
+      const hostEl = refs.scroll?.refs.host;
+      if (!hostEl) {return;}
+      let hostSize = hostEl[props.horizontal ? 'offsetWidth' : 'offsetHeight'];
+      const headEl = hostEl.querySelector('[data-virtual-head]') as undefined | HTMLDivElement;
+      const footEl = hostEl.querySelector('[data-virtual-foot]') as undefined | HTMLDivElement;
+      if (!!headEl) {hostSize -= headEl[props.horizontal ? 'offsetWidth' : 'offsetHeight'];}
+      if (!!footEl) {hostSize -= footEl[props.horizontal ? 'offsetWidth' : 'offsetHeight'];}
+
+      if (state.hostSize != hostSize) {state.hostSize = hostSize;}
+    },
   };
 
   /*---------------------------------------handler-------------------------------------------*/
@@ -242,36 +357,38 @@ export function useVirtualList(
       if (props.disabled) {
         return;
       }
-      freezeState.scrollTop = (e.target as HTMLDivElement).scrollTop;
-      const current = utils.getPageIndex((e.target as HTMLDivElement).scrollTop, state.pageSize);
-      if (freezeState.current.pageIndex != current.pageIndex || freezeState.current.start != current.start) {
-        state.scrollTop = (e.target as HTMLDivElement).scrollTop;
-        freezeState.current = current;
-        emit.onPageIndexChange(current);
-      }
+      const newScrollValue = (e.target as HTMLDivElement)[props.horizontal ? 'scrollLeft' : 'scrollTop'];
+      state.scrollDirection = newScrollValue > freezeState.scrollValue ? ScrollDirection.end : ScrollDirection.start;
+      freezeState.scrollValue = newScrollValue;
+      const current = utils.getPageIndex((e.target as HTMLDivElement).scrollTop);
+      state.scrollValue = (e.target as HTMLDivElement)[props.horizontal ? 'scrollLeft' : 'scrollTop'];
+      freezeState.current = current;
+      emit.onPageIndexChange(current);
     }
   };
 
-  watch(() => props.data, (data: any[]) => {
+  watch(() => dataModel.value || [], (data: any[]) => {
+    delay().then(() => {
+      utils.resetHostSize();
+    });
     if (props.disabled) {
       return;
     }
     if (!props.dynamicSize) {
       return;
     }
-    !!refs.scroll && refs.scroll.methods.scrollTop(0, 0);
-    /*如果是动态高度，则刷state.nodes*/
-    utils.resetData(data);
+    // !!refs.scroll && refs.scroll.methods.scrollTop(0, 0);
   });
 
-  onMounted(() => {
-    const hostHeight = refs.scroll!.refs.host!.offsetHeight;
-    state.pageSize = Math.ceil(hostHeight / props.size);
-    if (props.dynamicSize && !props.disabled) {
-      utils.resetData(props.data);
-    }
+  onMounted(async () => {
+    await delay(23);
+    utils.resetHostSize();
   });
 
+  onBeforeUnmount(
+    addWindowListener('resize', () => delay(23).then(utils.resetHostSize))
+  );
+
   onUpdated(async () => {
     if (props.disabled) {
       return;
@@ -281,25 +398,17 @@ export function useVirtualList(
     }
     await delay();
     // console.log('dynamic scan height')
-    const elNodes = (Array.from(refs.content!.childNodes || []) as HTMLElement[]).filter(node => node.nodeType !== 3);
+    const elNodes = (refs.content?.querySelectorAll('[data-vid],[vid]') || []) as HTMLElement[];
+
     for (let i = 0; i < elNodes.length; i++) {
       const el = elNodes[i];
-      const { offsetHeight: height } = el;
+      const size = el[props.horizontal ? 'offsetWidth' : 'offsetHeight'];
       let vid = el.getAttribute('vid') || el.getAttribute('data-vid') as null | number | string;
       if (vid == null) {
         throw new Error('Each item of the virtual-list must have an attribute named "vid", please set :vid="index" or :data-vid="index"');
       }
-      vid = Number(vid);
-      const prevNode = state.nodes[vid];
-      const prevHeight = prevNode.height;
-      let deltaHeight = prevHeight - height;
-      if (deltaHeight !== 0) {
-        prevNode.height = height;
-        prevNode.bottom = prevNode.bottom - deltaHeight;
-        for (let j = vid + 1; j < state.nodes!.length; j++) {
-          state.nodes![j].top = state.nodes![j - 1].bottom;
-          state.nodes![j].bottom = state.nodes![j].bottom - deltaHeight;
-        }
+      if (state.id2size[vid] != size) {
+        state.id2size[vid] = size;
       }
     }
   });
@@ -311,6 +420,21 @@ export function useVirtualList(
       strutStyles,
       contentStyles,
       handler,
+
+      freezeState,
+      state,
+      nodes,
     }
   };
 }
+
+export type iVirtualList = ReturnType<typeof useVirtualList>['virtual']
+
+export interface iVirtualNode<T = PlainObject> {
+  id: string,
+  item: T,
+  size: number,
+  start: number,
+  end: number,
+  index: number
+}

package/src/packages/components/VirtualList/virtual-list.scss

@@ -1,34 +1,57 @@
-@include comp(virtual-table) {
-  @include comp(virtual-list) {
-    & > .scroll-wrapper {
-      & > .scroll-content {
-        overflow-y: unset;
-      }
-    }
-  }
-}
-
 @include comp(virtual-list) {
   position: relative;
 
-  & > .scroll-wrapper {
-    & > .scroll-content {
-      overflow-y: hidden;
-      min-width: 100%;
-    }
-  }
-
   &:not(.virtual-list-disabled) {
     .virtual-list-strut {
       position: relative;
       //overflow: hidden;
+    }
 
+    &:not(.virtual-list-horizontal) {
       .virtual-list-content {
         position: absolute;
         top: 0;
         left: 0;
         right: 0;
-        //overflow: hidden;
+      }
+    }
+    &.virtual-list-horizontal {
+      .virtual-list-content {
+        position: absolute;
+        top: 0;
+        bottom: 0;
+        left: 0;
+      }
+    }
+  }
+
+  &:not(.virtual-list-horizontal) {
+    & > .scroll-wrapper {
+      & > .scroll-content {
+        overflow-y: hidden;
+        min-width: 100%;
+      }
+    }
+  }
+
+  &.virtual-list-horizontal {
+    & > .scroll-wrapper {
+      & > .scroll-content {
+        overflow-x: hidden;
+        min-height: 100%;
+      }
+    }
+  }
+}
+
+
+@include comp(virtual-table) {
+  @include comp(virtual-list) {
+    &.virtual-list-horizontal, &:not(.virtual-list-horizontal) {
+      & > .scroll-wrapper {
+        & > .scroll-content {
+          overflow-y: unset;
+        }
       }
     }
   }