vft 0.0.375 → 0.0.376

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

@@ -1,289 +1,205 @@
 import "@vueuse/core";
-import { isFunction, isUndefined, isNumber } from "@vft/utils";
-import { throwError } from "../../../utils/error.js";
+import { isFunction as d, isUndefined as g, isNumber as S } from "@vft/utils";
+import { throwError as w } 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 { DEFAULT_DYNAMIC_LIST_ITEM_SIZE, AUTO_ALIGNMENT, CENTERED_ALIGNMENT, END_ALIGNMENT, START_ALIGNMENT, SMART_ALIGNMENT } from "../defaults.js";
-const { max, min, floor } = Math;
-const SCOPE = "ElDynamicSizeGrid";
-const ACCESS_SIZER_KEY_MAP = {
+import G from "../builders/build-grid.js";
+import { DEFAULT_DYNAMIC_LIST_ITEM_SIZE as z, AUTO_ALIGNMENT as A, CENTERED_ALIGNMENT as _, END_ALIGNMENT as x, START_ALIGNMENT as L, SMART_ALIGNMENT as V } from "../defaults.js";
+const { max: I, min: v, floor: O } = Math, T = "ElDynamicSizeGrid", F = {
   column: "columnWidth",
   row: "rowHeight"
-};
-const ACCESS_LAST_VISITED_KEY_MAP = {
+}, E = {
   column: "lastVisitedColumnIndex",
   row: "lastVisitedRowIndex"
-};
-const getItemFromCache = (props, index, gridCache, type) => {
-  const [cachedItems, sizer, lastVisited] = [
-    gridCache[type],
-    props[ACCESS_SIZER_KEY_MAP[type]],
-    gridCache[ACCESS_LAST_VISITED_KEY_MAP[type]]
+}, l = (t, s, e, i) => {
+  const [n, o, f] = [
+    e[i],
+    t[F[i]],
+    e[E[i]]
   ];
-  if (index > lastVisited) {
-    let offset = 0;
-    if (lastVisited >= 0) {
-      const item = cachedItems[lastVisited];
-      offset = item.offset + item.size;
+  if (s > f) {
+    let r = 0;
+    if (f >= 0) {
+      const m = n[f];
+      r = m.offset + m.size;
     }
-    for (let i = lastVisited + 1; i <= index; i++) {
-      const size = sizer(i);
-      cachedItems[i] = {
-        offset,
-        size
-      };
-      offset += size;
-    }
-    gridCache[ACCESS_LAST_VISITED_KEY_MAP[type]] = index;
-  }
-  return cachedItems[index];
-};
-const bs = (props, gridCache, low, high, offset, type) => {
-  while (low <= high) {
-    const mid = low + floor((high - low) / 2);
-    const currentOffset = getItemFromCache(props, mid, gridCache, type).offset;
-    if (currentOffset === offset) {
-      return mid;
-    } else if (currentOffset < offset) {
-      low = mid + 1;
-    } else {
-      high = mid - 1;
+    for (let m = f + 1; m <= s; m++) {
+      const u = o(m);
+      n[m] = {
+        offset: r,
+        size: u
+      }, r += u;
     }
+    e[E[i]] = s;
   }
-  return max(0, low - 1);
-};
-const es = (props, gridCache, idx, offset, type) => {
-  const total = type === "column" ? props.totalColumn : props.totalRow;
-  let exponent = 1;
-  while (idx < total && getItemFromCache(props, idx, gridCache, type).offset < offset) {
-    idx += exponent;
-    exponent *= 2;
+  return n[s];
+}, C = (t, s, e, i, n, o) => {
+  for (; e <= i; ) {
+    const f = e + O((i - e) / 2), r = l(t, f, s, o).offset;
+    if (r === n)
+      return f;
+    r < n ? e = f + 1 : i = f - 1;
   }
-  return bs(
-    props,
-    gridCache,
-    floor(idx / 2),
-    min(idx, total - 1),
-    offset,
-    type
+  return I(0, e - 1);
+}, P = (t, s, e, i, n) => {
+  const o = n === "column" ? t.totalColumn : t.totalRow;
+  let f = 1;
+  for (; e < o && l(t, e, s, n).offset < i; )
+    e += f, f *= 2;
+  return C(
+    t,
+    s,
+    O(e / 2),
+    v(e, o - 1),
+    i,
+    n
   );
-};
-const findItem = (props, gridCache, offset, type) => {
-  const [cache, lastVisitedIndex] = [
-    gridCache[type],
-    gridCache[ACCESS_LAST_VISITED_KEY_MAP[type]]
+}, M = (t, s, e, i) => {
+  const [n, o] = [
+    s[i],
+    s[E[i]]
   ];
-  const lastVisitedItemOffset = lastVisitedIndex > 0 ? cache[lastVisitedIndex].offset : 0;
-  if (lastVisitedItemOffset >= offset) {
-    return bs(props, gridCache, 0, lastVisitedIndex, offset, type);
+  return (o > 0 ? n[o].offset : 0) >= e ? C(t, s, 0, o, e, i) : P(t, s, I(0, o), e, i);
+}, h = ({ totalRow: t }, { estimatedRowHeight: s, lastVisitedRowIndex: e, row: i }) => {
+  let n = 0;
+  if (e >= t && (e = t - 1), e >= 0) {
+    const r = i[e];
+    n = r.offset + r.size;
   }
-  return es(props, gridCache, max(0, lastVisitedIndex), offset, type);
-};
-const getEstimatedTotalHeight = ({ totalRow }, { estimatedRowHeight, lastVisitedRowIndex, row }) => {
-  let sizeOfVisitedRows = 0;
-  if (lastVisitedRowIndex >= totalRow) {
-    lastVisitedRowIndex = totalRow - 1;
+  const f = (t - e - 1) * s;
+  return n + f;
+}, D = ({ totalColumn: t }, { column: s, estimatedColumnWidth: e, lastVisitedColumnIndex: i }) => {
+  let n = 0;
+  if (i > t && (i = t - 1), i >= 0) {
+    const r = s[i];
+    n = r.offset + r.size;
   }
-  if (lastVisitedRowIndex >= 0) {
-    const item = row[lastVisitedRowIndex];
-    sizeOfVisitedRows = item.offset + item.size;
+  const f = (t - i - 1) * e;
+  return n + f;
+}, b = {
+  column: D,
+  row: h
+}, N = (t, s, e, i, n, o, f) => {
+  const [r, m] = [
+    o === "row" ? t.height : t.width,
+    b[o]
+  ], u = l(t, s, n, o), R = m(t, n), a = I(0, v(R - r, u.offset)), c = I(0, u.offset - r + f + u.size);
+  switch (e === V && (i >= c - r && i <= a + r ? e = A : e = _), e) {
+    case L:
+      return a;
+    case x:
+      return c;
+    case _:
+      return Math.round(c + (a - c) / 2);
+    case A:
+    default:
+      return i >= c && i <= a ? i : c > a || i < c ? c : a;
   }
-  const unvisitedItems = totalRow - lastVisitedRowIndex - 1;
-  const sizeOfUnvisitedItems = unvisitedItems * estimatedRowHeight;
-  return sizeOfVisitedRows + sizeOfUnvisitedItems;
-};
-const getEstimatedTotalWidth = ({ totalColumn }, { column, estimatedColumnWidth, lastVisitedColumnIndex }) => {
-  let sizeOfVisitedColumns = 0;
-  if (lastVisitedColumnIndex > totalColumn) {
-    lastVisitedColumnIndex = totalColumn - 1;
-  }
-  if (lastVisitedColumnIndex >= 0) {
-    const item = column[lastVisitedColumnIndex];
-    sizeOfVisitedColumns = item.offset + item.size;
-  }
-  const unvisitedItems = totalColumn - lastVisitedColumnIndex - 1;
-  const sizeOfUnvisitedItems = unvisitedItems * estimatedColumnWidth;
-  return sizeOfVisitedColumns + sizeOfUnvisitedItems;
-};
-const ACCESS_ESTIMATED_SIZE_KEY_MAP = {
-  column: getEstimatedTotalWidth,
-  row: getEstimatedTotalHeight
-};
-const getOffset = (props, index, alignment, scrollOffset, cache, type, scrollBarWidth) => {
-  const [size, estimatedSizeAssociates] = [
-    type === "row" ? props.height : props.width,
-    ACCESS_ESTIMATED_SIZE_KEY_MAP[type]
-  ];
-  const item = getItemFromCache(props, index, cache, type);
-  const estimatedSize = estimatedSizeAssociates(props, cache);
-  const maxOffset = max(0, min(estimatedSize - size, item.offset));
-  const minOffset = max(0, item.offset - size + scrollBarWidth + 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 (minOffset > maxOffset) {
-        return minOffset;
-      } else if (scrollOffset < minOffset) {
-        return minOffset;
-      } else {
-        return maxOffset;
-      }
-    }
-  }
-};
-const DynamicSizeGrid = createGrid({
+}, k = G({
   name: "ElDynamicSizeGrid",
-  getColumnPosition: (props, idx, cache) => {
-    const item = getItemFromCache(props, idx, cache, "column");
-    return [item.size, item.offset];
+  getColumnPosition: (t, s, e) => {
+    const i = l(t, s, e, "column");
+    return [i.size, i.offset];
   },
-  getRowPosition: (props, idx, cache) => {
-    const item = getItemFromCache(props, idx, cache, "row");
-    return [item.size, item.offset];
+  getRowPosition: (t, s, e) => {
+    const i = l(t, s, e, "row");
+    return [i.size, i.offset];
   },
-  getColumnOffset: (props, columnIndex, alignment, scrollLeft, cache, scrollBarWidth) => getOffset(
-    props,
-    columnIndex,
-    alignment,
-    scrollLeft,
-    cache,
+  getColumnOffset: (t, s, e, i, n, o) => N(
+    t,
+    s,
+    e,
+    i,
+    n,
     "column",
-    scrollBarWidth
+    o
   ),
-  getRowOffset: (props, rowIndex, alignment, scrollTop, cache, scrollBarWidth) => getOffset(
-    props,
-    rowIndex,
-    alignment,
-    scrollTop,
-    cache,
+  getRowOffset: (t, s, e, i, n, o) => N(
+    t,
+    s,
+    e,
+    i,
+    n,
     "row",
-    scrollBarWidth
+    o
   ),
-  getColumnStartIndexForOffset: (props, scrollLeft, cache) => findItem(props, cache, scrollLeft, "column"),
-  getColumnStopIndexForStartIndex: (props, startIndex, scrollLeft, cache) => {
-    const item = getItemFromCache(props, startIndex, cache, "column");
-    const maxOffset = scrollLeft + props.width;
-    let offset = item.offset + item.size;
-    let stopIndex = startIndex;
-    while (stopIndex < props.totalColumn - 1 && offset < maxOffset) {
-      stopIndex++;
-      offset += getItemFromCache(props, startIndex, cache, "column").size;
-    }
-    return stopIndex;
+  getColumnStartIndexForOffset: (t, s, e) => M(t, e, s, "column"),
+  getColumnStopIndexForStartIndex: (t, s, e, i) => {
+    const n = l(t, s, i, "column"), o = e + t.width;
+    let f = n.offset + n.size, r = s;
+    for (; r < t.totalColumn - 1 && f < o; )
+      r++, f += l(t, s, i, "column").size;
+    return r;
   },
-  getEstimatedTotalHeight,
-  getEstimatedTotalWidth,
-  getRowStartIndexForOffset: (props, scrollTop, cache) => findItem(props, cache, scrollTop, "row"),
-  getRowStopIndexForStartIndex: (props, startIndex, scrollTop, cache) => {
-    const { totalRow, height } = props;
-    const item = getItemFromCache(props, startIndex, cache, "row");
-    const maxOffset = scrollTop + height;
-    let offset = item.size + item.offset;
-    let stopIndex = startIndex;
-    while (stopIndex < totalRow - 1 && offset < maxOffset) {
-      stopIndex++;
-      offset += getItemFromCache(props, stopIndex, cache, "row").size;
-    }
-    return stopIndex;
+  getEstimatedTotalHeight: h,
+  getEstimatedTotalWidth: D,
+  getRowStartIndexForOffset: (t, s, e) => M(t, e, s, "row"),
+  getRowStopIndexForStartIndex: (t, s, e, i) => {
+    const { totalRow: n, height: o } = t, f = l(t, s, i, "row"), r = e + o;
+    let m = f.size + f.offset, u = s;
+    for (; u < n - 1 && m < r; )
+      u++, m += l(t, u, i, "row").size;
+    return u;
   },
-  injectToInstance: (instance, cache) => {
-    const resetAfter = ({ columnIndex, rowIndex }, forceUpdate) => {
-      forceUpdate = isUndefined(forceUpdate) ? true : forceUpdate;
-      if (isNumber(columnIndex)) {
-        cache.value.lastVisitedColumnIndex = Math.min(
-          cache.value.lastVisitedColumnIndex,
-          columnIndex - 1
-        );
-      }
-      if (isNumber(rowIndex)) {
-        cache.value.lastVisitedRowIndex = Math.min(
-          cache.value.lastVisitedRowIndex,
-          rowIndex - 1
-        );
-      }
-      instance.exposed?.getItemStyleCache.value(-1, null, null);
-      if (forceUpdate) instance.proxy?.$forceUpdate();
-    };
-    const resetAfterColumnIndex = (columnIndex, forceUpdate) => {
-      resetAfter(
+  injectToInstance: (t, s) => {
+    const e = ({ columnIndex: o, rowIndex: f }, r) => {
+      r = g(r) ? !0 : r, S(o) && (s.value.lastVisitedColumnIndex = Math.min(
+        s.value.lastVisitedColumnIndex,
+        o - 1
+      )), S(f) && (s.value.lastVisitedRowIndex = Math.min(
+        s.value.lastVisitedRowIndex,
+        f - 1
+      )), t.exposed?.getItemStyleCache.value(-1, null, null), r && t.proxy?.$forceUpdate();
+    }, i = (o, f) => {
+      e(
         {
-          columnIndex
+          columnIndex: o
         },
-        forceUpdate
+        f
       );
-    };
-    const resetAfterRowIndex = (rowIndex, forceUpdate) => {
-      resetAfter(
+    }, n = (o, f) => {
+      e(
         {
-          rowIndex
+          rowIndex: o
         },
-        forceUpdate
+        f
       );
     };
-    Object.assign(instance.proxy, {
-      resetAfterColumnIndex,
-      resetAfterRowIndex,
-      resetAfter
+    Object.assign(t.proxy, {
+      resetAfterColumnIndex: i,
+      resetAfterRowIndex: n,
+      resetAfter: e
     });
   },
   initCache: ({
-    estimatedColumnWidth = DEFAULT_DYNAMIC_LIST_ITEM_SIZE,
-    estimatedRowHeight = DEFAULT_DYNAMIC_LIST_ITEM_SIZE
-  }) => {
-    const cache = {
-      column: {},
-      estimatedColumnWidth,
-      estimatedRowHeight,
-      lastVisitedColumnIndex: -1,
-      lastVisitedRowIndex: -1,
-      row: {}
-    };
-    return cache;
-  },
-  clearCache: false,
-  validateProps: ({ columnWidth, rowHeight }) => {
-    if (process.env.NODE_ENV !== "production") {
-      if (!isFunction(columnWidth)) {
-        throwError(
-          SCOPE,
-          `
+    estimatedColumnWidth: t = z,
+    estimatedRowHeight: s = z
+  }) => ({
+    column: {},
+    estimatedColumnWidth: t,
+    estimatedRowHeight: s,
+    lastVisitedColumnIndex: -1,
+    lastVisitedRowIndex: -1,
+    row: {}
+  }),
+  clearCache: !1,
+  validateProps: ({ columnWidth: t, rowHeight: s }) => {
+    process.env.NODE_ENV !== "production" && (d(t) || w(
+      T,
+      `
           "columnWidth" must be passed as function,
-            instead ${typeof columnWidth} was given.
+            instead ${typeof t} was given.
         `
-        );
-      }
-      if (!isFunction(rowHeight)) {
-        throwError(
-          SCOPE,
-          `
+    ), d(s) || w(
+      T,
+      `
           "rowHeight" must be passed as function,
-            instead ${typeof rowHeight} was given.
+            instead ${typeof s} was given.
         `
-        );
-      }
-    }
+    ));
   }
 });
 export {
-  DynamicSizeGrid as default
+  k as default
 };