@revolist/revogrid 3.6.1 → 3.6.2

package/custom-element/revogr-row-headers2.js

@@ -28,10 +28,7 @@ items, realCount, virtualSize, dimension) {
       toUpdate = recombineByOffset(Math.abs(changedOffsetStart), Object.assign(Object.assign({ positiveDirection: changedOffsetStart > -1 }, dimension), items));
     }
   }
-  // virtual size can differ based on scroll position if some big items are present
-  // scroll can be in the middle of item and virtual size will be larger
-  // so we need to exclude this part from virtual size hence it's already passed
-  const maxSizeVirtualSize = Math.min(virtualSize + (activeItem.end - activeItem.start), dimension.realSize);
+  const maxSizeVirtualSize = getMaxVirtualSize(virtualSize, dimension.realSize, activeItem);
   // if partial recombination add items if revo-viewport has some space left
   if (toUpdate) {
     const extra = addMissingItems(activeItem, realCount, maxSizeVirtualSize, toUpdate, dimension);
@@ -58,6 +55,12 @@ items, realCount, virtualSize, dimension) {
   }
   return toUpdate;
 }
+// virtual size can differ based on scroll position if some big items are present
+// scroll can be in the middle of item and virtual size will be larger
+// so we need to exclude this part from virtual size hence it's already passed
+function getMaxVirtualSize(virtualSize, realSize, activeItem) {
+  return Math.min(virtualSize + (activeItem.end - activeItem.start), realSize);
+}
 function updateMissingAndRange(items, missing, range) {
   items.splice(range.end + 1, 0, ...missing);
   // update range if start larger after recombination
@@ -189,8 +192,24 @@ function getItemSize(index, sizes, origSize = 0) {
   }
   return origSize;
 }
-function isActiveRange(pos, item) {
-  return item && pos >= item.start && pos <= item.end;
+/**
+ * Verify if position is in range of the PositionItem, start and end are included
+ */
+function isActiveRange(pos, realSize, first, last) {
+  if (!first || !last) {
+    return false;
+  }
+  // if position is in range of first item
+  // or position is after first item and last item is the last item in real size
+  return pos >= first.start && pos <= first.end ||
+    pos > first.end && last.end === realSize;
+}
+function isActiveRangeOutsideLastItem(pos, virtualSize, firstItem, lastItem) {
+  // if no first item, means no items in viewport
+  if (!firstItem) {
+    return false;
+  }
+  return virtualSize + pos > (lastItem === null || lastItem === void 0 ? void 0 : lastItem.end);
 }
 function getFirstItem(s) {
   return s.items[s.start];
@@ -267,31 +286,37 @@ class ViewportStore {
       return;
     }
     const frameOffset = dimension.frameOffset;
-    const outsize = frameOffset * 2 * dimension.originItemSize;
+    const singleOffsetInPx = dimension.originItemSize * frameOffset;
+    // add offset to virtual size from both sides
+    const outsize = singleOffsetInPx * 2;
     virtualSize += outsize;
-    let maxCoordinate = virtualSize;
-    // if real size is bigger than virtual size, then the end will be real size decreased by virtual size
-    // but sometimes the real size slightly bigger than virtual size, so we need to check it and fallback max coordinate to virtual size
+    // expected no scroll if real size less than virtual size, position is 0
+    let maxCoordinate = 0;
+    // if there is nodes outside of viewport, max coordinate has to be adjusted
     if (dimension.realSize > virtualSize) {
-      maxCoordinate = Math.max(dimension.realSize - virtualSize, virtualSize);
+      // max coordinate is real size minus virtual/rendered space
+      maxCoordinate = dimension.realSize - virtualSize;
     }
     let toUpdate = {
       lastCoordinate: position,
     };
     let pos = position;
-    pos -= frameOffset * dimension.originItemSize;
-    pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate; // todo: check if maxCoordinate can be removed
-    const firstItem = getFirstItem(this.getItems());
-    const lastItem = getLastItem(this.getItems());
+    pos -= singleOffsetInPx;
+    pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate;
+    const allItems = this.getItems();
+    const firstItem = getFirstItem(allItems);
+    const lastItem = getLastItem(allItems);
     // left position changed
-    if (!isActiveRange(pos, firstItem)) {
-      toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, this.getItems(), this.store.get('realCount'), virtualSize, dimension));
+    // verify if new position is in range of previously rendered first item
+    if (!isActiveRange(pos, dimension.realSize, firstItem, lastItem)) {
+      toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, allItems, this.store.get('realCount'), virtualSize, dimension));
       this.setViewport(Object.assign({}, toUpdate));
       // right position changed
     }
-    else if (firstItem && this.store.get('virtualSize') + pos > (lastItem === null || lastItem === void 0 ? void 0 : lastItem.end)) {
+    else if (isActiveRangeOutsideLastItem(pos, virtualSize, firstItem, lastItem)) {
       // check is any item missing for full fill content
-      const missing = addMissingItems(firstItem, this.store.get('realCount'), virtualSize + pos - firstItem.start, this.getItems(), dimension);
+      const missing = addMissingItems(firstItem, this.store.get('realCount'), virtualSize + pos - firstItem.start, allItems, dimension);
+      // update missing items
       if (missing.length) {
         const items = [...this.store.get('items')];
         const range = {

package/dist/cjs/revo-grid_11.cjs.entry.js

@@ -4525,10 +4525,7 @@ items, realCount, virtualSize, dimension) {
       toUpdate = recombineByOffset(Math.abs(changedOffsetStart), Object.assign(Object.assign({ positiveDirection: changedOffsetStart > -1 }, dimension), items));
     }
   }
-  // virtual size can differ based on scroll position if some big items are present
-  // scroll can be in the middle of item and virtual size will be larger
-  // so we need to exclude this part from virtual size hence it's already passed
-  const maxSizeVirtualSize = Math.min(virtualSize + (activeItem.end - activeItem.start), dimension.realSize);
+  const maxSizeVirtualSize = getMaxVirtualSize(virtualSize, dimension.realSize, activeItem);
   // if partial recombination add items if revo-viewport has some space left
   if (toUpdate) {
     const extra = addMissingItems(activeItem, realCount, maxSizeVirtualSize, toUpdate, dimension);
@@ -4555,6 +4552,12 @@ items, realCount, virtualSize, dimension) {
   }
   return toUpdate;
 }
+// virtual size can differ based on scroll position if some big items are present
+// scroll can be in the middle of item and virtual size will be larger
+// so we need to exclude this part from virtual size hence it's already passed
+function getMaxVirtualSize(virtualSize, realSize, activeItem) {
+  return Math.min(virtualSize + (activeItem.end - activeItem.start), realSize);
+}
 function updateMissingAndRange(items, missing, range) {
   items.splice(range.end + 1, 0, ...missing);
   // update range if start larger after recombination
@@ -4686,8 +4689,24 @@ function getItemSize(index, sizes, origSize = 0) {
   }
   return origSize;
 }
-function isActiveRange(pos, item) {
-  return item && pos >= item.start && pos <= item.end;
+/**
+ * Verify if position is in range of the PositionItem, start and end are included
+ */
+function isActiveRange(pos, realSize, first, last) {
+  if (!first || !last) {
+    return false;
+  }
+  // if position is in range of first item
+  // or position is after first item and last item is the last item in real size
+  return pos >= first.start && pos <= first.end ||
+    pos > first.end && last.end === realSize;
+}
+function isActiveRangeOutsideLastItem(pos, virtualSize, firstItem, lastItem) {
+  // if no first item, means no items in viewport
+  if (!firstItem) {
+    return false;
+  }
+  return virtualSize + pos > (lastItem === null || lastItem === void 0 ? void 0 : lastItem.end);
 }
 function getFirstItem(s) {
   return s.items[s.start];
@@ -4764,31 +4783,37 @@ class ViewportStore {
       return;
     }
     const frameOffset = dimension.frameOffset;
-    const outsize = frameOffset * 2 * dimension.originItemSize;
+    const singleOffsetInPx = dimension.originItemSize * frameOffset;
+    // add offset to virtual size from both sides
+    const outsize = singleOffsetInPx * 2;
     virtualSize += outsize;
-    let maxCoordinate = virtualSize;
-    // if real size is bigger than virtual size, then the end will be real size decreased by virtual size
-    // but sometimes the real size slightly bigger than virtual size, so we need to check it and fallback max coordinate to virtual size
+    // expected no scroll if real size less than virtual size, position is 0
+    let maxCoordinate = 0;
+    // if there is nodes outside of viewport, max coordinate has to be adjusted
     if (dimension.realSize > virtualSize) {
-      maxCoordinate = Math.max(dimension.realSize - virtualSize, virtualSize);
+      // max coordinate is real size minus virtual/rendered space
+      maxCoordinate = dimension.realSize - virtualSize;
     }
     let toUpdate = {
       lastCoordinate: position,
     };
     let pos = position;
-    pos -= frameOffset * dimension.originItemSize;
-    pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate; // todo: check if maxCoordinate can be removed
-    const firstItem = getFirstItem(this.getItems());
-    const lastItem = getLastItem(this.getItems());
+    pos -= singleOffsetInPx;
+    pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate;
+    const allItems = this.getItems();
+    const firstItem = getFirstItem(allItems);
+    const lastItem = getLastItem(allItems);
     // left position changed
-    if (!isActiveRange(pos, firstItem)) {
-      toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, this.getItems(), this.store.get('realCount'), virtualSize, dimension));
+    // verify if new position is in range of previously rendered first item
+    if (!isActiveRange(pos, dimension.realSize, firstItem, lastItem)) {
+      toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, allItems, this.store.get('realCount'), virtualSize, dimension));
       this.setViewport(Object.assign({}, toUpdate));
       // right position changed
     }
-    else if (firstItem && this.store.get('virtualSize') + pos > (lastItem === null || lastItem === void 0 ? void 0 : lastItem.end)) {
+    else if (isActiveRangeOutsideLastItem(pos, virtualSize, firstItem, lastItem)) {
       // check is any item missing for full fill content
-      const missing = addMissingItems(firstItem, this.store.get('realCount'), virtualSize + pos - firstItem.start, this.getItems(), dimension);
+      const missing = addMissingItems(firstItem, this.store.get('realCount'), virtualSize + pos - firstItem.start, allItems, dimension);
+      // update missing items
       if (missing.length) {
         const items = [...this.store.get('items')];
         const range = {

package/dist/collection/store/viewPort/viewport.helpers.js

@@ -21,10 +21,7 @@ items, realCount, virtualSize, dimension) {
       toUpdate = recombineByOffset(Math.abs(changedOffsetStart), Object.assign(Object.assign({ positiveDirection: changedOffsetStart > -1 }, dimension), items));
     }
   }
-  // virtual size can differ based on scroll position if some big items are present
-  // scroll can be in the middle of item and virtual size will be larger
-  // so we need to exclude this part from virtual size hence it's already passed
-  const maxSizeVirtualSize = Math.min(virtualSize + (activeItem.end - activeItem.start), dimension.realSize);
+  const maxSizeVirtualSize = getMaxVirtualSize(virtualSize, dimension.realSize, activeItem);
   // if partial recombination add items if revo-viewport has some space left
   if (toUpdate) {
     const extra = addMissingItems(activeItem, realCount, maxSizeVirtualSize, toUpdate, dimension);
@@ -51,6 +48,12 @@ items, realCount, virtualSize, dimension) {
   }
   return toUpdate;
 }
+// virtual size can differ based on scroll position if some big items are present
+// scroll can be in the middle of item and virtual size will be larger
+// so we need to exclude this part from virtual size hence it's already passed
+function getMaxVirtualSize(virtualSize, realSize, activeItem) {
+  return Math.min(virtualSize + (activeItem.end - activeItem.start), realSize);
+}
 export function updateMissingAndRange(items, missing, range) {
   items.splice(range.end + 1, 0, ...missing);
   // update range if start larger after recombination
@@ -182,8 +185,24 @@ function getItemSize(index, sizes, origSize = 0) {
   }
   return origSize;
 }
-export function isActiveRange(pos, item) {
-  return item && pos >= item.start && pos <= item.end;
+/**
+ * Verify if position is in range of the PositionItem, start and end are included
+ */
+export function isActiveRange(pos, realSize, first, last) {
+  if (!first || !last) {
+    return false;
+  }
+  // if position is in range of first item
+  // or position is after first item and last item is the last item in real size
+  return pos >= first.start && pos <= first.end ||
+    pos > first.end && last.end === realSize;
+}
+export function isActiveRangeOutsideLastItem(pos, virtualSize, firstItem, lastItem) {
+  // if no first item, means no items in viewport
+  if (!firstItem) {
+    return false;
+  }
+  return virtualSize + pos > (lastItem === null || lastItem === void 0 ? void 0 : lastItem.end);
 }
 export function getFirstItem(s) {
   return s.items[s.start];

package/dist/collection/store/viewPort/viewport.store.js

@@ -7,7 +7,7 @@
  * Redraw items during scrolling
  */
 import { createStore } from '@stencil/store';
-import { addMissingItems, getFirstItem, getLastItem, getUpdatedItemsByPosition, isActiveRange, setItemSizes, updateMissingAndRange } from './viewport.helpers';
+import { addMissingItems, getFirstItem, getLastItem, getUpdatedItemsByPosition, isActiveRange, isActiveRangeOutsideLastItem, setItemSizes, updateMissingAndRange } from './viewport.helpers';
 import { setStore } from '../../utils/store.utils';
 function initialState() {
   return {
@@ -37,31 +37,37 @@ export default class ViewportStore {
       return;
     }
     const frameOffset = dimension.frameOffset;
-    const outsize = frameOffset * 2 * dimension.originItemSize;
+    const singleOffsetInPx = dimension.originItemSize * frameOffset;
+    // add offset to virtual size from both sides
+    const outsize = singleOffsetInPx * 2;
     virtualSize += outsize;
-    let maxCoordinate = virtualSize;
-    // if real size is bigger than virtual size, then the end will be real size decreased by virtual size
-    // but sometimes the real size slightly bigger than virtual size, so we need to check it and fallback max coordinate to virtual size
+    // expected no scroll if real size less than virtual size, position is 0
+    let maxCoordinate = 0;
+    // if there is nodes outside of viewport, max coordinate has to be adjusted
     if (dimension.realSize > virtualSize) {
-      maxCoordinate = Math.max(dimension.realSize - virtualSize, virtualSize);
+      // max coordinate is real size minus virtual/rendered space
+      maxCoordinate = dimension.realSize - virtualSize;
     }
     let toUpdate = {
       lastCoordinate: position,
     };
     let pos = position;
-    pos -= frameOffset * dimension.originItemSize;
-    pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate; // todo: check if maxCoordinate can be removed
-    const firstItem = getFirstItem(this.getItems());
-    const lastItem = getLastItem(this.getItems());
+    pos -= singleOffsetInPx;
+    pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate;
+    const allItems = this.getItems();
+    const firstItem = getFirstItem(allItems);
+    const lastItem = getLastItem(allItems);
     // left position changed
-    if (!isActiveRange(pos, firstItem)) {
-      toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, this.getItems(), this.store.get('realCount'), virtualSize, dimension));
+    // verify if new position is in range of previously rendered first item
+    if (!isActiveRange(pos, dimension.realSize, firstItem, lastItem)) {
+      toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, allItems, this.store.get('realCount'), virtualSize, dimension));
       this.setViewport(Object.assign({}, toUpdate));
       // right position changed
     }
-    else if (firstItem && this.store.get('virtualSize') + pos > (lastItem === null || lastItem === void 0 ? void 0 : lastItem.end)) {
+    else if (isActiveRangeOutsideLastItem(pos, virtualSize, firstItem, lastItem)) {
       // check is any item missing for full fill content
-      const missing = addMissingItems(firstItem, this.store.get('realCount'), virtualSize + pos - firstItem.start, this.getItems(), dimension);
+      const missing = addMissingItems(firstItem, this.store.get('realCount'), virtualSize + pos - firstItem.start, allItems, dimension);
+      // update missing items
       if (missing.length) {
         const items = [...this.store.get('items')];
         const range = {

package/dist/collection/utilsExternal/generate-data.js

@@ -67,9 +67,15 @@ export function generateFakeDataObject(config = {}) {
         prop: rgCol,
         filter:"myFilterType",
         sortable: true,
-        size: 200,
+        size: 140,
         cellCompare: (rgCol % 2) == 0 ? naturalSort : undefined
       };
+      
+      if (rgCol == 0) {
+        columns[rgCol].size = 433;
+      } else if (rgCol == 10) {
+        columns[rgCol].size = 200;
+      }
 
       // apply config
       if (colPinStart.indexOf(j) > -1) {

package/dist/esm/revo-grid_11.entry.js

@@ -4521,10 +4521,7 @@ items, realCount, virtualSize, dimension) {
       toUpdate = recombineByOffset(Math.abs(changedOffsetStart), Object.assign(Object.assign({ positiveDirection: changedOffsetStart > -1 }, dimension), items));
     }
   }
-  // virtual size can differ based on scroll position if some big items are present
-  // scroll can be in the middle of item and virtual size will be larger
-  // so we need to exclude this part from virtual size hence it's already passed
-  const maxSizeVirtualSize = Math.min(virtualSize + (activeItem.end - activeItem.start), dimension.realSize);
+  const maxSizeVirtualSize = getMaxVirtualSize(virtualSize, dimension.realSize, activeItem);
   // if partial recombination add items if revo-viewport has some space left
   if (toUpdate) {
     const extra = addMissingItems(activeItem, realCount, maxSizeVirtualSize, toUpdate, dimension);
@@ -4551,6 +4548,12 @@ items, realCount, virtualSize, dimension) {
   }
   return toUpdate;
 }
+// virtual size can differ based on scroll position if some big items are present
+// scroll can be in the middle of item and virtual size will be larger
+// so we need to exclude this part from virtual size hence it's already passed
+function getMaxVirtualSize(virtualSize, realSize, activeItem) {
+  return Math.min(virtualSize + (activeItem.end - activeItem.start), realSize);
+}
 function updateMissingAndRange(items, missing, range) {
   items.splice(range.end + 1, 0, ...missing);
   // update range if start larger after recombination
@@ -4682,8 +4685,24 @@ function getItemSize(index, sizes, origSize = 0) {
   }
   return origSize;
 }
-function isActiveRange(pos, item) {
-  return item && pos >= item.start && pos <= item.end;
+/**
+ * Verify if position is in range of the PositionItem, start and end are included
+ */
+function isActiveRange(pos, realSize, first, last) {
+  if (!first || !last) {
+    return false;
+  }
+  // if position is in range of first item
+  // or position is after first item and last item is the last item in real size
+  return pos >= first.start && pos <= first.end ||
+    pos > first.end && last.end === realSize;
+}
+function isActiveRangeOutsideLastItem(pos, virtualSize, firstItem, lastItem) {
+  // if no first item, means no items in viewport
+  if (!firstItem) {
+    return false;
+  }
+  return virtualSize + pos > (lastItem === null || lastItem === void 0 ? void 0 : lastItem.end);
 }
 function getFirstItem(s) {
   return s.items[s.start];
@@ -4760,31 +4779,37 @@ class ViewportStore {
       return;
     }
     const frameOffset = dimension.frameOffset;
-    const outsize = frameOffset * 2 * dimension.originItemSize;
+    const singleOffsetInPx = dimension.originItemSize * frameOffset;
+    // add offset to virtual size from both sides
+    const outsize = singleOffsetInPx * 2;
     virtualSize += outsize;
-    let maxCoordinate = virtualSize;
-    // if real size is bigger than virtual size, then the end will be real size decreased by virtual size
-    // but sometimes the real size slightly bigger than virtual size, so we need to check it and fallback max coordinate to virtual size
+    // expected no scroll if real size less than virtual size, position is 0
+    let maxCoordinate = 0;
+    // if there is nodes outside of viewport, max coordinate has to be adjusted
     if (dimension.realSize > virtualSize) {
-      maxCoordinate = Math.max(dimension.realSize - virtualSize, virtualSize);
+      // max coordinate is real size minus virtual/rendered space
+      maxCoordinate = dimension.realSize - virtualSize;
     }
     let toUpdate = {
       lastCoordinate: position,
     };
     let pos = position;
-    pos -= frameOffset * dimension.originItemSize;
-    pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate; // todo: check if maxCoordinate can be removed
-    const firstItem = getFirstItem(this.getItems());
-    const lastItem = getLastItem(this.getItems());
+    pos -= singleOffsetInPx;
+    pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate;
+    const allItems = this.getItems();
+    const firstItem = getFirstItem(allItems);
+    const lastItem = getLastItem(allItems);
     // left position changed
-    if (!isActiveRange(pos, firstItem)) {
-      toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, this.getItems(), this.store.get('realCount'), virtualSize, dimension));
+    // verify if new position is in range of previously rendered first item
+    if (!isActiveRange(pos, dimension.realSize, firstItem, lastItem)) {
+      toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, allItems, this.store.get('realCount'), virtualSize, dimension));
       this.setViewport(Object.assign({}, toUpdate));
       // right position changed
     }
-    else if (firstItem && this.store.get('virtualSize') + pos > (lastItem === null || lastItem === void 0 ? void 0 : lastItem.end)) {
+    else if (isActiveRangeOutsideLastItem(pos, virtualSize, firstItem, lastItem)) {
       // check is any item missing for full fill content
-      const missing = addMissingItems(firstItem, this.store.get('realCount'), virtualSize + pos - firstItem.start, this.getItems(), dimension);
+      const missing = addMissingItems(firstItem, this.store.get('realCount'), virtualSize + pos - firstItem.start, allItems, dimension);
+      // update missing items
       if (missing.length) {
         const items = [...this.store.get('items')];
         const range = {