@revolist/revogrid 3.1.6 → 3.2.4

package/dist/{collection/utils/utils.js → revo-grid/utils-2c3b3857.js}

@@ -1,6 +1,9 @@
+/*!
+ * Built by Revolist
+ */
 /* Generate range on size
  */
-export function range(size, startAt = 0) {
+function range(size, startAt = 0) {
   const res = [];
   const end = startAt + size;
   for (let i = startAt; i < end; i++) {
@@ -9,7 +12,7 @@ export function range(size, startAt = 0) {
   return res;
 }
 /* Find index position in array */
-export function findPositionInArray(el, compareFn) {
+function findPositionInArray(el, compareFn) {
   return (function (arr) {
     let m = 0;
     let n = arr.length - 1;
@@ -29,7 +32,7 @@ export function findPositionInArray(el, compareFn) {
     return -m - 1;
   })(this);
 }
-export function pushSorted(arr, el, fn) {
+function pushSorted(arr, el, fn) {
   arr.splice(findPositionInArray.bind(arr)(el, fn), 0, el);
   return arr;
 }
@@ -37,7 +40,7 @@ export function pushSorted(arr, el, fn) {
 function simpleCompare(el1, el2) {
   return el1 < el2;
 }
-export function mergeSortedArray(arr1, arr2, compareFn = simpleCompare) {
+function mergeSortedArray(arr1, arr2, compareFn = simpleCompare) {
   const merged = [];
   let index1 = 0;
   let index2 = 0;
@@ -58,7 +61,7 @@ export function mergeSortedArray(arr1, arr2, compareFn = simpleCompare) {
   return merged;
 }
 /* Calculate system scrollbar width */
-export function getScrollbarWidth(doc) {
+function getScrollbarWidth(doc) {
   // Creating invisible container
   const outer = doc.createElement('div');
   const styles = outer.style;
@@ -87,18 +90,20 @@ export function getScrollbarWidth(doc) {
  *
  * ~~ return value does the equivalent of Math.floor but faster.
  */
-export function scaleValue(value, from, to) {
+function scaleValue(value, from, to) {
   return ((to[1] - to[0]) * (value - from[0])) / (from[1] - from[0]) + to[0];
 }
-export async function timeout(delay = 0) {
+async function timeout(delay = 0) {
   await new Promise((r) => {
     setTimeout(() => r(), delay);
   });
 }
-export function applyMixins(derivedCtor, constructors) {
+function applyMixins(derivedCtor, constructors) {
   constructors.forEach(baseCtor => {
     Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
       Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || Object.create(null));
     });
   });
 }
+
+export { getScrollbarWidth as g, mergeSortedArray as m, scaleValue as s, timeout as t };

package/dist/revo-grid/viewport.helpers-49d3f031.js

@@ -0,0 +1,16 @@
+/*!
+ * Built by Revolist
+ */
+const HEADER_SLOT = 'header';
+const FOOTER_SLOT = 'footer';
+const CONTENT_SLOT = 'content';
+const DATA_SLOT = 'data';
+/** Receive last visible in viewport by required type */
+function getLastCell(data, rowType) {
+  return {
+    x: data.viewports[data.colType].store.get('realCount'),
+    y: data.viewports[rowType].store.get('realCount'),
+  };
+}
+
+export { CONTENT_SLOT as C, DATA_SLOT as D, FOOTER_SLOT as F, HEADER_SLOT as H, getLastCell as g };

package/dist/{collection/store/viewPort/viewport.helpers.js → revo-grid/viewport.store-ffaaab6d.js}

@@ -1,10 +1,15 @@
-import { getItemByPosition } from '../dimension/dimension.helpers';
+/*!
+ * Built by Revolist
+ */
+import { c as createStore, d as setStore } from './data.store-3263fff9.js';
+import { a as getItemByPosition } from './dimension.helpers-a7944fc4.js';
+
 /**
  * Update items based on new scroll position
  * If viewport wasn't changed fully simple recombination of positions
  * Otherwise rebuild viewport items
  */
-export function getUpdatedItemsByPosition(pos, items, realCount, virtualSize, dimension) {
+function getUpdatedItemsByPosition(pos, items, realCount, virtualSize, dimension) {
   const activeItem = getItemByPosition(dimension, pos);
   const firstItem = getFirstItem(items);
   let toUpdate;
@@ -45,7 +50,7 @@ export function getUpdatedItemsByPosition(pos, items, realCount, virtualSize, di
   }
   return toUpdate;
 }
-export function updateMissingAndRange(items, missing, range) {
+function updateMissingAndRange(items, missing, range) {
   items.splice(range.end + 1, 0, ...missing);
   // update range if start larger after recombination
   if (range.start >= range.end && !(range.start === range.end && range.start === 0)) {
@@ -54,7 +59,7 @@ export function updateMissingAndRange(items, missing, range) {
   range.end += missing.length;
 }
 // if partial replacement add items if revo-viewport has some space left
-export function addMissingItems(firstItem, realCount, virtualSize, existingCollection, dimension) {
+function addMissingItems(firstItem, realCount, virtualSize, existingCollection, dimension) {
   const lastItem = getLastItem(existingCollection);
   const items = getItems({
     sizes: dimension.sizes,
@@ -67,7 +72,7 @@ export function addMissingItems(firstItem, realCount, virtualSize, existingColle
   return items;
 }
 // get revo-viewport items parameters, caching position and calculating items count in revo-viewport
-export function getItems(opt, currentSize = 0) {
+function getItems(opt, currentSize = 0) {
   const items = [];
   let index = opt.startIndex;
   let size = currentSize;
@@ -88,7 +93,7 @@ export function getItems(opt, currentSize = 0) {
  * Do batch items recombination
  * If items not overlapped with existing viewport returns null
  */
-export function recombineByOffset(offset, data) {
+function recombineByOffset(offset, data) {
   const newItems = [...data.items];
   const itemsCount = newItems.length;
   let newRange = {
@@ -169,12 +174,133 @@ function getItemSize(index, sizes, origSize = 0) {
   }
   return origSize;
 }
-export function isActiveRange(pos, item) {
+function isActiveRange(pos, item) {
   return item && pos >= item.start && pos <= item.end;
 }
-export function getFirstItem(s) {
+function getFirstItem(s) {
   return s.items[s.start];
 }
-export function getLastItem(s) {
+function getLastItem(s) {
   return s.items[s.end];
 }
+
+/**
+ * Store is responsible for visible
+ * Viewport information for each dimension
+ * Redraw items during scrolling
+ */
+function initialState() {
+  return {
+    // virtual item information per rendered item
+    items: [],
+    // virtual dom item order to render
+    start: 0,
+    end: 0,
+    // size of viewport in px
+    virtualSize: 0,
+    // total number of items
+    realCount: 0,
+    // last coordinate for store position restore
+    lastCoordinate: 0,
+  };
+}
+class ViewportStore {
+  constructor() {
+    this.store = createStore(initialState());
+    this.store.onChange('realCount', () => this.clear());
+  }
+  /** Render viewport based on coordinate, this is main method for draw */
+  setViewPortCoordinate(position, dimension) {
+    let virtualSize = this.store.get('virtualSize');
+    // no visible data to calculate
+    if (!virtualSize) {
+      return;
+    }
+    const frameOffset = dimension.frameOffset;
+    const outsize = frameOffset * 2 * dimension.originItemSize;
+    virtualSize += outsize;
+    let maxCoordinate = virtualSize;
+    if (dimension.realSize > virtualSize) {
+      maxCoordinate = dimension.realSize - virtualSize;
+    }
+    let toUpdate = {
+      lastCoordinate: position,
+    };
+    let pos = position;
+    pos -= frameOffset * dimension.originItemSize;
+    pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate;
+    const firstItem = getFirstItem(this.getItems());
+    const lastItem = getLastItem(this.getItems());
+    // left position changed
+    if (!isActiveRange(pos, firstItem)) {
+      toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, this.getItems(), this.store.get('realCount'), virtualSize, dimension));
+      setStore(this.store, Object.assign({}, toUpdate));
+      // right position changed
+    }
+    else if (firstItem && this.store.get('virtualSize') + pos > (lastItem === null || lastItem === void 0 ? void 0 : lastItem.end)) {
+      // check is any item missing for full fill content
+      const missing = addMissingItems(firstItem, this.store.get('realCount'), virtualSize + pos - firstItem.start, this.getItems(), dimension);
+      if (missing.length) {
+        const items = [...this.store.get('items')];
+        const range = {
+          start: this.store.get('start'),
+          end: this.store.get('end'),
+        };
+        updateMissingAndRange(items, missing, range);
+        toUpdate = Object.assign(Object.assign(Object.assign({}, toUpdate), { items: [...items] }), range);
+        setStore(this.store, Object.assign({}, toUpdate));
+      }
+    }
+  }
+  /** Update viewport sizes */
+  setViewPortDimension(sizes) {
+    const items = this.store.get('items');
+    const count = items.length;
+    // viewport not inited
+    if (!count) {
+      return;
+    }
+    let changedCoordinate = 0;
+    let i = 0;
+    let start = this.store.get('start');
+    // loop through array from initial item after recombination
+    while (i < count) {
+      const item = items[start];
+      // change pos if size change present before
+      if (changedCoordinate) {
+        item.start += changedCoordinate;
+        item.end += changedCoordinate;
+      }
+      // change size
+      const size = sizes[item.itemIndex];
+      if (size) {
+        const changedSize = size - item.size;
+        changedCoordinate += changedSize;
+        item.size = size;
+        item.end = item.start + size;
+      }
+      // loop by start index
+      start++;
+      i++;
+      if (start === count) {
+        start = 0;
+      }
+    }
+    setStore(this.store, { items: [...items] });
+  }
+  getItems() {
+    return {
+      items: this.store.get('items'),
+      start: this.store.get('start'),
+      end: this.store.get('end'),
+    };
+  }
+  setViewport(data) {
+    setStore(this.store, data);
+  }
+  clear() {
+    this.store.set('items', []);
+  }
+}
+
+export { ViewportStore as V };

package/dist/types/components/revo-grid/revo-grid.d.ts

@@ -87,6 +87,12 @@ export declare class RevoGridComponent {
    * Can be filter collection
    */
   filter: boolean | ColumnFilterConfig;
+  /**
+   * Enables column move plugin
+   * Can be boolean
+   * Can be filter collection
+   */
+  canMoveColumns: boolean;
   /**
    * Trimmed rows
    * Functionality which allows to hide rows from main data set