@qsxy/element-plus-react 1.0.2 → 2.0.0

package/dist/VirtualList/components/dynamic-size-list.js

@@ -0,0 +1,186 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import createList from "../builders/build-list";
+import { AUTO_ALIGNMENT, CENTERED_ALIGNMENT, DEFAULT_DYNAMIC_LIST_ITEM_SIZE, END_ALIGNMENT, SMART_ALIGNMENT, START_ALIGNMENT } from "../defaults";
+import { isHorizontal } from "../utils";
+var getItemFromCache = function getItemFromCache(props, index, listCache) {
+  var itemSize = props.itemSize;
+  var items = listCache.items,
+    lastVisitedIndex = listCache.lastVisitedIndex;
+  if (index > lastVisitedIndex) {
+    var offset = 0;
+    if (lastVisitedIndex >= 0) {
+      var item = items[lastVisitedIndex];
+      offset = item.offset + item.size;
+    }
+    for (var i = lastVisitedIndex + 1; i <= index; i++) {
+      var size = itemSize(i);
+      items[i] = {
+        offset: offset,
+        size: size
+      };
+      offset += size;
+    }
+    listCache.lastVisitedIndex = index;
+  }
+  return items[index];
+};
+var findItem = function findItem(props, listCache, offset) {
+  var items = listCache.items,
+    lastVisitedIndex = listCache.lastVisitedIndex;
+  var lastVisitedOffset = lastVisitedIndex > 0 ? items[lastVisitedIndex].offset : 0;
+  if (lastVisitedOffset >= offset) {
+    return bs(props, listCache, 0, lastVisitedIndex, offset);
+  }
+  return es(props, listCache, Math.max(0, lastVisitedIndex), offset);
+};
+
+// bs stands for binary search which has approximately time complexity of O(Log n)
+// space complexity of O(1)
+// in this case we use it for search the offset of each item, since
+// the cached items' offset is monotonically increasing
+var bs = function bs(props, listCache, low, high, offset) {
+  while (low <= high) {
+    var mid = low + Math.floor((high - low) / 2);
+    var currentOffset = getItemFromCache(props, mid, listCache).offset;
+    if (currentOffset === offset) {
+      return mid;
+    } else if (currentOffset < offset) {
+      low = mid + 1;
+    } else if (currentOffset > offset) {
+      high = mid - 1;
+    }
+  }
+  return Math.max(0, low - 1);
+};
+
+// es stands for exponential search which has time complexity of O(Log n) and
+// space complexity of O(1) in the case of finding the boundary element.
+// the exponential indicator in this case is 2.
+// for more detail about exponential search click this link
+// https://www.freecodecamp.org/news/search-algorithms-exponential-search-explained/
+
+var es = function es(props, listCache, index, offset) {
+  var total = props.total;
+  var exponent = 1;
+  while (index < total && getItemFromCache(props, index, listCache).offset < offset) {
+    index += exponent;
+    exponent *= 2;
+  }
+  return bs(props, listCache, Math.floor(index / 2), Math.min(index, total - 1), offset);
+};
+var getEstimatedTotalSize = function getEstimatedTotalSize(_ref, _ref2) {
+  var total = _ref.total;
+  var items = _ref2.items,
+    estimatedItemSize = _ref2.estimatedItemSize,
+    lastVisitedIndex = _ref2.lastVisitedIndex;
+  var totalSizeOfMeasuredItems = 0;
+  if (lastVisitedIndex >= total) {
+    lastVisitedIndex = total - 1;
+  }
+  if (lastVisitedIndex >= 0) {
+    var item = items[lastVisitedIndex];
+    totalSizeOfMeasuredItems = item.offset + item.size;
+  }
+  var numUnmeasuredItems = total - lastVisitedIndex - 1;
+  var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedItemSize;
+  return totalSizeOfMeasuredItems + totalSizeOfUnmeasuredItems;
+};
+var DynamicSizeList = createList({
+  name: 'ElDynamicSizeList',
+  getItemOffset: function getItemOffset(props, index, listCache) {
+    return getItemFromCache(props, index, listCache).offset;
+  },
+  getItemSize: function getItemSize(_, index, _ref3) {
+    var items = _ref3.items;
+    return items[index].size;
+  },
+  getEstimatedTotalSize: getEstimatedTotalSize,
+  getOffset: function getOffset(props, index, alignment, scrollOffset, listCache) {
+    var height = props.height,
+      layout = props.layout,
+      width = props.width;
+    var size = isHorizontal(layout) ? width : height;
+    var item = getItemFromCache(props, index, listCache);
+    var estimatedTotalSize = getEstimatedTotalSize(props, listCache);
+    var maxOffset = Math.max(0, Math.min(estimatedTotalSize - size, item.offset));
+    var minOffset = Math.max(0, item.offset - size + item.size);
+    var finalAlignment = alignment;
+    if (alignment === SMART_ALIGNMENT) {
+      if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
+        finalAlignment = AUTO_ALIGNMENT;
+      } else {
+        finalAlignment = CENTERED_ALIGNMENT;
+      }
+    }
+    switch (finalAlignment) {
+      case START_ALIGNMENT:
+        {
+          return maxOffset;
+        }
+      case END_ALIGNMENT:
+        {
+          return minOffset;
+        }
+      case CENTERED_ALIGNMENT:
+        {
+          return Math.round(minOffset + (maxOffset - minOffset) / 2);
+        }
+      case AUTO_ALIGNMENT:
+      default:
+        {
+          if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
+            return scrollOffset;
+          } else if (scrollOffset < minOffset) {
+            return minOffset;
+          } else {
+            return maxOffset;
+          }
+        }
+    }
+  },
+  getStartIndexForOffset: function getStartIndexForOffset(props, offset, listCache) {
+    return findItem(props, listCache, offset);
+  },
+  getStopIndexForStartIndex: function getStopIndexForStartIndex(props, startIndex, scrollOffset, listCache) {
+    var height = props.height,
+      total = props.total,
+      layout = props.layout,
+      width = props.width;
+    var size = isHorizontal(layout) ? width : height;
+    var item = getItemFromCache(props, startIndex, listCache);
+    var maxOffset = scrollOffset + size;
+    var offset = item.offset + item.size;
+    var stopIndex = startIndex;
+    while (stopIndex < total - 1 && offset < maxOffset) {
+      stopIndex++;
+      offset += getItemFromCache(props, stopIndex, listCache).size;
+    }
+    return stopIndex;
+  },
+  initCache: function initCache(_ref4) {
+    var _ref4$estimatedItemSi = _ref4.estimatedItemSize,
+      estimatedItemSize = _ref4$estimatedItemSi === void 0 ? DEFAULT_DYNAMIC_LIST_ITEM_SIZE : _ref4$estimatedItemSi;
+    var cache = {
+      items: {},
+      estimatedItemSize: estimatedItemSize,
+      lastVisitedIndex: -1
+    };
+    cache.clearCacheAfterIndex = function (index) {
+      var forceUpdate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      cache.lastVisitedIndex = Math.min(cache.lastVisitedIndex, index - 1);
+      // In React, we'll handle force update differently
+      if (forceUpdate) {
+        // Force update will be handled by the component
+      }
+    };
+    return cache;
+  },
+  clearCache: false,
+  validateProps: function validateProps(_ref5) {
+    var itemSize = _ref5.itemSize;
+    if (typeof itemSize !== 'function') {
+      throw new Error("[ElDynamicSizeList] itemSize is required as function, but the given value was ".concat(_typeof(itemSize)));
+    }
+  }
+});
+export default DynamicSizeList;

package/dist/VirtualList/components/fixed-size-grid.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+declare const FixedSizeGrid: React.ForwardRefExoticComponent<import("..").VirtualizedGridProps & React.RefAttributes<import("..").GridExposes>>;
+export type FixedSizeGridInstance = React.ElementRef<typeof FixedSizeGrid> & unknown;
+export default FixedSizeGrid;

package/dist/VirtualList/components/fixed-size-grid.js

@@ -0,0 +1,161 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import createGrid from "../builders/build-grid";
+import { AUTO_ALIGNMENT, CENTERED_ALIGNMENT, END_ALIGNMENT, SMART_ALIGNMENT, START_ALIGNMENT } from "../defaults";
+var SCOPE = 'ElFixedSizeGrid';
+var FixedSizeGrid = createGrid({
+  name: 'ElFixedSizeGrid',
+  getColumnPosition: function getColumnPosition(_ref, index) {
+    var columnWidth = _ref.columnWidth;
+    return [columnWidth, index * columnWidth];
+  },
+  getRowPosition: function getRowPosition(_ref2, index) {
+    var rowHeight = _ref2.rowHeight;
+    return [rowHeight, index * rowHeight];
+  },
+  getEstimatedTotalHeight: function getEstimatedTotalHeight(_ref3) {
+    var totalRow = _ref3.totalRow,
+      rowHeight = _ref3.rowHeight;
+    return rowHeight * totalRow;
+  },
+  getEstimatedTotalWidth: function getEstimatedTotalWidth(_ref4) {
+    var totalColumn = _ref4.totalColumn,
+      columnWidth = _ref4.columnWidth;
+    return columnWidth * totalColumn;
+  },
+  getColumnOffset: function getColumnOffset(_ref5, columnIndex, alignment, scrollLeft, _, scrollBarWidth) {
+    var totalColumn = _ref5.totalColumn,
+      columnWidth = _ref5.columnWidth,
+      width = _ref5.width;
+    width = Number(width);
+    var lastColumnOffset = Math.max(0, totalColumn * columnWidth - width);
+    var maxOffset = Math.min(lastColumnOffset, columnIndex * columnWidth);
+    var minOffset = Math.max(0, columnIndex * columnWidth - width + scrollBarWidth + columnWidth);
+    var finalAlignment = alignment;
+    if (alignment === 'smart') {
+      if (scrollLeft >= minOffset - width && scrollLeft <= maxOffset + width) {
+        finalAlignment = AUTO_ALIGNMENT;
+      } else {
+        finalAlignment = CENTERED_ALIGNMENT;
+      }
+    }
+    switch (finalAlignment) {
+      case START_ALIGNMENT:
+        return maxOffset;
+      case END_ALIGNMENT:
+        return minOffset;
+      case CENTERED_ALIGNMENT:
+        {
+          var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
+          if (middleOffset < Math.ceil(width / 2)) {
+            return 0;
+          } else if (middleOffset > lastColumnOffset + Math.floor(width / 2)) {
+            return lastColumnOffset;
+          } else {
+            return middleOffset;
+          }
+        }
+      case AUTO_ALIGNMENT:
+      default:
+        if (scrollLeft >= minOffset && scrollLeft <= maxOffset) {
+          return scrollLeft;
+        } else if (minOffset > maxOffset) {
+          return minOffset;
+        } else if (scrollLeft < minOffset) {
+          return minOffset;
+        } else {
+          return maxOffset;
+        }
+    }
+  },
+  getRowOffset: function getRowOffset(_ref6, rowIndex, align, scrollTop, _, scrollBarWidth) {
+    var rowHeight = _ref6.rowHeight,
+      height = _ref6.height,
+      totalRow = _ref6.totalRow;
+    height = Number(height);
+    var lastRowOffset = Math.max(0, totalRow * rowHeight - height);
+    var maxOffset = Math.min(lastRowOffset, rowIndex * rowHeight);
+    var minOffset = Math.max(0, rowIndex * rowHeight - height + scrollBarWidth + rowHeight);
+    var finalAlign = align;
+    if (align === SMART_ALIGNMENT) {
+      if (scrollTop >= minOffset - height && scrollTop <= maxOffset + height) {
+        finalAlign = AUTO_ALIGNMENT;
+      } else {
+        finalAlign = CENTERED_ALIGNMENT;
+      }
+    }
+    switch (finalAlign) {
+      case START_ALIGNMENT:
+        return maxOffset;
+      case END_ALIGNMENT:
+        return minOffset;
+      case CENTERED_ALIGNMENT:
+        {
+          var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
+          if (middleOffset < Math.ceil(height / 2)) {
+            return 0;
+          } else if (middleOffset > lastRowOffset + Math.floor(height / 2)) {
+            return lastRowOffset;
+          } else {
+            return middleOffset;
+          }
+        }
+      case AUTO_ALIGNMENT:
+      default:
+        if (scrollTop >= minOffset && scrollTop <= maxOffset) {
+          return scrollTop;
+        } else if (minOffset > maxOffset) {
+          return minOffset;
+        } else if (scrollTop < minOffset) {
+          return minOffset;
+        } else {
+          return maxOffset;
+        }
+    }
+  },
+  getColumnStartIndexForOffset: function getColumnStartIndexForOffset(_ref7, scrollLeft) {
+    var columnWidth = _ref7.columnWidth,
+      totalColumn = _ref7.totalColumn;
+    return Math.max(0, Math.min(totalColumn - 1, Math.floor(scrollLeft / columnWidth)));
+  },
+  getColumnStopIndexForStartIndex: function getColumnStopIndexForStartIndex(_ref8, startIndex, scrollLeft) {
+    var columnWidth = _ref8.columnWidth,
+      totalColumn = _ref8.totalColumn,
+      width = _ref8.width;
+    var left = startIndex * columnWidth;
+    var visibleColumnsCount = Math.ceil((width + scrollLeft - left) / columnWidth);
+    return Math.max(0, Math.min(totalColumn - 1, startIndex + visibleColumnsCount - 1));
+  },
+  getRowStartIndexForOffset: function getRowStartIndexForOffset(_ref9, scrollTop) {
+    var rowHeight = _ref9.rowHeight,
+      totalRow = _ref9.totalRow;
+    return Math.max(0, Math.min(totalRow - 1, Math.floor(scrollTop / rowHeight)));
+  },
+  getRowStopIndexForStartIndex: function getRowStopIndexForStartIndex(_ref10, startIndex, scrollTop) {
+    var rowHeight = _ref10.rowHeight,
+      totalRow = _ref10.totalRow,
+      height = _ref10.height;
+    var top = startIndex * rowHeight;
+    var numVisibleRows = Math.ceil((height + scrollTop - top) / rowHeight);
+    return Math.max(0, Math.min(totalRow - 1, startIndex + numVisibleRows - 1 // -1 is because stop index is inclusive
+    ));
+  },
+  /**
+   * Fixed size grid does not need this cache
+   * Using any to bypass it, TODO: Using type inference to fix this.
+   */
+  initCache: function initCache() {
+    return undefined;
+  },
+  clearCache: true,
+  validateProps: function validateProps(_ref11) {
+    var columnWidth = _ref11.columnWidth,
+      rowHeight = _ref11.rowHeight;
+    if (typeof columnWidth !== 'number') {
+      throw new Error("[".concat(SCOPE, "] \"columnWidth\" must be passed as number, instead ").concat(_typeof(columnWidth), " was given."));
+    }
+    if (typeof rowHeight !== 'number') {
+      throw new Error("[".concat(SCOPE, "] \"rowHeight\" must be passed as number, instead ").concat(_typeof(rowHeight), " was given."));
+    }
+  }
+});
+export default FixedSizeGrid;

package/dist/VirtualList/components/fixed-size-list.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { VirtualizedListProps } from '../props';
+declare const FixedSizeList: React.ForwardRefExoticComponent<VirtualizedListProps & {
+    children: (props: any) => React.ReactNode;
+} & React.RefAttributes<import("..").ListExposes>>;
+export type FixedSizeListInstance = React.ElementRef<typeof FixedSizeList> & unknown;
+export default FixedSizeList;

package/dist/VirtualList/components/fixed-size-list.js

@@ -0,0 +1,103 @@
+import buildList from "../builders/build-list";
+import { AUTO_ALIGNMENT, CENTERED_ALIGNMENT, END_ALIGNMENT, SMART_ALIGNMENT, START_ALIGNMENT } from "../defaults";
+import { isHorizontal } from "../utils";
+var FixedSizeList = buildList({
+  name: 'ElFixedSizeList',
+  getItemOffset: function getItemOffset(_ref, index) {
+    var itemSize = _ref.itemSize;
+    return index * itemSize;
+  },
+  getItemSize: function getItemSize(_ref2) {
+    var itemSize = _ref2.itemSize;
+    return itemSize;
+  },
+  getEstimatedTotalSize: function getEstimatedTotalSize(_ref3) {
+    var total = _ref3.total,
+      itemSize = _ref3.itemSize;
+    return itemSize * total;
+  },
+  getOffset: function getOffset(_ref4, index, alignment, scrollOffset) {
+    var height = _ref4.height,
+      total = _ref4.total,
+      itemSize = _ref4.itemSize,
+      layout = _ref4.layout,
+      width = _ref4.width;
+    var size = isHorizontal(layout) ? width : height;
+    var lastItemOffset = Math.max(0, total * itemSize - size);
+    var maxOffset = Math.min(lastItemOffset, index * itemSize);
+    var minOffset = Math.max(0, (index + 1) * itemSize - size);
+    var finalAlignment = alignment;
+    if (alignment === SMART_ALIGNMENT) {
+      if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
+        finalAlignment = AUTO_ALIGNMENT;
+      } else {
+        finalAlignment = CENTERED_ALIGNMENT;
+      }
+    }
+    switch (finalAlignment) {
+      case START_ALIGNMENT:
+        {
+          return maxOffset;
+        }
+      case END_ALIGNMENT:
+        {
+          return minOffset;
+        }
+      case CENTERED_ALIGNMENT:
+        {
+          // "Centered" offset is usually the average of the min and max.
+          // But near the edges of the list, this doesn't hold true.
+          var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
+          if (middleOffset < Math.ceil(size / 2)) {
+            return 0; // near the beginning
+          } else if (middleOffset > lastItemOffset + Math.floor(size / 2)) {
+            return lastItemOffset; // near the end
+          } else {
+            return middleOffset;
+          }
+        }
+      case AUTO_ALIGNMENT:
+      default:
+        {
+          if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
+            return scrollOffset;
+          } else if (scrollOffset < minOffset) {
+            return minOffset;
+          } else {
+            return maxOffset;
+          }
+        }
+    }
+  },
+  getStartIndexForOffset: function getStartIndexForOffset(_ref5, offset) {
+    var total = _ref5.total,
+      itemSize = _ref5.itemSize;
+    return Math.max(0, Math.min(total - 1, Math.floor(offset / itemSize)));
+  },
+  getStopIndexForStartIndex: function getStopIndexForStartIndex(_ref6, startIndex, scrollOffset) {
+    var height = _ref6.height,
+      total = _ref6.total,
+      itemSize = _ref6.itemSize,
+      layout = _ref6.layout,
+      width = _ref6.width;
+    var offset = startIndex * itemSize;
+    var size = isHorizontal(layout) ? width : height;
+    var numVisibleItems = Math.ceil((size + scrollOffset - offset) / itemSize);
+    return Math.max(0, Math.min(total - 1,
+    // because startIndex is inclusive, so in order to prevent array outbound indexing
+    // we need to - 1 to prevent outbound behavior
+    startIndex + numVisibleItems - 1));
+  },
+  /**
+   * Fixed size list does not need this cache
+   * Using any to bypass it, TODO: Using type inference to fix this.
+   */
+  initCache: function initCache() {
+    return undefined;
+  },
+  clearCache: true,
+  validateProps: function validateProps() {
+    //
+  }
+});
+export default FixedSizeList;

package/dist/VirtualList/components/scrollbar.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { VirtualizedScrollbarProps } from '../props';
+import { ScrollbarExpose } from '../types';
+declare const Scrollbar: React.ForwardRefExoticComponent<VirtualizedScrollbarProps & React.RefAttributes<ScrollbarExpose>>;
+export default Scrollbar;