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

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

@@ -0,0 +1,66 @@
+import {delay, designComponent, onBeforeUnmount, onMounted, reactive, watch} from "plain-design-composition";
+import {createEffects} from "plain-utils/utils/createEffects";
+
+export const RollingNumber = designComponent({
+  name: 'rolling-number',
+  props: {
+    val: { type: Number }
+  },
+  setup({ props }) {
+
+    const state = reactive({ val: 0 });
+
+    const utils = {
+      update: (space = 1) => {
+        // console.log('update');
+        space = Math.abs(space);
+        const val = state.val;
+        if (props.val == null) {
+          state.val = 0;
+          return;
+        }
+        if (val == props.val) {
+          return;
+        }
+        if (val > props.val) {
+          state.val = Math.max(val - space, props.val);
+          delay(20).then(() => utils.update(space));
+        } else {
+          state.val = Math.min(val + space, props.val);
+          delay(20).then(() => utils.update(space));
+        }
+      },
+      format: (num: number) => {
+        const [prepend, append] = String(num).split('.');
+        const list = String(prepend).split('').reverse();
+        const lastIndex = list.length - 1;
+        return list.reduce((prev, item, index) => {
+          return (lastIndex != index && (index + 1) % 3 == 0 ? ',' : '') + item + prev;
+        }, '') + (!append ? '' : `.${append}`);
+      },
+    };
+
+    const { effects } = createEffects();
+
+    onMounted(() => {
+      effects.push(
+        watch(() => props.val, () => {
+          const curVal = state.val || 0;
+          const newVal = props.val == null ? 0 : props.val;
+          const space = Math.ceil((newVal - curVal) / 50);
+          utils.update(space);
+        }, { immediate: true })
+      );
+    });
+
+    onBeforeUnmount(effects.clear);
+
+    return () => (
+      props.val != null && (
+        <span>{utils.format(state.val)}</span>
+      )
+    );
+  },
+});
+
+export default RollingNumber;

package/src/packages/components/Scroll/HorizontalScrollbar.tsx

@@ -5,6 +5,7 @@ import {enableUserSelect} from "plain-utils/dom/enableUserSelect";
 import {Scroll} from "./index";
 import {delay} from "plain-utils/utils/delay";
 import Tooltip from "../Tooltip";
+import {ClientZoom} from "../ClientZoom";
 
 export const HorizontalScrollbar = designComponent({
   props: {
@@ -41,15 +42,17 @@ export const HorizontalScrollbar = designComponent({
         state.scrollLeft = (e.target as HTMLElement).scrollLeft;
       },
       onMousedown: (e: iMouseEvent) => {
+        const { clientX } = ClientZoom.getClientPosition(e);
         scroll.freezeState.isDragging = true;
         dragState.left = left.value;
-        dragState.clientX = e.clientX;
+        dragState.clientX = clientX;
         document.addEventListener('mousemove', handler.onMousemove);
         document.addEventListener('mouseup', handler.onMouseup);
         disabledUserSelect();
       },
       onMousemove: (e: MouseEvent) => {
-        let deltaX = e.clientX - dragState.clientX;
+        const { clientX } = ClientZoom.getClientPosition(e);
+        let deltaX = clientX - dragState.clientX;
         const left = dragState.left + deltaX;
         let scrollLeft = left * (scroll.state.contentWidth - scroll.state.hostWidth) / (scroll.state.hostWidth - width.value);
         scrollLeft = Math.max(0, Math.min(scrollLeft, scroll.state.contentWidth - scroll.state.hostWidth));
@@ -66,7 +69,8 @@ export const HorizontalScrollbar = designComponent({
         enableUserSelect();
 
         if (scroll.props.scrollAfterDragEnd) {
-          let deltaX = e.clientX - dragState.clientX;
+          const { clientX } = ClientZoom.getClientPosition(e);
+          let deltaX = clientX - dragState.clientX;
           const left = dragState.left + deltaX;
           scroll.refs.wrapper!.scrollLeft = left * (scroll.state.contentWidth - scroll.state.hostWidth) / (scroll.state.hostWidth - width.value);
         }

package/src/packages/components/Scroll/VerticalScrollbar.tsx

@@ -5,6 +5,7 @@ import {enableUserSelect} from "plain-utils/dom/enableUserSelect";
 import {Scroll} from "./index";
 import {delay} from "plain-utils/utils/delay";
 import Tooltip from "../Tooltip";
+import {ClientZoom} from "../ClientZoom";
 
 export const VerticalScrollbar = designComponent({
   props: {
@@ -46,15 +47,17 @@ export const VerticalScrollbar = designComponent({
         state.scrollTop = (e.target as HTMLElement).scrollTop;
       },
       onMousedown: (e: iMouseEvent) => {
+        const { clientY } = ClientZoom.getClientPosition(e);
         scroll.freezeState.isDragging = true;
         dragState.top = top.value;
-        dragState.clientY = e.clientY;
+        dragState.clientY = clientY;
         document.addEventListener('mousemove', handler.onMousemove);
         document.addEventListener('mouseup', handler.onMouseup);
         disabledUserSelect();
       },
       onMousemove: (e: MouseEvent) => {
-        let deltaY = e.clientY - dragState.clientY;
+        const { clientY } = ClientZoom.getClientPosition(e);
+        let deltaY = clientY - dragState.clientY;
         let top = dragState.top + deltaY;
         let scrollTop = top * (scroll.state.contentHeight - scroll.state.hostHeight) / (scroll.state.hostHeight - height.value);
         scrollTop = Math.max(0, Math.min(scrollTop, scroll.state.contentHeight - scroll.state.hostHeight));
@@ -72,7 +75,8 @@ export const VerticalScrollbar = designComponent({
         enableUserSelect();
 
         if (scroll.props.scrollAfterDragEnd) {
-          let deltaY = e.clientY - dragState.clientY;
+          const { clientY } = ClientZoom.getClientPosition(e);
+          let deltaY = clientY - dragState.clientY;
           let top = dragState.top + deltaY;
           scroll.refs.wrapper!.scrollTop = top * (scroll.state.contentHeight - scroll.state.hostHeight) / (scroll.state.hostHeight - height.value);
         }

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

@@ -8,6 +8,7 @@ import {VerticalScrollbar} from "./VerticalScrollbar";
 import {HorizontalScrollbar} from "./HorizontalScrollbar";
 import {ResizeDetectFuncParam, useResizeDetector} from "../../directives/ResizeDetector";
 import {createScrollUtils} from "../createScrollUtils";
+import {getRectAutoFormat} from "plain-utils/dom/getRectAutoFormat";
 
 export enum PLAIN_SCROLL_VERTICAL_POSITION {
   top = 'top',
@@ -34,9 +35,13 @@ export const Scroll = designComponent({
     autoScrollSpeed: { type: Number, default: 400 },                                                  // 自动滚动的时候的速度，每秒钟滚动的距离
     scrollAfterDragEnd: { type: Boolean, },                                                           // 是否拖拽结束后才刷新滚动位置
     disableListTransition: { type: Boolean, },                                                        // 是否股弄懂的时候禁用list的队列动画
-    disableTransitionWhenScroll: { type: Boolean },                                                     // 是否在滚动的时候禁用内部所有元素的transition动画
+    disableTransitionWhenScroll: { type: Boolean },                                                   // 是否在滚动的时候禁用内部所有元素的transition动画
     horizontalScrollbarTooltip: { type: String },                                                     // 横向滚动条tooltip显示文本
     verticalScrollbarTooltip: { type: String },                                                       // 纵向滚动条tooltip显示文本
+    mutationSubtree: { type: Boolean, default: true },                                                // 监听整个子树的节点变化
+    mutationChildList: { type: Boolean, default: true },                                              // 监听整个子树的节点新增与删除
+    mutationAttributes: { type: Boolean, default: false },                                            // 监听整个子树节点的属性变化
+
   },
   emits: {
     onScroll: (e: Event) => true,
@@ -78,9 +83,9 @@ export const Scroll = designComponent({
       set isDragging(val: boolean) {
         this._isDragging = val;
         if (val) {
-          refs.host!.setAttribute('is-dragging', '');
+          refs.host?.setAttribute('is-dragging', '');
         } else {
-          refs.host!.removeAttribute('is-dragging');
+          refs.host?.removeAttribute('is-dragging');
         }
       },
     };
@@ -209,15 +214,48 @@ export const Scroll = designComponent({
       autoScrollLeft() {scrollUtils.autoScrollLeft();},
       autoScrollRight() {scrollUtils.autoScrollRight();},
       stopAutoScroll() {scrollUtils.stopAutoScroll();},
+      showElement: (elementSelector: string | HTMLElement): boolean => {
+        if (!refs.host || !refs.content) {return false;}
+        const selectElement = typeof elementSelector === "string" ? refs.content?.querySelector(elementSelector) : elementSelector;
+
+        if (selectElement == null) {return false;}
+        const selectElementRect = getRectAutoFormat(selectElement as any);
+        const contentElementRect = getRectAutoFormat(refs.content);
+        const hostElementRect = getRectAutoFormat(refs.host);
+
+        /*vertical*/
+        if (selectElementRect.bottom >= hostElementRect.bottom) {
+          /*在下面*/
+          const offsetTop = selectElementRect.top - contentElementRect.top;
+          methods.scrollTop(offsetTop - (hostElementRect.height - selectElementRect.height));
+        } else if (selectElementRect.top <= hostElementRect.top) {
+          /*在上面*/
+          const offsetTop = selectElementRect.top - contentElementRect.top;
+          methods.scrollTop(offsetTop);
+        }
+
+        /*horizontal*/
+        if (selectElementRect.right >= hostElementRect.right) {
+          /*在右边*/
+          const offsetLeft = selectElementRect.left - contentElementRect.left;
+          methods.scrollLeft(offsetLeft - (hostElementRect.width - selectElementRect.width));
+        } else if (selectElementRect.left <= hostElementRect.left) {
+          /*在左边*/
+          const offsetLeft = selectElementRect.left - contentElementRect.left;
+          methods.scrollLeft(offsetLeft);
+        }
+
+        return true;
+      },
       /**
        * 禁用list的队列动画，300ms后恢复正常
        * @author  韦胜健
        * @date    2020/12/15 10:16
        */
       disableListTransition: (() => {
-        const disabledQueueAnimation = debounce(() => refs.host!.removeAttribute('virtual-scrolling'), 300, true);
+        const disabledQueueAnimation = debounce(() => refs.host?.removeAttribute('virtual-scrolling'), 300, true);
         return () => {
-          refs.host!.setAttribute('virtual-scrolling', '');
+          refs.host?.setAttribute('virtual-scrolling', '');
           disabledQueueAnimation();
         };
       })(),
@@ -227,9 +265,9 @@ export const Scroll = designComponent({
        * @date    2022.10.28 21:34
        */
       disableInnerTransition: (() => {
-        const disabledQueueAnimation = debounce(() => refs.host!.removeAttribute('disable-all-transition'), 300, true);
+        const disabledQueueAnimation = debounce(() => refs.host?.removeAttribute('disable-all-transition'), 300, true);
         return () => {
-          refs.host!.setAttribute('disable-all-transition', '');
+          refs.host?.setAttribute('disable-all-transition', '');
           disabledQueueAnimation();
         };
       })()
@@ -320,8 +358,8 @@ export const Scroll = designComponent({
 
     watch(() => props.refreshState, methods.refresh);
 
-    useResizeDetector({ elGetter: () => refs.host, onResize: handler.hostResize });
-    useResizeDetector({ elGetter: () => refs.content, onResize: handler.contentResize });
+    useResizeDetector({ elGetter: () => refs.host, onResize: handler.hostResize, mutateOption: { childList: props.mutationChildList, subtree: props.mutationSubtree, attributes: props.mutationAttributes } });
+    useResizeDetector({ elGetter: () => refs.content, onResize: handler.contentResize, mutateOption: { childList: props.mutationChildList, subtree: props.mutationSubtree, attributes: props.mutationAttributes }, });
 
     return {
       refer: {

package/src/packages/components/Scroll/scroll.scss

@@ -110,8 +110,10 @@
     }
   }
   &[disable-all-transition] {
-    *, *:before, *:after {
-      transition: none !important;
+    *:not([data-force-transition=true]) {
+      &, &:before, &:after {
+        transition: none !important;
+      }
     }
   }
 

package/src/packages/components/Select/SelectPanel.tsx

@@ -5,6 +5,7 @@ import {Loading} from "../Loading";
 import Empty from "../Empty";
 import {ApplicationConfigurationProvider} from "../Application/utils/application.utils";
 import i18n from "../i18n";
+import {useSearchText} from "../SelectGroup";
 
 export const SelectPanel = designComponent({
   name: 'select-panel',
@@ -27,6 +28,8 @@ export const SelectPanel = designComponent({
 
     const applicationConfiguration = ApplicationConfigurationProvider.inject();
 
+    useSearchText.provide(() => props.searchText);
+
     const handler = {
       onClickOption: (selectOptionProps: any, e: MouseEvent,) => {emit.onSelect(selectOptionProps, e);},
       onEnterOption: emit.onEnterOption,
@@ -43,7 +46,7 @@ export const SelectPanel = designComponent({
           content = slots.loadingContent(
             <div className="select-panel-loading">
               <Loading type="delta"/>
-              <span>{i18n('base.loading').d('加载中')}</span>
+              <span>{i18n.$it('base.loading').d('加载中')}</span>
             </div>
           );
         } else if (props.dataLength === 0) {

package/src/packages/components/Select/createMultipleSelectRender.tsx

@@ -83,11 +83,11 @@ export function createMultipleSelectRender(params: iSelectCompositionParams) {
         <>
           {editComputed.value.editable && (
             <div className="select-panel-header">
-              {/*<Button onClick={handler.handleCheckAll} size="mini">{i18n('base.select.all').d('全选')}</Button>
-              <Button onClick={handler.handleUncheckALl} size="mini">{i18n('base.clear').d('清空')}</Button>
-              <Button onClick={handler.handleCheckReverse} size="mini">{i18n('base.select.reverse').d('反选')}</Button>*/}
+              {/*<Button onClick={handler.handleCheckAll} size="mini">{i18n.$it('base.select.all').d('全选')}</Button>
+              <Button onClick={handler.handleUncheckALl} size="mini">{i18n.$it('base.clear').d('清空')}</Button>
+              <Button onClick={handler.handleCheckReverse} size="mini">{i18n.$it('base.select.reverse').d('反选')}</Button>*/}
               <Checkbox checkStatus={checkStatus} customReadonly label={
-                checkStatus !== CheckboxStatus.check ? i18n('base.select.all').d('全选') : i18n('base.clear').d('清空')
+                checkStatus !== CheckboxStatus.check ? i18n.$it('base.select.all').d('全选') : i18n.$it('base.clear').d('清空')
               } onClick={() => {
                 checkStatus !== CheckboxStatus.check ? handler.handleCheckAll() : handler.handleUncheckALl();
               }}/>

package/src/packages/components/Select/createPublicSelectRender.tsx

@@ -236,7 +236,7 @@ export function createPublicSelectRender(
                   const { virtualRowSize } = props;
                   return virtualRowSize == null ? SelectDefaultVirtualRowSize[styleComputed.value.size] : virtualRowSize;
                 })()}>
-                  {{ default: ({ item, index }: { item: iSelectOptionProps, index: number }) => <SelectOption {...item} index={index} key={index}/> }}
+                  {{ default: ({ item, index, vIndex }: { item: iSelectOptionProps, index: number, vIndex: number }) => <SelectOption {...item} index={index} key={vIndex}/> }}
                 </VirtualList>
               </div>) : (
                 matchOptionPropsList.map((i, index) => (<SelectOption {...i} index={index}/>))

package/src/packages/components/Select/select.utils.tsx

@@ -151,7 +151,7 @@ export const SelectUtils = {
     if (!!props.isMatchSearch) {
       return props.isMatchSearch(searchText, optionProps);
     }
-    return !!optionProps.label && optionProps.label.indexOf(searchText) > -1;
+    return !!optionProps.label && optionProps.label.toLowerCase().indexOf(searchText.toLowerCase()) > -1;
   },
 };
 

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

@@ -1,6 +1,6 @@
 import {designComponent} from "plain-design-composition";
 import {createSelectOptionDecoder} from "../Select/createSelectOptionDecoder";
-import {pick} from "../../utils/pick";
+import {pick} from "plain-utils/object/pick";
 import {EditProps} from "../../uses/useEdit";
 import {useMultipleModel} from "../../uses/useMultipleModel";
 import {toArray} from "plain-utils/utils/toArray";

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

@@ -0,0 +1,37 @@
+import {designComponent, inject, provide} from "plain-design-composition";
+import DropdownGroup from "../DropdownGroup";
+
+export const SelectGroup = designComponent({
+  name: 'select-group',
+  props: {
+    title: { type: String },
+  },
+  slots: ['default'],
+  setup({ props, slots }) {
+
+    const searchText = useSearchText.inject();
+
+    return () => {
+      return (
+        /*有搜索关键词的时候不显示分组标题*/
+        !searchText?.()?.length && (
+          <DropdownGroup>
+            {slots.default(props.title)}
+          </DropdownGroup>
+        )
+      );
+    };
+  },
+});
+
+export const useSearchText = (() => {
+  const PROVIDE_NAME = '@@SEARCH_TEXT_PROVIDER';
+  return {
+    provide: (getSearchText: () => string | null | undefined) => {
+      provide(PROVIDE_NAME, getSearchText);
+    },
+    inject: () => {
+      return inject(PROVIDE_NAME) as (() => string | null | undefined) | undefined | null;
+    },
+  };
+})();

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

@@ -7,7 +7,7 @@ import {createSliderHooks, createSliderUtils, iSliderPublicParams, SliderEmitsOp
 import {useWatchAutoClear} from "../../utils/watchEffectAutoClear";
 import {useSliderRange} from "./useSlider.range";
 import {useSliderSingle} from "./useSlider.single";
-import {doNothing} from "../../utils/doNothing";
+import {doNothing} from "plain-utils/utils/doNothing";
 
 export const Slider = designComponent({
   name: 'slider',

package/src/packages/components/Slider/slider.scss

@@ -47,7 +47,7 @@
         transition: all 300ms ease;
         opacity: 0;
         background-color: rgba(black, 0.8);
-        color: white;
+        color: #ffffff;
         padding: 3px 6px;
         line-height: initial;
         position: absolute;

package/src/packages/components/Slider/useSliderDotDragier.tsx

@@ -3,6 +3,7 @@ import {disabledUserSelect} from "plain-utils/dom/disabledUserSelect";
 import {enableUserSelect} from "plain-utils/dom/enableUserSelect";
 import {iMouseEvent, reactive} from "plain-design-composition";
 import {iSliderHooks} from "./slider.utils";
+import {ClientZoom} from "../ClientZoom";
 
 export function useSliderDotDraggier<InitialState>(
   hooks: iSliderHooks,
@@ -24,10 +25,11 @@ export function useSliderDotDraggier<InitialState>(
 
   const handler = {
     onMousedown: (e: iMouseEvent) => {
+      const { clientX, clientY } = ClientZoom.getClientPosition(e);
       staticState = {
         start: {
-          x: e.clientX,
-          y: e.clientY,
+          x: clientX,
+          y: clientY,
         },
         state: getInitialState(),
       };
@@ -46,8 +48,9 @@ export function useSliderDotDraggier<InitialState>(
     },
     onMousemove: (e: MouseEvent) => {
       if (!staticState) {return;}
-      const durX = e.clientX - staticState.start.x;
-      const durY = e.clientY - staticState.start.y;
+      const { clientX, clientY } = ClientZoom.getClientPosition(e);
+      const durX = clientX - staticState.start.x;
+      const durY = clientY - staticState.start.y;
       handleDraggier({
         durX,
         durY,

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

@@ -0,0 +1,191 @@
+import {computed, CSSProperties, designComponent, getComponentCls, iHTMLDivElement, iMouseEvent, PropType, reactive, useClasses, useModel, useRefs} from "plain-design-composition";
+import './sort-list.scss';
+import {createEffects} from "plain-utils/utils/createEffects";
+import {addWindowListener} from "plain-utils/dom/addWindowListener";
+import {getRectAutoFormat} from "plain-utils/dom/getRectAutoFormat";
+import {iElementRect} from "../../utils/getRowEl";
+
+export const SortList = designComponent({
+  name: 'sort-list',
+  props: {
+    modelValue: { type: Array as PropType<any[]> },
+    col: { type: Number, default: 1 },
+    space: { type: Number, default: 0 },
+  },
+  emits: {
+    onUpdateModelValue: (val: any[]) => true,
+    onDragStart: (data: { item: any, index: number, e: iMouseEvent }) => true,
+  },
+  scopeSlots: {
+    default: (data: { item: any, index: number }) => true,
+  },
+  setup({ props, scopeSlots, event: { emit } }) {
+
+    const { refs, onRef } = useRefs({ el: iHTMLDivElement });
+
+    const model = useModel(() => props.modelValue || [], emit.onUpdateModelValue);
+
+    const isHorizontal = computed(() => props.col > 1);
+
+    const classes = useClasses(() => [
+      getComponentCls('sort-list'),
+    ]);
+
+    const draggier = (() => {
+
+      const draggierState = reactive({
+        isDragging: false,
+      });
+
+      const mousedown = (e: iMouseEvent, item: any, index: number) => {
+        emit.onDragStart({ item, index, e });
+
+        const { effects: draggierEffects } = createEffects();
+        const staticState = {
+          start: {
+            x: e.clientX,
+            y: e.clientY,
+            left: 0,
+            top: 0,
+          },
+          siblingRects: (() => {
+            const sortItemElements = Array.from(refs.el!.querySelectorAll('.sort-item')) as HTMLElement[];
+            return sortItemElements.map((el, index) => {
+              return {
+                index,
+                rects: getRectAutoFormat(el)
+              };
+            });
+          })(),
+          dropData: null as null | {
+            itemRect: { index: number, rects: Omit<iElementRect, 'right' | 'bottom'> },
+            pos: 'prev' | 'next'
+          }
+        };
+        const sourceElement = (e.currentTarget as HTMLElement);
+        const sourceRect = getRectAutoFormat(sourceElement);
+        staticState.start.left = sourceRect.left;
+        staticState.start.top = sourceRect.top;
+        let shadowElement: HTMLElement | null = null;
+        let indicator: HTMLDivElement | null = null;
+        const indicatorSize = 2;
+
+        draggierEffects.push(addWindowListener('mouseup', draggierEffects.clear));
+        draggierEffects.push(addWindowListener('mousemove', (e) => {
+          const durX = e.clientX - staticState.start.x;
+          const durY = e.clientY - staticState.start.y;
+
+          if (!draggierState.isDragging) {
+            if (Math.abs(durX) > 5 || Math.abs(durY) > 5) {
+              draggierState.isDragging = true;
+              draggierEffects.push(() => {draggierState.isDragging = false;});
+
+              shadowElement = sourceElement.cloneNode(true) as HTMLElement;
+              shadowElement.style.boxSizing = 'border-box';
+              shadowElement.style.position = 'fixed';
+              shadowElement.style.top = sourceRect.top + 'px';
+              shadowElement.style.left = sourceRect.left + 'px';
+              shadowElement.style.height = sourceRect.height + 'px';
+              shadowElement.style.width = sourceRect.width + 'px';
+              shadowElement.style.opacity = '0.5';
+              shadowElement.style.zIndex = '2';
+              refs.el!.appendChild(shadowElement);
+              draggierEffects.push(() => {refs.el!.removeChild(shadowElement!);});
+
+              sourceElement.style.opacity = "0";
+              draggierEffects.push(() => sourceElement.style.opacity = "");
+
+              indicator = document.createElement('div') as HTMLDivElement;
+              indicator.style.position = 'fixed';
+              indicator.style.zIndex = '3';
+              refs.el!.appendChild(indicator);
+              draggierEffects.push(() => {refs.el!.removeChild(indicator!);});
+
+              draggierEffects.push(() => {
+                if (!staticState.dropData) {return;}
+                if (staticState.dropData.itemRect.index === index) {return;}
+                let currentIndex = index;
+                let targetIndex = staticState.dropData.itemRect.index + (staticState.dropData.pos === 'prev' ? 0 : 1);
+                const newData = [...model.value];
+                const removeData = newData.splice(currentIndex, 1);
+                newData.splice(targetIndex > currentIndex ? targetIndex - 1 : targetIndex, 0, ...removeData);
+                model.value = newData;
+              });
+            }
+          }
+          if (!draggierState.isDragging || !shadowElement || !indicator) {
+            return;
+          }
+
+          shadowElement.style.top = `${Math.ceil(staticState.start.top + durY)}px`;
+          shadowElement.style.left = `${Math.ceil(staticState.start.left + durX)}px`;
+
+          const matchItemRect = staticState.siblingRects.find(i => {
+            return e.clientY > i.rects.top && e.clientY < i.rects.top + i.rects.height && e.clientX > i.rects.left && e.clientX < i.rects.left + i.rects.width;
+          });
+          if (!matchItemRect) {
+            staticState.dropData = null;
+            indicator.style.display = 'none';
+          } else {
+            staticState.dropData = {
+              itemRect: matchItemRect,
+              pos: (() => {
+                if (isHorizontal.value) {
+                  return e.clientX > matchItemRect.rects.left + matchItemRect.rects.width / 2 ? 'next' : 'prev';
+                } else {
+                  return e.clientY > matchItemRect.rects.top + matchItemRect.rects.height / 2 ? 'next' : 'prev';
+                }
+              })()
+            };
+            indicator.style.display = 'block';
+            indicator.style.backgroundColor = 'black';
+            if (isHorizontal.value) {
+              indicator.style.top = matchItemRect.rects.top + 'px';
+              indicator.style.height = matchItemRect.rects.height + 'px';
+              indicator.style.left = matchItemRect.rects.left + (staticState.dropData.pos === 'prev' ? (-indicatorSize / 2 - props.space / 2) : (matchItemRect.rects.width + props.space / 2 - indicatorSize / 2)) + 'px';
+              indicator.style.width = indicatorSize + 'px';
+            } else {
+              indicator.style.left = matchItemRect.rects.left + 'px';
+              indicator.style.width = matchItemRect.rects.width + 'px';
+              indicator.style.top = matchItemRect.rects.top + (staticState.dropData.pos === 'prev' ? (-indicatorSize / 2 - props.space / 2) : (matchItemRect.rects.height + props.space / 2 - indicatorSize / 2)) + 'px';
+              indicator.style.height = indicatorSize + 'px';
+            }
+          }
+        }));
+      };
+
+      return { mousedown };
+    })();
+
+    return () => (
+      <div
+        className={classes.value}
+        data-direction={isHorizontal.value ? 'horizontal' : 'vertical'}
+        ref={onRef.el}
+      >
+        {model.value.map((item, index) => {
+          const styles = {} as CSSProperties;
+          if (props.col !== 1) {
+            styles.width = `calc((100% - ${(props.col - 1) * props.space}px) / ${props.col})`;
+            if ((index + 1) % props.col !== 0) {
+              styles.marginRight = props.space + 'px';
+            }
+          } else {
+            styles.width = '100%';
+          }
+          styles.marginBottom = props.space + 'px';
+          return (
+            <div
+              className="sort-item"
+              style={styles}
+              key={index}
+              onMouseDown={e => draggier.mousedown(e, item, index)}
+            >
+              {scopeSlots.default({ item, index }, null)}
+            </div>
+          );
+        })}
+      </div>
+    );
+  },
+});

package/src/packages/components/SortList/sort-list.scss

@@ -0,0 +1,11 @@
+@include comp(sort-list) {
+  user-select: none;
+  &[data-direction=horizontal] {
+    display: flex;
+    flex-wrap: wrap;
+  }
+  &[data-direction=vertical] {
+    display: flex;
+    flex-direction: column;
+  }
+}