@king-design/vue 2.1.4 → 2.1.5

package/components/table/useDraggable.js

@@ -8,6 +8,7 @@ export function useDraggable(data) {
   var originIndex;
   var originData;
   var draggingIndex;
+
   function onRowDragStart(e, tableRow) {
     draggingIndex = originIndex = tableRow.get('index');
     var key = tableRow.get('key');
@@ -18,22 +19,28 @@ export function useDraggable(data) {
       from: draggingIndex
     });
   }
+
   function onRowDragOver(e, tableRow) {
     var _context;
+
     e.preventDefault();
     e.stopPropagation();
     var newIndex = tableRow.get('index');
-    if (newIndex === draggingIndex) return;
-    // swap data
+    if (newIndex === draggingIndex) return; // swap data
+
     var newData = _sliceInstanceProperty(_context = data.value).call(_context);
+
     var item = _spliceInstanceProperty(newData).call(newData, draggingIndex, 1)[0];
+
     _spliceInstanceProperty(newData).call(newData, newIndex, 0, item);
+
     draggingIndex = newIndex;
     data.set(newData);
   }
+
   function onRowDragEnd(e, tableRow) {
-    e.preventDefault();
-    // revert to origin data, then set to new data to trigger animation
+    e.preventDefault(); // revert to origin data, then set to new data to trigger animation
+
     var newData = data.value;
     data.set(originData);
     nextTick(function () {
@@ -46,6 +53,7 @@ export function useDraggable(data) {
       });
     });
   }
+
   return {
     onRowDragStart: onRowDragStart,
     onRowDragOver: onRowDragOver,

package/components/table/useExpandable.js

@@ -3,14 +3,17 @@ import { inArray } from './useChecked';
 import { toggleArray } from '../utils';
 export function useExpandable() {
   var instance = useInstance();
+
   function isExpanded(key) {
     return inArray(instance.get('expandedKeys'), key);
   }
+
   instance.on('clickRow', function (data, index, key) {
     if (instance.get('rowExpandable')) {
       var _instance$get = instance.get(),
-        expandedKeys = _instance$get.expandedKeys,
-        $blocks = _instance$get.$blocks;
+          expandedKeys = _instance$get.expandedKeys,
+          $blocks = _instance$get.$blocks;
+
       if (!$blocks || !$blocks.expand) return;
       instance.set('expandedKeys', toggleArray(expandedKeys, key));
     }

package/components/table/useFixedColumns.d.ts

@@ -3,7 +3,7 @@ import { TableColumn, TableColumnProps } from './column';
 import type { TableProps, TableRowKey } from './table';
 import { State } from '../../hooks/useState';
 import type { useScroll } from './useScroll';
-type ScrollPosition = 'left' | 'middle' | 'right';
+declare type ScrollPosition = 'left' | 'middle' | 'right';
 export declare const context: {
     Provider: import("intact").ComponentConstructor<import("intact").Component<import("../context").ProviderProps<any>, {}, {}, {}>>;
     Consumer: import("intact").ComponentConstructor<import("intact").Component<import("../context").ConsumerProps<any>, {}, {}, {}>>;

package/components/table/useFixedColumns.js

@@ -8,7 +8,7 @@ import { createContext } from '../context';
 export var context = createContext();
 export function useFixedColumns(getColumns, _ref, widthMap) {
   var scrollRef = _ref.scrollRef,
-    callbacks = _ref.callbacks;
+      callbacks = _ref.callbacks;
   var instance = useInstance();
   var scrollPosition = useState(null);
   var hasFixed = useState(false);
@@ -32,6 +32,7 @@ export function useFixedColumns(getColumns, _ref, widthMap) {
   onUnmounted(function () {
     window.removeEventListener('resize', throttleUpdate);
   });
+
   function handleFixedColumns() {
     var columns = getColumns();
     hasFixedLeft = false;
@@ -44,34 +45,45 @@ export function useFixedColumns(getColumns, _ref, widthMap) {
         var key = props.key;
         offsetMap[key] = 0;
         var fixed = props.fixed;
+
         if (fixed === 'left') {
           var value = 0;
           var prevVNode = props.prevVNode;
+
           while (prevVNode) {
             var _props = prevVNode.props;
+
             if (_props.fixed === 'left') {
               if (process.env.NODE_ENV !== 'production') {
                 validateWidth(_props);
               }
+
               value += widthMap.value[_props.key] || parseInt(_props.width, 10) || 0;
             }
+
             prevVNode = _props.prevVNode;
           }
+
           offsetMap[key] = value;
           hasFixedLeft = true;
         } else if (fixed === 'right') {
           var _value = 0;
           var lastVNode = columns[columns.length - 1];
+
           while (vNode !== lastVNode) {
             var _props2 = lastVNode.props;
+
             if (_props2.fixed === 'right') {
               if (process.env.NODE_ENV !== 'production') {
                 validateWidth(_props2);
               }
+
               _value += widthMap.value[_props2.key] || parseInt(_props2.width, 10) || 0;
             }
+
             lastVNode = _props2.prevVNode;
           }
+
           offsetMap[key] = _value;
           hasFixedRight = true;
         }
@@ -79,20 +91,24 @@ export function useFixedColumns(getColumns, _ref, widthMap) {
     });
     hasFixed.set(hasFixedLeft || hasFixedRight);
   }
+
   function setScrollPosition(scrollLeft) {
     if (!hasFixed.value) return;
     var scrollDom = scrollRef.value;
     var maxScroll = scrollDom.scrollWidth - scrollDom.offsetWidth;
     scrollPosition.set(scrollLeft === 0 ? 'left' : scrollLeft >= maxScroll ? 'right' : 'middle');
   }
+
   function updateScrollPositionOnResize() {
     var scrollDom = scrollRef.value;
+
     if (scrollDom.scrollWidth - scrollDom.offsetWidth <= 0) {
       scrollPosition.set(null);
     } else {
       setScrollPosition(scrollRef.value.scrollLeft);
     }
   }
+
   return {
     scrollPosition: scrollPosition,
     setScrollPosition: setScrollPosition,
@@ -107,18 +123,21 @@ export function useFixedColumns(getColumns, _ref, widthMap) {
 }
 export function getClassAndStyleForFixed(_ref2, offset, checkType) {
   var _cx, _ref3;
+
   var className = _ref2.className,
-    fixed = _ref2.fixed,
-    align = _ref2.align;
+      fixed = _ref2.fixed,
+      align = _ref2.align;
   var extraOffset = checkType && checkType !== 'none' && fixed === 'left' ? 40 : 0;
   return {
     className: cx((_cx = {}, _cx[className] = !!className, _cx["k-fixed-" + fixed] = !!fixed, _cx["k-align-" + align] = !!align, _cx)),
     style: fixed ? (_ref3 = {}, _ref3[fixed] = offset + extraOffset + "px", _ref3) : null
   };
 }
+
 function validateWidth(_ref4) {
   var width = _ref4.width,
-    key = _ref4.key;
+      key = _ref4.key;
+
   if (isNullOrUndefined(width) || isString(width) && !/\d+(px)?/.test(width)) {
     error("The width must be specified with 'px' when the column has fixed. <TableColumn key=\"" + key + "\" />");
   }

package/components/table/useGroup.d.ts

@@ -1,5 +1,5 @@
 import type { TableColumnGroupItem } from './column';
-type ContextValue = {
+declare type ContextValue = {
     groupValue: any;
     onChange: (key: string, groupValue: any) => void;
 };

package/components/table/useGroup.js

@@ -15,54 +15,71 @@ export function useGroup() {
   instance.on('$receive:group', function (group) {
     return filteredGroup.set(group);
   });
+
   function onSelect(value, groupValue, onChange) {
     var _instance$get = instance.get(),
-      multiple = _instance$get.multiple,
-      key = _instance$get.key;
+        multiple = _instance$get.multiple,
+        key = _instance$get.key;
+
     if (multiple) {
       value = toggleArray(groupValue, value);
     }
+
     onChange(key, value);
   }
+
   function isChecked(value, groupValue) {
     var _instance$get2 = instance.get(),
-      multiple = _instance$get2.multiple;
+        multiple = _instance$get2.multiple;
+
     if (multiple) {
       return groupValue && _includesInstanceProperty(groupValue).call(groupValue, value);
     }
+
     return groupValue === value;
   }
+
   function getGroupText(groupValue) {
     var _instance$get3 = instance.get(),
-      multiple = _instance$get3.multiple,
-      group = _instance$get3.group;
+        multiple = _instance$get3.multiple,
+        group = _instance$get3.group;
+
     if (isNullOrUndefined(groupValue)) return null;
+
     if (!multiple) {
       groupValue = [groupValue];
     }
+
     if (group) {
       var _context;
+
       var ret = _mapInstanceProperty(_context = _filterInstanceProperty(group).call(group, function (item) {
         return _includesInstanceProperty(groupValue).call(groupValue, item.value);
       })).call(_context, function (item) {
         return item.label;
       }).join(', ');
+
       if (ret) {
         return "(" + ret + ")";
       }
     }
+
     return null;
   }
+
   watchState(keywords, function (v) {
     var _instance$get4 = instance.get(),
-      _instance$get4$group = _instance$get4.group,
-      group = _instance$get4$group === void 0 ? [] : _instance$get4$group;
+        _instance$get4$group = _instance$get4.group,
+        group = _instance$get4$group === void 0 ? [] : _instance$get4$group;
+
     v = _trimInstanceProperty(v).call(v);
+
     if (!v) {
       filteredGroup.set(group);
     } else {
       filteredGroup.set(_filterInstanceProperty(group).call(group, function (item) {
         var _context2, _context3;
+
         return _includesInstanceProperty(_context2 = String(item.label)).call(_context2, v) || _includesInstanceProperty(_context3 = String(item.value)).call(_context3, v);
       }));
     }

package/components/table/useMerge.d.ts

@@ -1,16 +1,16 @@
 import { Props } from 'intact-vue-next';
 import type { TableColumnProps } from './column';
 import { State } from '../../hooks/useState';
-export type TableMerge<T = any, CheckType = 'checkbox'> = (row: T, column: CheckType extends 'none' ? Props<TableColumnProps> : Props<TableColumnProps> | null, rowIndex: number, columnIndex: number) => TableMergeConfig | undefined;
-export type TableMergeConfig = {
+export declare type TableMerge<T = any, CheckType = 'checkbox'> = (row: T, column: CheckType extends 'none' ? Props<TableColumnProps> : Props<TableColumnProps> | null, rowIndex: number, columnIndex: number) => TableMergeConfig | undefined;
+export declare type TableMergeConfig = {
     colspan?: number;
     rowspan?: number;
 };
-export type TableGridItem = {
+export declare type TableGridItem = {
     render: boolean;
     spans: TableMergeConfig | undefined;
 };
-export type TableGrid = TableGridItem[][];
+export declare type TableGrid = TableGridItem[][];
 export declare function useMerge(getCols: () => Props<TableColumnProps>[], data: State<unknown[] | undefined>): {
     getGrid: () => TableGrid;
 };

package/components/table/useMerge.js

@@ -3,29 +3,36 @@ import { watchState } from '../../hooks/useState';
 export function useMerge(getCols, data) {
   var instance = useInstance();
   var grid = [];
+
   function handleSpans() {
     grid = [];
+
     var _instance$get = instance.get(),
-      merge = _instance$get.merge,
-      checkType = _instance$get.checkType;
+        merge = _instance$get.merge,
+        checkType = _instance$get.checkType;
+
     if (!data.value || !data.value.length || !merge) return;
     var cols = getCols();
     data.value.forEach(function (data, rowIndex) {
       var currentRow = [];
       grid.push(currentRow);
       var columnIndexOffset = 0;
+
       if (checkType !== 'none') {
         handleGridItem(currentRow, merge, data, null, rowIndex, 0);
         columnIndexOffset = 1;
       }
+
       cols.forEach(function (props, columnIndex) {
         handleGridItem(currentRow, merge, data, props, rowIndex, columnIndex + columnIndexOffset);
       });
     });
   }
+
   function handleGridItem(currentRow, merge, data, column, rowIndex, columnIndex) {
     var prevCell = currentRow[columnIndex - 1];
     var tmp;
+
     if (prevCell && (tmp = prevCell.spans) && tmp.colspan > 1) {
       currentRow.push({
         render: false,
@@ -36,9 +43,11 @@ export function useMerge(getCols, data) {
       });
       return;
     }
+
     if (rowIndex > 0) {
       var prevRow = grid[rowIndex - 1];
       var aboveCell = prevRow[columnIndex];
+
       if (aboveCell && (tmp = aboveCell.spans) && tmp.rowspan > 1) {
         currentRow.push({
           render: false,
@@ -50,14 +59,17 @@ export function useMerge(getCols, data) {
         return;
       }
     }
+
     currentRow.push({
       render: true,
       spans: merge(data, column, rowIndex, columnIndex)
     });
   }
+
   function getGrid() {
     return grid;
   }
+
   instance.on('$receive:children', handleSpans);
   watchState(data, handleSpans);
   return {

package/components/table/usePagination.js

@@ -12,51 +12,65 @@ export function usePagination() {
   var value = useState(defaultPagination.value);
   var limit = useState(defaultPagination.limit);
   var paginationRef = createRef(); // for unit test
+
   useReceive(['data', 'pagination'], function () {
     handleData();
   });
+
   function handleData() {
     var _instance$get = instance.get(),
-      _data = _instance$get.data,
-      pagination = _instance$get.pagination;
+        _data = _instance$get.data,
+        pagination = _instance$get.pagination;
+
     if (!_data) {
       data.set(undefined);
       return;
     }
+
     if (!pagination) {
       data.set(_data);
       return;
     }
+
     if (isObject(pagination)) {
       if (pagination.value) {
         value.set(pagination.value);
       }
+
       if (pagination.limit) {
         limit.set(pagination.limit);
       }
     }
+
     updateDataByPage();
   }
+
   function updateDataByPage() {
     var _instance$get2 = instance.get(),
-      _data = _instance$get2.data;
+        _data = _instance$get2.data;
+
     var index = (value.value - 1) * limit.value;
     data.set(_sliceInstanceProperty(_data).call(_data, index, index + limit.value));
   }
+
   function onChange(data) {
     var _instance$get3 = instance.get(),
-      pagination = _instance$get3.pagination;
+        pagination = _instance$get3.pagination;
+
     value.set(data.value);
     limit.set(data.limit);
     updateDataByPage();
+
     if (isObject(pagination)) {
       instance.set('pagination', _extends({}, pagination, {
         value: value.value,
         limit: limit.value
       }));
     }
+
     instance.trigger('changePage', data);
   }
+
   return {
     data: data,
     value: value,

package/components/table/useResizable.js

@@ -12,21 +12,26 @@ export function useResizable(scrollRef, tableRef, tableWidth, widthMap, storeWid
   var currentVNode;
   var currentTh;
   var minWidth;
+
   function onStart(e) {
     containerWidth = scrollRef.value.clientWidth;
-    x = e.clientX;
-    // find the previous column but exclude the hidden columns, #467
+    x = e.clientX; // find the previous column but exclude the hidden columns, #467
+
     prevVNode = currentVNode = e._vNode;
     prevTh;
+
     do {
       prevVNode = prevVNode.props.prevVNode;
       prevTh = findDomFromVNode(prevVNode, true);
     } while (window.getComputedStyle(prevTh).display === 'none');
+
     currentTh = findDomFromVNode(currentVNode, true);
     minWidth = prevVNode.props.minWidth || instance.get('minColWidth');
   }
+
   function onMove(e) {
     var _map;
+
     var delX = e.clientX - x;
     if (delX === 0) return;
     var newPrevWidth = prevTh.offsetWidth + delX;
@@ -37,13 +42,16 @@ export function useResizable(scrollRef, tableRef, tableWidth, widthMap, storeWid
     var prevKey = prevVNode.props.key;
     x = e.clientX;
     var map = (_map = {}, _map[prevKey] = newPrevWidth, _map);
+
     if (containerWidth > newTableWidth) {
       map[currentKey] = newCurrentWidth;
     } else {
       tableWidth.set(newTableWidth);
     }
+
     widthMap.set(_extends({}, widthMap.value, map));
   }
+
   return useDraggable({
     onStart: onStart,
     onMove: onMove,

package/components/table/useRestRowStatus.js

@@ -6,13 +6,15 @@ export function useRestRowStatus(getAllKeys) {
   var instance = useInstance();
   var allUnmountedRows = [];
   var willUnmounted = false;
+
   function onRowBeforeUnmount(key) {
-    if (willUnmounted || instance.get('keepStatus')) return;
-    // maybe the row is only removed by shrinking, i.e. tree table
+    if (willUnmounted || instance.get('keepStatus')) return; // maybe the row is only removed by shrinking, i.e. tree table
+
     var allKeys = getAllKeys();
     if (_includesInstanceProperty(allKeys).call(allKeys, key)) return;
     allUnmountedRows.push(key);
   }
+
   function reset() {
     if (allUnmountedRows.length) {
       omit('checkedKeys', allUnmountedRows);
@@ -22,6 +24,7 @@ export function useRestRowStatus(getAllKeys) {
       allUnmountedRows = [];
     }
   }
+
   function omit(type, keys) {
     var originKeys = instance.get(type);
     if (!originKeys) return;
@@ -31,6 +34,7 @@ export function useRestRowStatus(getAllKeys) {
     });
     instance.set(type, originKeys);
   }
+
   onBeforeUnmount(function () {
     return willUnmounted = true;
   });

package/components/table/useScroll.d.ts

@@ -1,5 +1,5 @@
 import { RefObject } from 'intact-vue-next';
-export type ScrollCallback = (scrollLeft: number) => void;
+export declare type ScrollCallback = (scrollLeft: number) => void;
 export declare function useScroll(): {
     callbacks: ScrollCallback[];
     scrollRef: RefObject<HTMLElement>;

package/components/table/useScroll.js

@@ -3,8 +3,10 @@ export function useScroll() {
   var callbacks = [];
   var scrollRef = createRef();
   var scrollLeft = 0;
+
   function onScroll() {
     var newScrollLeft = scrollRef.value.scrollLeft;
+
     if (scrollLeft !== newScrollLeft) {
       scrollLeft = newScrollLeft;
       callbacks.forEach(function (fn) {
@@ -12,6 +14,7 @@ export function useScroll() {
       });
     }
   }
+
   onMounted(function () {
     scrollRef.value.addEventListener('scroll', onScroll, {
       passive: true

package/components/table/useSelected.js

@@ -3,13 +3,16 @@ import { inArray } from './useChecked';
 import { toggleArray } from '../utils';
 export function useSelected() {
   var instance = useInstance();
+
   function isSelected(key) {
     return inArray(instance.get('selectedKeys'), key);
   }
+
   instance.on('clickRow', function (data, index, key) {
     var _instance$get = instance.get(),
-      rowSelectable = _instance$get.rowSelectable,
-      selectedKeys = _instance$get.selectedKeys;
+        rowSelectable = _instance$get.rowSelectable,
+        selectedKeys = _instance$get.selectedKeys;
+
     if (rowSelectable === 'multiple') {
       instance.set('selectedKeys', toggleArray(selectedKeys, key));
     } else if (rowSelectable) {

package/components/table/useSortable.js

@@ -3,16 +3,20 @@ import { useInstance } from 'intact-vue-next';
 import { createContext } from '../context';
 export var context = createContext();
 export function useSortable() {
-  var instance = useInstance();
-  // if the same column has been clicked three times consecutively,
+  var instance = useInstance(); // if the same column has been clicked three times consecutively,
   // then let the third click to reset the sort
+
   var count = 0;
+
   function onChange(key, event) {
     // ignore when click group dropdown menu
     if (event._ignoreSortable) return;
+
     var sort = _extends({}, instance.get('sort'));
+
     if (sort.key === key) {
       count++;
+
       if (count === 3) {
         sort = {};
       } else {
@@ -23,8 +27,10 @@ export function useSortable() {
       sort.key = key;
       if (!sort.type) sort.type = 'desc';
     }
+
     instance.set('sort', sort);
   }
+
   return {
     onChange: onChange
   };

package/components/table/useStickyHeader.js

@@ -6,16 +6,20 @@ export function useStickyHeader(callbacks) {
   var elementRef = createRef();
   var headRef = createRef();
   var stickHeader = useState(null);
+
   function excludeStickHeader(_ref) {
     var offsetTop = _ref.offsetTop;
+
     var _elementRef$value$get = elementRef.value.getBoundingClientRect(),
-      bottom = _elementRef$value$get.bottom;
+        bottom = _elementRef$value$get.bottom;
+
     return bottom <= offsetTop;
   }
+
   instance.on('$receive:stickHeader', function (v) {
     stickHeader.set(v === true ? 0 : isStringOrNumber(v) ? +v : null);
-  });
-  // when the scroll element scroll horizontally, scroll the sticky header too 
+  }); // when the scroll element scroll horizontally, scroll the sticky header too 
+
   callbacks.push(function (scrollLeft) {
     if (isNull(stickHeader.value)) return;
     var affixHeadWrapper = headRef.value.parentElement;