plain-design 1.0.0-beta.72 → 1.0.0-beta.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plain-design",
-  "version": "1.0.0-beta.72",
+  "version": "1.0.0-beta.73",
   "description": "",
   "main": "dist/plain-design.min.js",
   "module": "dist/plain-design.commonjs.min.js",

package/src/packages/components/VirtualList/createVirtualDraggier.ts

@@ -143,22 +143,25 @@ export function createVirtualDraggier(
 
   const getItemStyles = (index: number) => {
     const { dragIndex, initDragElementRect } = dragStaticState;
-    if (dragReactiveState.pointIndex == null || dragIndex == null || dragReactiveState.pointIndex == dragIndex || index == dragIndex) {
+    if (dragReactiveState.pointIndex == null || dragIndex == null) {
       return;
     }
+    const styles: StyleProperties = {};
+    styles.transition = 'transform ease 300ms';
     if (dragReactiveState.pointIndex >= index && index > dragIndex) {
-      return {
-        transform: props.horizontal ?
-          `translateX(-${initDragElementRect?.width || 0}px)` :
-          `translateY(-${initDragElementRect?.height || 0}px)`
-      };
+      styles.transform = props.horizontal ?
+        `translateX(-${initDragElementRect?.width || 0}px)` :
+        `translateY(-${initDragElementRect?.height || 0}px)`;
     } else if (dragReactiveState.pointIndex <= index && index < dragIndex) {
-      return {
-        transform: props.horizontal ?
-          `translateX(${initDragElementRect?.width || 0}px)` :
-          `translateY(${initDragElementRect?.height || 0}px)`
-      };
+      styles.transform = props.horizontal ?
+        `translateX(${initDragElementRect?.width || 0}px)` :
+        `translateY(${initDragElementRect?.height || 0}px)`;
+    } else {
+      styles.transform = props.horizontal ?
+        `translateX(0px)` :
+        `translateY(0px)`;
     }
+    return styles;
   };
 
   const draggier = createWebDraggier({
@@ -257,17 +260,19 @@ export function createVirtualDraggier(
           dragReactiveState.endingDefer.resolve();
         };
 
-        const newStart = (() => {
-          if (props.horizontal) {
-            return dragReactiveState.pointIndex < dragIndex ?
-              (getElementRect(strutElement).left + pointNode.start) + 'px' :
-              (getElementRect(strutElement).left + pointNode.end - initDragElementRect.width) + 'px';
-          } else {
-            return dragReactiveState.pointIndex < dragIndex ?
-              (getElementRect(strutElement).top + pointNode.start) + 'px' :
-              (getElementRect(strutElement).top + pointNode.end - initDragElementRect.height) + 'px';
-          }
-        })();
+        const newStart = Math.ceil(
+          (() => {
+            if (props.horizontal) {
+              return dragReactiveState.pointIndex < dragIndex ?
+                (getElementRect(strutElement).left + pointNode.start) :
+                (getElementRect(strutElement).left + pointNode.end - initDragElementRect.width);
+            } else {
+              return dragReactiveState.pointIndex < dragIndex ?
+                (getElementRect(strutElement).top + pointNode.start) :
+                (getElementRect(strutElement).top + pointNode.end - initDragElementRect.height);
+            }
+          })()
+        ) + 'px';
 
         const styleName = props.horizontal ? 'left' : 'top';
         if (dragElementShadow.style[styleName] == newStart) {
@@ -350,7 +355,7 @@ export function createVirtualDraggier(
   };
 }
 
-interface iDraggierStaticState {
+export interface iDraggierStaticState {
   /*拖拽节点在所有数据中的索引*/
   dragIndex: number;
   /*拖拽元素的节点的 data-vid 标识字符*/
@@ -369,14 +374,14 @@ interface iDraggierStaticState {
   strutElement: HTMLElement;
 }
 
-interface iDraggierReactiveState {
+export interface iDraggierReactiveState {
   pointIndex: number | null,
   onScroll: SimpleFunction,
   isDragging: boolean,
   endingDefer: DFD<void>,
 }
 
-function createDefaultDraggierReactiveState(): iDraggierReactiveState {
+export function createDefaultDraggierReactiveState(): iDraggierReactiveState {
   return {
     pointIndex: null,
     onScroll: doNothing,
@@ -385,7 +390,7 @@ function createDefaultDraggierReactiveState(): iDraggierReactiveState {
   };
 }
 
-function createDefaultDraggierStaticState(): iDraggierStaticState {
+export function createDefaultDraggierStaticState(): iDraggierStaticState {
   const fakeEle = null as any;
   return {
     dragIndex: -1,

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

@@ -64,7 +64,7 @@ export const VirtualList = designComponent({
       draggier.value?.emitScroll(e);
     }));
 
-    const { virtual } = useVirtualList({ dataModel, refs, props, emit, isDragging: () => !!(draggier.value?.dragReactiveState.isDragging) });
+    const { virtual } = useVirtualList({ dataModel, refs, props, emit });
 
     const onRefScroll = (scroll: typeof Scroll.use.class | null) => {
       onRef.scroll(scroll);

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

@@ -34,7 +34,6 @@ export function useVirtualList(
     refs,
     emit,
     transform,
-    isDragging
   }: {
     dataModel: { value: any[] | undefined | null },
     props: {
@@ -57,8 +56,6 @@ export function useVirtualList(
       onPageIndexChange: (data: { pageIndex: number, startIndex: number, endIndex: number }) => void,
     },
     transform?: boolean,
-    /*当前是否处于拖拽中的状态，是则会给组件根节点加上一个class，使得内部所有的data-vid元素启用transition动画*/
-    isDragging?: () => boolean,
   }
 ) {
 
@@ -83,7 +80,7 @@ export function useVirtualList(
   const idMap = new WeakMap<PlainObject, string>();
   let prevEnd = 0;
 
-  const nodes = computed(() => {
+  const nodes = computed((): iVirtualNode[] => {
     prevEnd = 0;
     return (dataModel.value || []).map((item, index): DataNode => {
       let id = idMap.get(item);
@@ -136,7 +133,6 @@ export function useVirtualList(
     {
       'virtual-list-disabled': props.disabled,
       'virtual-list-horizontal': props.horizontal,
-      'virtual-list-is-dragging': !!(isDragging?.()),
     },
   ]);
 
@@ -410,3 +406,12 @@ export function useVirtualList(
 }
 
 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

@@ -42,12 +42,6 @@
       }
     }
   }
-
-  &.virtual-list-is-dragging {
-    [data-vid] {
-      transition: all ease 300ms;
-    }
-  }
 }
 
 

package/src/packages/components/createScrollDraggier/index.ts

@@ -0,0 +1,374 @@
+import {getComponentCls, iMouseEvent, iTouchEvent, reactive, StyleProperties} from "plain-design-composition";
+import {doNothing} from "plain-utils/utils/doNothing";
+import {findParentElement} from "plain-utils/dom/findParentElement";
+import {hasClass} from "plain-utils/dom/hasClass";
+import {getElementRect} from "../../utils/getElementRect";
+import {createWebDraggier} from "../../utils/createDraggier";
+import {delay} from "plain-utils/utils/delay";
+import {PlainScroll} from "../Scroll";
+import {createDefaultDraggierReactiveState, createDefaultDraggierStaticState, iVirtualDraggierHandler} from "../VirtualList/createVirtualDraggier";
+import {iVirtualNode} from "../VirtualList/useVirtualList";
+
+/**
+ * 创建虚拟列表的拖拽移动节点管理对象
+ * @author  韦胜健
+ * @date    2024/5/29 14:55
+ */
+export function createScrollDraggier(
+  {
+    props,
+    getScroll,
+    dataModel,
+    getItemElements,
+    onDraggierStart,
+    onDraggierMove,
+    onDraggierEnd,
+    onDraggierTap,
+  }: {
+    props: { horizontal: boolean },
+    getScroll: () => PlainScroll | undefined,
+    dataModel: { value: any[] | undefined | null },
+    getItemElements: () => HTMLElement[],
+
+    onDraggierStart?: iVirtualDraggierHandler,
+    onDraggierMove?: iVirtualDraggierHandler,
+    onDraggierEnd?: iVirtualDraggierHandler,
+    onDraggierTap?: iVirtualDraggierHandler,
+  }
+) {
+
+  /*管理自动滚动*/
+  const autoScrollManager = (() => {
+    const _state = { value: null as null | 'top' | 'bottom' | 'left' | 'right' };
+
+    const handler = {
+      top: () => {
+        getScroll()?.methods.autoScrollTop();
+      },
+      bottom: () => {
+        getScroll()?.methods.autoScrollBottom();
+      },
+      left: () => {
+        getScroll()?.methods.autoScrollLeft();
+      },
+      right: () => {
+        getScroll()?.methods.autoScrollRight();
+      },
+      stop: () => {
+        getScroll()?.methods.stopAutoScroll();
+      },
+    };
+
+    const set = (val: null | 'top' | 'bottom' | 'left' | 'right') => {
+      const newVal = val;
+      const oldVal = _state.value;
+      if (newVal == oldVal) {
+        return;
+      }
+      _state.value = val;
+
+      if (!oldVal && !!newVal) {
+        handler[newVal]();
+      } else {
+        handler.stop();
+      }
+    };
+    const get = () => _state.value;
+    const stop = () => getScroll()?.methods.stopAutoScroll();
+    return { get, set, stop };
+  })();
+
+  /*静态变量*/
+  const dragStaticState = {
+    ...createDefaultDraggierStaticState(),
+    nodes: [] as iVirtualNode[],
+  };
+
+  /*响应式变量*/
+  const dragReactiveState = reactive(createDefaultDraggierReactiveState());
+
+  const start = (e: iMouseEvent | iTouchEvent, startIndex: number) => {
+
+    const itemElements = getItemElements();
+
+    dragStaticState.nodes = (() => {
+      let tempStart = 0;
+      return itemElements.map((item, index) => {
+        const start = tempStart;
+        const size = item[props.horizontal ? 'offsetWidth' : 'offsetHeight'];
+        const end = start + size;
+        tempStart += size;
+        return {
+          id: String(index),
+          size,
+          start,
+          end,
+          index,
+          item: dataModel.value?.[index],
+        };
+      });
+    })();
+
+    /*重置静态变量*/
+    Object.assign(dragReactiveState, createDefaultDraggierReactiveState());
+    /*重置响应式变量*/
+    Object.assign(dragReactiveState, createDefaultDraggierStaticState());
+
+    /*初始化部分静态变量*/
+    dragStaticState.dragElement = itemElements[startIndex];
+    if (!dragStaticState.dragElement) {
+      throw new Error(`Can't find [data-vid] elements!`);
+    }
+
+    dragStaticState.hostElement = findParentElement(dragStaticState.dragElement, el => hasClass(el, getComponentCls('scroll')))!;
+    if (!dragStaticState.hostElement) {
+      throw new Error(`Can't find host elements`);
+    }
+    dragStaticState.strutElement = findParentElement(dragStaticState.dragElement, el => hasClass(el, 'scroll-content'))!;
+    if (!dragStaticState.strutElement) {
+      throw new Error(`Can't find strut elements`);
+    }
+
+    dragStaticState.initDragElementRect = getElementRect(dragStaticState.dragElement);
+    dragStaticState.dragIndex = startIndex;
+    if (dragStaticState.dragIndex == -1) {
+      throw new Error(`Can't find index of drag elements`);
+    }
+
+    draggier.start(e);
+  };
+
+  const update = () => {
+
+    const { strutElement } = dragStaticState;
+
+    const offsetStart = props.horizontal ?
+      draggier.staticState.moveX - getElementRect(strutElement!).left :
+      draggier.staticState.moveY - getElementRect(strutElement!).top;
+
+    const newPointIndex = dragStaticState.nodes.findIndex(node => node.start <= offsetStart && node.end > offsetStart);
+
+    /*值有效的时候才更新值，新值无效的话，就用老的值，因为如果超出边界的话就会得到无效的新值，此时用老值即可*/
+    if (newPointIndex != null && newPointIndex != -1) {
+      dragReactiveState.pointIndex = newPointIndex || 0;
+    }
+  };
+
+  const getItemStyles = (index: number) => {
+    const { dragIndex, initDragElementRect } = dragStaticState;
+    if (dragReactiveState.pointIndex == null || dragIndex == null) {
+      return;
+    }
+    const styles: StyleProperties = {};
+    styles.transition = 'transform ease 300ms';
+    if (dragReactiveState.pointIndex >= index && index > dragIndex) {
+      styles.transform = props.horizontal ?
+        `translateX(-${initDragElementRect?.width || 0}px)` :
+        `translateY(-${initDragElementRect?.height || 0}px)`;
+    } else if (dragReactiveState.pointIndex <= index && index < dragIndex) {
+      styles.transform = props.horizontal ?
+        `translateX(${initDragElementRect?.width || 0}px)` :
+        `translateY(${initDragElementRect?.height || 0}px)`;
+    } else {
+      styles.transform = props.horizontal ?
+        `translateX(0px)` :
+        `translateY(0px)`;
+    }
+    return styles;
+  };
+
+  const draggier = createWebDraggier({
+    horizontal: props.horizontal,
+    vertical: !props.horizontal,
+    onInit: () => {
+    },
+    onStart: (draggierData) => {
+
+      const { draggierEffects } = draggierData;
+
+      const { dragElement, initDragElementRect, hostElement } = dragStaticState;
+
+      if (!dragElement || !initDragElementRect || !hostElement) {
+        return;
+      }
+
+      const dragElementShadow = dragStaticState.dragElementShadow = dragElement.cloneNode(true) as any;
+
+      if (!dragElementShadow) {
+        return;
+      }
+
+      /*强制启用动画，避免被Scroll禁用*/
+      dragElementShadow.setAttribute('data-force-transition', 'true');
+      dragElementShadow.style.height = initDragElementRect.height + 'px';
+      dragElementShadow.style.width = initDragElementRect.width + 'px';
+      dragElementShadow.style.position = 'fixed';
+      dragElementShadow.style.top = initDragElementRect.top + 'px';
+      dragElementShadow.style.left = initDragElementRect.left + 'px';
+      dragElementShadow.style.pointerEvents = 'none';
+      dragElementShadow.style.transition = 'none';
+
+      /*添加克隆节点*/
+      hostElement.appendChild(dragElementShadow);
+      draggierEffects.push(async () => {
+        if (!dragElementShadow || !hostElement) {
+          return;
+        }
+        await dragReactiveState.endingDefer.promise;
+        await delay(23);
+        hostElement.removeChild(dragElementShadow);
+        dragStaticState.dragElementShadow = null as any;
+      });
+
+      /*隐藏原始对象*/
+      dragStaticState.oldDragElementStyles.opacity = dragElement.style.opacity;
+      dragElement.style.opacity = "0";
+      draggierEffects.push(async () => {
+        if (!dragElement) {
+          return;
+        }
+        await dragReactiveState.endingDefer.promise;
+        await delay(23);
+        dragElement.style.opacity = dragStaticState.oldDragElementStyles.opacity;
+        dragStaticState.dragElement = null as any;
+      });
+
+      /*监听滚动*/
+      dragReactiveState.onScroll = (e: Event) => {
+        update();
+      };
+      const ejectOnScroll = getScroll()!.on.onScroll(dragReactiveState.onScroll);
+      draggierEffects.push(() => {
+        ejectOnScroll();
+        dragReactiveState.onScroll = doNothing;
+      });
+
+      /*拖拽结束的时候停止自动滚动*/
+      draggierEffects.push(() => getScroll()?.methods.stopAutoScroll());
+      draggierEffects.push(async () => {
+        await dragReactiveState.endingDefer.promise;
+        dragReactiveState.pointIndex = null;
+      });
+
+      /*标记拖拽中响应式变量*/
+      dragReactiveState.isDragging = true;
+      draggierEffects.push(async () => {
+        await dragReactiveState.endingDefer.promise;
+        dragReactiveState.isDragging = false;
+      });
+
+      /*操作结束之后的更新数据动作*/
+      draggierEffects.push(async () => {
+        const { strutElement, dragIndex } = dragStaticState;
+        if (!initDragElementRect || dragReactiveState.pointIndex == null || !dragElementShadow || !strutElement || dragIndex == null) {
+          return;
+        }
+        // console.log('==>>', dragReactiveState.pointIndex);
+        const pointNode = dragStaticState.nodes[dragReactiveState.pointIndex];
+        // console.log(pointNode, dragElementShadow);
+        const afterTransition = () => {
+          if (dragReactiveState && dragReactiveState.pointIndex != null && dragIndex != null && dragReactiveState.pointIndex != dragIndex) {
+            const insertIndex = dragReactiveState.pointIndex;
+            const newList = [...dataModel.value || []];
+            const spliceArr = newList.splice(dragIndex, 1);
+            newList.splice(insertIndex, 0, ...spliceArr);
+            dataModel.value = (newList);
+          }
+          dragReactiveState.endingDefer.resolve();
+        };
+
+        const newStart = Math.ceil((() => {
+          if (props.horizontal) {
+            return dragReactiveState.pointIndex < dragIndex ?
+              (getElementRect(strutElement).left + pointNode.start) :
+              (getElementRect(strutElement).left + pointNode.end - initDragElementRect.width);
+          } else {
+            return dragReactiveState.pointIndex < dragIndex ?
+              (getElementRect(strutElement).top + pointNode.start) :
+              (getElementRect(strutElement).top + pointNode.end - initDragElementRect.height);
+          }
+        })()) + 'px';
+
+        const styleName = props.horizontal ? 'left' : 'top';
+
+        // console.log(newStart, dragElementShadow.style[styleName]);
+
+        if (dragElementShadow.style[styleName] == newStart) {
+          /*位置没有变化，直接更新数据，因为值没有变化，导致就算复制也不会触发transition动画*/
+          afterTransition();
+        } else {
+          /*位置有变化，等transition动画结束之后再更新数据*/
+          dragElementShadow.style.transition = 'all ease 300ms';
+          dragElementShadow.addEventListener('transitionend', async () => {
+            afterTransition();
+          });
+        }
+        dragElementShadow.style[styleName] = newStart;
+      });
+
+      onDraggierStart?.({ ...draggierData, dragStaticState, dragReactiveState });
+    },
+    onMove: (draggierData) => {
+
+      const { staticState } = draggierData;
+
+      const { dragElementShadow, initDragElementRect, hostElement, strutElement } = dragStaticState;
+
+      if (!dragElementShadow || !initDragElementRect || !hostElement || !strutElement) {
+        return;
+      }
+
+      const strutRect = getElementRect(strutElement);
+      const hostRect = getElementRect(hostElement);
+
+      const newStart = props.horizontal ?
+        initDragElementRect.left + staticState.durX :
+        initDragElementRect.top + staticState.durY;
+      const minStart = props.horizontal ?
+        getElementRect(hostElement).left :
+        getElementRect(hostElement).top;
+      const maxStart1 = props.horizontal ?
+        strutRect.left + strutRect.width - initDragElementRect.width :
+        strutRect.top + strutRect.height - initDragElementRect.height;
+      const maxStart2 = props.horizontal ?
+        hostRect.left + hostRect.width - initDragElementRect.width :
+        hostRect.top + hostRect.height - initDragElementRect.height;
+      const maxStart = Math.min(maxStart1, maxStart2);
+
+      const resultStart = Math.max(minStart, Math.min(maxStart, newStart));
+
+      if (resultStart == minStart) {
+        autoScrollManager.set(props.horizontal ? 'left' : 'top');
+      } else if (resultStart == maxStart) {
+        autoScrollManager.set(props.horizontal ? 'right' : 'bottom');
+      } else {
+        autoScrollManager.set(null);
+      }
+
+      const styleName = props.horizontal ? 'left' : 'top';
+      dragElementShadow.style[styleName] = resultStart + 'px';
+
+      update();
+
+      onDraggierMove?.({ ...draggierData, dragStaticState, dragReactiveState });
+    },
+    onEnd: (draggierData) => {
+      onDraggierEnd?.({ ...draggierData, dragStaticState, dragReactiveState });
+    },
+    onTap: (draggierData) => {
+      onDraggierTap?.({ ...draggierData, dragStaticState, dragReactiveState });
+    },
+  });
+
+  const emitScroll = (e: any) => {
+    dragReactiveState.onScroll(e);
+  };
+
+  return {
+    dragStaticState,
+    dragReactiveState,
+    start,
+    getItemStyles,
+    emitScroll,
+  };
+}

package/src/packages/entry.tsx

@@ -222,6 +222,7 @@ export {createRequestInterceptor} from './components/createRequestInterceptor';
 export type{iRequestInterceptor} from './components/createRequestInterceptor';
 export {createVirtualDraggier} from './components/createVirtualDraggier';
 export {createWebDraggier} from './components/createWebDraggier';
+export {createScrollDraggier} from './components/createScrollDraggier';
 
 // @ts-ignore
 setComponentPrefix(globalComponentPrefix);