vft 0.0.375 → 0.0.376

package/es/components/virtual-list/components/dynamic-size-list.js

@@ -1,171 +1,111 @@
 import "@vueuse/core";
 import "@vft/utils";
-import { throwError } from "../../../utils/error.js";
+import { throwError as N } from "../../../utils/error.js";
 import "../../config-provider/hooks/use-global-config.js";
 import "vue";
 import "lodash-es";
-import createList from "../builders/build-list.js";
-import { isHorizontal } from "../utils.js";
-import { AUTO_ALIGNMENT, CENTERED_ALIGNMENT, END_ALIGNMENT, START_ALIGNMENT, SMART_ALIGNMENT, DEFAULT_DYNAMIC_LIST_ITEM_SIZE } from "../defaults.js";
-const SCOPE = "ElDynamicSizeList";
-const getItemFromCache = (props, index, listCache) => {
-  const { itemSize } = props;
-  const { items, lastVisitedIndex } = listCache;
-  if (index > lastVisitedIndex) {
-    let offset = 0;
-    if (lastVisitedIndex >= 0) {
-      const item = items[lastVisitedIndex];
-      offset = item.offset + item.size;
+import T from "../builders/build-list.js";
+import { isHorizontal as z } from "../utils.js";
+import { AUTO_ALIGNMENT as E, CENTERED_ALIGNMENT as M, END_ALIGNMENT as l, START_ALIGNMENT as A, SMART_ALIGNMENT as L, DEFAULT_DYNAMIC_LIST_ITEM_SIZE as _ } from "../defaults.js";
+const x = "ElDynamicSizeList", I = (e, s, t) => {
+  const { itemSize: i } = e, { items: o, lastVisitedIndex: n } = t;
+  if (s > n) {
+    let f = 0;
+    if (n >= 0) {
+      const r = o[n];
+      f = r.offset + r.size;
     }
-    for (let i = lastVisitedIndex + 1; i <= index; i++) {
-      const size = itemSize(i);
-      items[i] = {
-        offset,
-        size
-      };
-      offset += size;
+    for (let r = n + 1; r <= s; r++) {
+      const m = i(r);
+      o[r] = {
+        offset: f,
+        size: m
+      }, f += m;
     }
-    listCache.lastVisitedIndex = index;
+    t.lastVisitedIndex = s;
   }
-  return items[index];
-};
-const findItem = (props, listCache, offset) => {
-  const { items, lastVisitedIndex } = listCache;
-  const 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);
-};
-const bs = (props, listCache, low, high, offset) => {
-  while (low <= high) {
-    const mid = low + Math.floor((high - low) / 2);
-    const 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 o[s];
+}, y = (e, s, t) => {
+  const { items: i, lastVisitedIndex: o } = s;
+  return (o > 0 ? i[o].offset : 0) >= t ? S(e, s, 0, o, t) : O(e, s, Math.max(0, o), t);
+}, S = (e, s, t, i, o) => {
+  for (; t <= i; ) {
+    const n = t + Math.floor((i - t) / 2), f = I(e, n, s).offset;
+    if (f === o)
+      return n;
+    f < o ? t = n + 1 : f > o && (i = n - 1);
   }
-  return Math.max(0, low - 1);
-};
-const es = (props, listCache, index, offset) => {
-  const { total } = props;
-  let 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
+  return Math.max(0, t - 1);
+}, O = (e, s, t, i) => {
+  const { total: o } = e;
+  let n = 1;
+  for (; t < o && I(e, t, s).offset < i; )
+    t += n, n *= 2;
+  return S(
+    e,
+    s,
+    Math.floor(t / 2),
+    Math.min(t, o - 1),
+    i
   );
-};
-const getEstimatedTotalSize = ({ total }, { items, estimatedItemSize, lastVisitedIndex }) => {
-  let totalSizeOfMeasuredItems = 0;
-  if (lastVisitedIndex >= total) {
-    lastVisitedIndex = total - 1;
-  }
-  if (lastVisitedIndex >= 0) {
-    const item = items[lastVisitedIndex];
-    totalSizeOfMeasuredItems = item.offset + item.size;
+}, h = ({ total: e }, { items: s, estimatedItemSize: t, lastVisitedIndex: i }) => {
+  let o = 0;
+  if (i >= e && (i = e - 1), i >= 0) {
+    const r = s[i];
+    o = r.offset + r.size;
   }
-  const numUnmeasuredItems = total - lastVisitedIndex - 1;
-  const totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedItemSize;
-  return totalSizeOfMeasuredItems + totalSizeOfUnmeasuredItems;
-};
-const DynamicSizeList = createList({
+  const f = (e - i - 1) * t;
+  return o + f;
+}, R = T({
   name: "ElDynamicSizeList",
-  getItemOffset: (props, index, listCache) => getItemFromCache(props, index, listCache).offset,
-  getItemSize: (_, index, { items }) => items[index].size,
-  getEstimatedTotalSize,
-  getOffset: (props, index, alignment, scrollOffset, listCache) => {
-    const { height, layout, width } = props;
-    const size = isHorizontal(layout) ? width : height;
-    const item = getItemFromCache(props, index, listCache);
-    const estimatedTotalSize = getEstimatedTotalSize(props, listCache);
-    const maxOffset = Math.max(
+  getItemOffset: (e, s, t) => I(e, s, t).offset,
+  getItemSize: (e, s, { items: t }) => t[s].size,
+  getEstimatedTotalSize: h,
+  getOffset: (e, s, t, i, o) => {
+    const { height: n, layout: f, width: r } = e, m = z(f) ? r : n, u = I(e, s, o), d = h(e, o), c = Math.max(
       0,
-      Math.min(estimatedTotalSize - size, item.offset)
-    );
-    const minOffset = Math.max(0, item.offset - size + item.size);
-    if (alignment === SMART_ALIGNMENT) {
-      if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
-        alignment = AUTO_ALIGNMENT;
-      } else {
-        alignment = CENTERED_ALIGNMENT;
-      }
-    }
-    switch (alignment) {
-      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;
-        }
-      }
+      Math.min(d - m, u.offset)
+    ), a = Math.max(0, u.offset - m + u.size);
+    switch (t === L && (i >= a - m && i <= c + m ? t = E : t = M), t) {
+      case A:
+        return c;
+      case l:
+        return a;
+      case M:
+        return Math.round(a + (c - a) / 2);
+      case E:
+      default:
+        return i >= a && i <= c ? i : i < a ? a : c;
     }
   },
-  getStartIndexForOffset: (props, offset, listCache) => findItem(props, listCache, offset),
-  getStopIndexForStartIndex: (props, startIndex, scrollOffset, listCache) => {
-    const { height, total, layout, width } = props;
-    const size = isHorizontal(layout) ? width : height;
-    const item = getItemFromCache(props, startIndex, listCache);
-    const maxOffset = scrollOffset + size;
-    let offset = item.offset + item.size;
-    let stopIndex = startIndex;
-    while (stopIndex < total - 1 && offset < maxOffset) {
-      stopIndex++;
-      offset += getItemFromCache(props, stopIndex, listCache).size;
-    }
-    return stopIndex;
+  getStartIndexForOffset: (e, s, t) => y(e, t, s),
+  getStopIndexForStartIndex: (e, s, t, i) => {
+    const { height: o, total: n, layout: f, width: r } = e, m = z(f) ? r : o, u = I(e, s, i), d = t + m;
+    let c = u.offset + u.size, a = s;
+    for (; a < n - 1 && c < d; )
+      a++, c += I(e, a, i).size;
+    return a;
   },
-  initCache({ estimatedItemSize = DEFAULT_DYNAMIC_LIST_ITEM_SIZE }, instance) {
-    const cache = {
+  initCache({ estimatedItemSize: e = _ }, s) {
+    const t = {
       items: {},
-      estimatedItemSize,
+      estimatedItemSize: e,
       lastVisitedIndex: -1
     };
-    cache.clearCacheAfterIndex = (index, forceUpdate = true) => {
-      cache.lastVisitedIndex = Math.min(cache.lastVisitedIndex, index - 1);
-      instance.exposed?.getItemStyleCache(-1);
-      if (forceUpdate) {
-        instance.proxy?.$forceUpdate();
-      }
-    };
-    return cache;
+    return t.clearCacheAfterIndex = (i, o = !0) => {
+      t.lastVisitedIndex = Math.min(t.lastVisitedIndex, i - 1), s.exposed?.getItemStyleCache(-1), o && s.proxy?.$forceUpdate();
+    }, t;
   },
-  clearCache: false,
-  validateProps: ({ itemSize }) => {
-    if (process.env.NODE_ENV !== "production") {
-      if (typeof itemSize !== "function") {
-        throwError(
-          SCOPE,
-          `
-          itemSize is required as function, but the given value was ${typeof itemSize}
+  clearCache: !1,
+  validateProps: ({ itemSize: e }) => {
+    process.env.NODE_ENV !== "production" && typeof e != "function" && N(
+      x,
+      `
+          itemSize is required as function, but the given value was ${typeof e}
         `
-        );
-      }
-    }
+    );
   }
 });
 export {
-  DynamicSizeList as default
+  R as default
 };

package/es/components/virtual-list/components/fixed-size-grid.js

@@ -1,154 +1,105 @@
-import { isNumber } from "@vft/utils";
+import { isNumber as E } from "@vft/utils";
 import "@vueuse/core";
-import { throwError } from "../../../utils/error.js";
+import { throwError as N } from "../../../utils/error.js";
 import "../../config-provider/hooks/use-global-config.js";
 import "vue";
 import "lodash-es";
-import createGrid from "../builders/build-grid.js";
-import { AUTO_ALIGNMENT, CENTERED_ALIGNMENT, END_ALIGNMENT, START_ALIGNMENT, SMART_ALIGNMENT } from "../defaults.js";
-const SCOPE = "ElFixedSizeGrid";
-const FixedSizeGrid = createGrid({
+import S from "../builders/build-grid.js";
+import { AUTO_ALIGNMENT as M, CENTERED_ALIGNMENT as c, END_ALIGNMENT as x, START_ALIGNMENT as O, SMART_ALIGNMENT as l } from "../defaults.js";
+const p = "ElFixedSizeGrid", T = S({
   name: "ElFixedSizeGrid",
-  getColumnPosition: ({ columnWidth }, index) => [
-    columnWidth,
-    index * columnWidth
+  getColumnPosition: ({ columnWidth: t }, e) => [
+    t,
+    e * t
   ],
-  getRowPosition: ({ rowHeight }, index) => [
-    rowHeight,
-    index * rowHeight
+  getRowPosition: ({ rowHeight: t }, e) => [
+    t,
+    e * t
   ],
-  getEstimatedTotalHeight: ({ totalRow, rowHeight }) => rowHeight * totalRow,
-  getEstimatedTotalWidth: ({ totalColumn, columnWidth }) => columnWidth * totalColumn,
-  getColumnOffset: ({ totalColumn, columnWidth, width }, columnIndex, alignment, scrollLeft, _, scrollBarWidth) => {
-    width = Number(width);
-    const lastColumnOffset = Math.max(
+  getEstimatedTotalHeight: ({ totalRow: t, rowHeight: e }) => e * t,
+  getEstimatedTotalWidth: ({ totalColumn: t, columnWidth: e }) => e * t,
+  getColumnOffset: ({ totalColumn: t, columnWidth: e, width: a }, o, n, s, u, d) => {
+    a = Number(a);
+    const i = Math.max(
       0,
-      totalColumn * columnWidth - width
-    );
-    const maxOffset = Math.min(
-      lastColumnOffset,
-      columnIndex * columnWidth
-    );
-    const minOffset = Math.max(
+      t * e - a
+    ), f = Math.min(
+      i,
+      o * e
+    ), r = Math.max(
       0,
-      columnIndex * columnWidth - width + scrollBarWidth + columnWidth
+      o * e - a + d + e
     );
-    if (alignment === "smart") {
-      if (scrollLeft >= minOffset - width && scrollLeft <= maxOffset + width) {
-        alignment = AUTO_ALIGNMENT;
-      } else {
-        alignment = CENTERED_ALIGNMENT;
-      }
-    }
-    switch (alignment) {
-      case START_ALIGNMENT:
-        return maxOffset;
-      case END_ALIGNMENT:
-        return minOffset;
-      case CENTERED_ALIGNMENT: {
-        const middleOffset = Math.round(
-          minOffset + (maxOffset - minOffset) / 2
+    switch (n === "smart" && (s >= r - a && s <= f + a ? n = M : n = c), n) {
+      case O:
+        return f;
+      case x:
+        return r;
+      case c: {
+        const m = Math.round(
+          r + (f - r) / 2
         );
-        if (middleOffset < Math.ceil(width / 2)) {
-          return 0;
-        } else if (middleOffset > lastColumnOffset + Math.floor(width / 2)) {
-          return lastColumnOffset;
-        } else {
-          return middleOffset;
-        }
+        return m < Math.ceil(a / 2) ? 0 : m > i + Math.floor(a / 2) ? i : m;
       }
-      case AUTO_ALIGNMENT:
+      case M:
       default:
-        if (scrollLeft >= minOffset && scrollLeft <= maxOffset) {
-          return scrollLeft;
-        } else if (minOffset > maxOffset) {
-          return minOffset;
-        } else if (scrollLeft < minOffset) {
-          return minOffset;
-        } else {
-          return maxOffset;
-        }
+        return s >= r && s <= f ? s : r > f || s < r ? r : f;
     }
   },
-  getRowOffset: ({ rowHeight, height, totalRow }, rowIndex, align, scrollTop, _, scrollBarWidth) => {
-    height = Number(height);
-    const lastRowOffset = Math.max(
+  getRowOffset: ({ rowHeight: t, height: e, totalRow: a }, o, n, s, u, d) => {
+    e = Number(e);
+    const i = Math.max(
       0,
-      totalRow * rowHeight - height
-    );
-    const maxOffset = Math.min(lastRowOffset, rowIndex * rowHeight);
-    const minOffset = Math.max(
+      a * t - e
+    ), f = Math.min(i, o * t), r = Math.max(
       0,
-      rowIndex * rowHeight - height + scrollBarWidth + rowHeight
+      o * t - e + d + t
     );
-    if (align === SMART_ALIGNMENT) {
-      if (scrollTop >= minOffset - height && scrollTop <= maxOffset + height) {
-        align = AUTO_ALIGNMENT;
-      } else {
-        align = CENTERED_ALIGNMENT;
-      }
-    }
-    switch (align) {
-      case START_ALIGNMENT:
-        return maxOffset;
-      case END_ALIGNMENT:
-        return minOffset;
-      case CENTERED_ALIGNMENT: {
-        const middleOffset = Math.round(
-          minOffset + (maxOffset - minOffset) / 2
+    switch (n === l && (s >= r - e && s <= f + e ? n = M : n = c), n) {
+      case O:
+        return f;
+      case x:
+        return r;
+      case c: {
+        const m = Math.round(
+          r + (f - r) / 2
         );
-        if (middleOffset < Math.ceil(height / 2)) {
-          return 0;
-        } else if (middleOffset > lastRowOffset + Math.floor(height / 2)) {
-          return lastRowOffset;
-        } else {
-          return middleOffset;
-        }
+        return m < Math.ceil(e / 2) ? 0 : m > i + Math.floor(e / 2) ? i : m;
       }
-      case AUTO_ALIGNMENT:
+      case M:
       default:
-        if (scrollTop >= minOffset && scrollTop <= maxOffset) {
-          return scrollTop;
-        } else if (minOffset > maxOffset) {
-          return minOffset;
-        } else if (scrollTop < minOffset) {
-          return minOffset;
-        } else {
-          return maxOffset;
-        }
+        return s >= r && s <= f ? s : r > f || s < r ? r : f;
     }
   },
-  getColumnStartIndexForOffset: ({ columnWidth, totalColumn }, scrollLeft) => Math.max(
+  getColumnStartIndexForOffset: ({ columnWidth: t, totalColumn: e }, a) => Math.max(
     0,
     Math.min(
-      totalColumn - 1,
-      Math.floor(scrollLeft / columnWidth)
+      e - 1,
+      Math.floor(a / t)
     )
   ),
-  getColumnStopIndexForStartIndex: ({ columnWidth, totalColumn, width }, startIndex, scrollLeft) => {
-    const left = startIndex * columnWidth;
-    const visibleColumnsCount = Math.ceil(
-      (width + scrollLeft - left) / columnWidth
+  getColumnStopIndexForStartIndex: ({ columnWidth: t, totalColumn: e, width: a }, o, n) => {
+    const s = o * t, u = Math.ceil(
+      (a + n - s) / t
     );
     return Math.max(
       0,
-      Math.min(totalColumn - 1, startIndex + visibleColumnsCount - 1)
+      Math.min(e - 1, o + u - 1)
     );
   },
-  getRowStartIndexForOffset: ({ rowHeight, totalRow }, scrollTop) => Math.max(
+  getRowStartIndexForOffset: ({ rowHeight: t, totalRow: e }, a) => Math.max(
     0,
-    Math.min(totalRow - 1, Math.floor(scrollTop / rowHeight))
+    Math.min(e - 1, Math.floor(a / t))
   ),
-  getRowStopIndexForStartIndex: ({ rowHeight, totalRow, height }, startIndex, scrollTop) => {
-    const top = startIndex * rowHeight;
-    const numVisibleRows = Math.ceil(
-      (height + scrollTop - top) / rowHeight
+  getRowStopIndexForStartIndex: ({ rowHeight: t, totalRow: e, height: a }, o, n) => {
+    const s = o * t, u = Math.ceil(
+      (a + n - s) / t
     );
     return Math.max(
       0,
       Math.min(
-        totalRow - 1,
-        startIndex + numVisibleRows - 1
+        e - 1,
+        o + u - 1
         // -1 is because stop index is inclusive
       )
     );
@@ -157,31 +108,25 @@ const FixedSizeGrid = createGrid({
    * Fixed size grid does not need this cache
    * Using any to bypass it, TODO: Using type inference to fix this.
    */
-  initCache: () => void 0,
-  clearCache: true,
-  validateProps: ({ columnWidth, rowHeight }) => {
-    if (process.env.NODE_ENV !== "production") {
-      if (!isNumber(columnWidth)) {
-        throwError(
-          SCOPE,
-          `
+  initCache: () => {
+  },
+  clearCache: !0,
+  validateProps: ({ columnWidth: t, rowHeight: e }) => {
+    process.env.NODE_ENV !== "production" && (E(t) || N(
+      p,
+      `
           "columnWidth" must be passed as number,
-            instead ${typeof columnWidth} was given.
+            instead ${typeof t} was given.
         `
-        );
-      }
-      if (!isNumber(rowHeight)) {
-        throwError(
-          SCOPE,
-          `
+    ), E(e) || N(
+      p,
+      `
           "columnWidth" must be passed as number,
-            instead ${typeof rowHeight} was given.
+            instead ${typeof e} was given.
         `
-        );
-      }
-    }
+    ));
   }
 });
 export {
-  FixedSizeGrid as default
+  T as default
 };

package/es/components/virtual-list/components/fixed-size-list.js

@@ -1,85 +1,57 @@
 import "@vueuse/core";
-import { isString } from "@vft/utils";
-import { throwError } from "../../../utils/error.js";
+import { isString as p } from "@vft/utils";
+import { throwError as N } from "../../../utils/error.js";
 import "../../config-provider/hooks/use-global-config.js";
 import "vue";
 import "lodash-es";
-import createList from "../builders/build-list.js";
-import { isHorizontal } from "../utils.js";
-import { AUTO_ALIGNMENT, CENTERED_ALIGNMENT, END_ALIGNMENT, START_ALIGNMENT, SMART_ALIGNMENT } from "../defaults.js";
-const FixedSizeList = createList({
+import l from "../builders/build-list.js";
+import { isHorizontal as M } from "../utils.js";
+import { AUTO_ALIGNMENT as E, CENTERED_ALIGNMENT as d, END_ALIGNMENT as I, START_ALIGNMENT as T, SMART_ALIGNMENT as x } from "../defaults.js";
+const F = l({
   name: "ElFixedSizeList",
-  getItemOffset: ({ itemSize }, index) => index * itemSize,
-  getItemSize: ({ itemSize }) => itemSize,
-  getEstimatedTotalSize: ({ total, itemSize }) => itemSize * total,
-  getOffset: ({ height, total, itemSize, layout, width }, index, alignment, scrollOffset) => {
-    const size = isHorizontal(layout) ? width : height;
-    if (process.env.NODE_ENV !== "production" && isString(size)) {
-      throwError(
-        "[ElVirtualList]",
-        `
+  getItemOffset: ({ itemSize: t }, e) => e * t,
+  getItemSize: ({ itemSize: t }) => t,
+  getEstimatedTotalSize: ({ total: t, itemSize: e }) => e * t,
+  getOffset: ({ height: t, total: e, itemSize: o, layout: h, width: u }, n, s, i) => {
+    const r = M(h) ? u : t;
+    process.env.NODE_ENV !== "production" && p(r) && N(
+      "[ElVirtualList]",
+      `
         You should set
           width/height
         to number when your layout is
           horizontal/vertical
       `
-      );
-    }
-    const lastItemOffset = Math.max(0, total * itemSize - size);
-    const maxOffset = Math.min(lastItemOffset, index * itemSize);
-    const minOffset = Math.max(0, (index + 1) * itemSize - size);
-    if (alignment === SMART_ALIGNMENT) {
-      if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
-        alignment = AUTO_ALIGNMENT;
-      } else {
-        alignment = CENTERED_ALIGNMENT;
-      }
-    }
-    switch (alignment) {
-      case START_ALIGNMENT: {
-        return maxOffset;
-      }
-      case END_ALIGNMENT: {
-        return minOffset;
-      }
-      case CENTERED_ALIGNMENT: {
-        const middleOffset = Math.round(
-          minOffset + (maxOffset - minOffset) / 2
+    );
+    const m = Math.max(0, e * o - r), f = Math.min(m, n * o), a = Math.max(0, (n + 1) * o - r);
+    switch (s === x && (i >= a - r && i <= f + r ? s = E : s = d), s) {
+      case T:
+        return f;
+      case I:
+        return a;
+      case d: {
+        const c = Math.round(
+          a + (f - a) / 2
         );
-        if (middleOffset < Math.ceil(size / 2)) {
-          return 0;
-        } else if (middleOffset > lastItemOffset + Math.floor(size / 2)) {
-          return lastItemOffset;
-        } else {
-          return middleOffset;
-        }
-      }
-      case AUTO_ALIGNMENT:
-      default: {
-        if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
-          return scrollOffset;
-        } else if (scrollOffset < minOffset) {
-          return minOffset;
-        } else {
-          return maxOffset;
-        }
+        return c < Math.ceil(r / 2) ? 0 : c > m + Math.floor(r / 2) ? m : c;
       }
+      case E:
+      default:
+        return i >= a && i <= f ? i : i < a ? a : f;
     }
   },
-  getStartIndexForOffset: ({ total, itemSize }, offset) => Math.max(0, Math.min(total - 1, Math.floor(offset / itemSize))),
-  getStopIndexForStartIndex: ({ height, total, itemSize, layout, width }, startIndex, scrollOffset) => {
-    const offset = startIndex * itemSize;
-    const size = isHorizontal(layout) ? width : height;
-    const numVisibleItems = Math.ceil(
-      (size + scrollOffset - offset) / itemSize
+  getStartIndexForOffset: ({ total: t, itemSize: e }, o) => Math.max(0, Math.min(t - 1, Math.floor(o / e))),
+  getStopIndexForStartIndex: ({ height: t, total: e, itemSize: o, layout: h, width: u }, n, s) => {
+    const i = n * o, r = M(h) ? u : t, m = Math.ceil(
+      (r + s - i) / o
     );
     return Math.max(
       0,
       Math.min(
-        total - 1,
+        e - 1,
         // because startIndex is inclusive, so in order to prevent array outbound indexing
         // we need to - 1 to prevent outbound behavior
-        startIndex + numVisibleItems - 1
+        n + m - 1
       )
     );
   },
@@ -88,12 +60,11 @@ const FixedSizeList = createList({
    * Using any to bypass it, TODO: Using type inference to fix this.
    */
   initCache() {
-    return void 0;
   },
-  clearCache: true,
+  clearCache: !0,
   validateProps() {
   }
 });
 export {
-  FixedSizeList as default
+  F as default
 };