@revolist/revogrid 4.22.1 → 4.23.1

package/dist/collection/services/scroll.dimension.helpers.js

@@ -0,0 +1,83 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+const FALLBACK_MAX_SCROLL_SIZE = 16000000;
+const SCROLL_SIZE_GUARD = 1000000;
+let detectedMaxScrollSize;
+export function getMaxScrollSize(doc = typeof document === 'undefined' ? undefined : document) {
+    if (typeof detectedMaxScrollSize === 'number') {
+        return detectedMaxScrollSize;
+    }
+    const body = doc === null || doc === void 0 ? void 0 : doc.body;
+    if (body) {
+        const ownerDocument = body.ownerDocument;
+        const element = ownerDocument.createElement('div');
+        element.style.cssText = [
+            'height:1px',
+            'left:-10000px',
+            'overflow:scroll',
+            'position:absolute',
+            'top:-10000px',
+            'visibility:hidden',
+            'width:1px',
+        ].join(';');
+        const content = ownerDocument.createElement('div');
+        content.style.height = `${FALLBACK_MAX_SCROLL_SIZE * 4}px`;
+        element.appendChild(content);
+        body.appendChild(element);
+        detectedMaxScrollSize = Math.max(0, Math.min(element.scrollHeight, FALLBACK_MAX_SCROLL_SIZE * 4) - SCROLL_SIZE_GUARD);
+        element.remove();
+        if (detectedMaxScrollSize > SCROLL_SIZE_GUARD) {
+            return detectedMaxScrollSize;
+        }
+        detectedMaxScrollSize = FALLBACK_MAX_SCROLL_SIZE;
+        return detectedMaxScrollSize;
+    }
+    return FALLBACK_MAX_SCROLL_SIZE;
+}
+export function getScrollDimension({ contentSize, clientSize, virtualSize = 0, maxScrollSize = getMaxScrollSize(), }) {
+    const safeContentSize = Math.max(0, maxScrollSize - SCROLL_SIZE_GUARD);
+    const size = Math.max(0, contentSize);
+    const client = Math.max(0, clientSize);
+    const viewport = Math.max(0, virtualSize || client);
+    const logicalScrollSize = Math.max(0, size - viewport);
+    const maxPhysicalScrollSize = Math.max(0, safeContentSize - client);
+    const physicalScrollSize = Math.min(logicalScrollSize, maxPhysicalScrollSize);
+    const physicalContentSize = client + physicalScrollSize;
+    const isCompressed = logicalScrollSize > physicalScrollSize && physicalScrollSize > 0;
+    const clampLogical = (coordinate) => Math.min(Math.max(0, coordinate || 0), logicalScrollSize);
+    const clampPhysical = (coordinate) => Math.min(Math.max(0, coordinate || 0), physicalScrollSize);
+    const toLogicalCoordinate = (coordinate) => {
+        if (!logicalScrollSize || !physicalScrollSize) {
+            return 0;
+        }
+        if (!isCompressed) {
+            return clampLogical(coordinate);
+        }
+        return clampLogical((clampPhysical(coordinate) / physicalScrollSize) * logicalScrollSize);
+    };
+    const toPhysicalCoordinate = (coordinate) => {
+        if (!logicalScrollSize || !physicalScrollSize) {
+            return 0;
+        }
+        if (!isCompressed) {
+            return clampPhysical(coordinate);
+        }
+        return clampPhysical((clampLogical(coordinate) / logicalScrollSize) * physicalScrollSize);
+    };
+    return {
+        contentSize: size,
+        clientSize: client,
+        viewportSize: viewport,
+        physicalContentSize,
+        logicalScrollSize,
+        physicalScrollSize,
+        isCompressed,
+        toLogicalCoordinate,
+        toPhysicalCoordinate,
+        getRenderOffset(coordinate) {
+            const logical = clampLogical(coordinate);
+            return logical - toPhysicalCoordinate(logical);
+        },
+    };
+}

package/dist/collection/services/selection.store.connector.js

@@ -46,13 +46,11 @@ export class SelectionStoreConnector {
         return (_a = this.focusedStore) === null || _a === void 0 ? void 0 : _a.entity.store.get('range');
     }
     registerColumn(x, type) {
+        this.updateColumnTypeMapping(x, type);
         if (this.columnStores[x]) {
             return this.columnStores[x];
         }
         this.columnStores[x] = new SelectionStore();
-        // build cross-linking type to position
-        this.storesByType[type] = x;
-        this.storesXToType[x] = type;
         return this.columnStores[x];
     }
     registerRow(y, type) {
@@ -194,7 +192,10 @@ export class SelectionStoreConnector {
         const nextItem = nextCell(focus, lastCell);
         let nextStore;
         if (nextItem) {
-            Object.entries(nextItem).forEach(([type, nextItemCoord]) => {
+            Object.keys(nextItem).forEach((t) => {
+                var _a;
+                const type = t;
+                const nextItemCoord = (_a = nextItem[type]) !== null && _a !== void 0 ? _a : 0;
                 let stores;
                 switch (type) {
                     case 'x':
@@ -270,4 +271,29 @@ export class SelectionStoreConnector {
         }
         return stores;
     }
+    /**
+     * Keep column viewport positions and types in sync across pin/unpin rerenders.
+     * Regression case: when a selected rgCol cell was pinned left, colPinStart
+     * could take over x=0 and render the stale rgCol focus store in the pinned area.
+     */
+    updateColumnTypeMapping(x, type) {
+        const previousType = this.storesXToType[x];
+        const previousX = this.storesByType[type];
+        let shouldClearFocus = false;
+        this.storesByType[type] = x;
+        this.storesXToType[x] = type;
+        if (previousType && previousType !== type) {
+            shouldClearFocus = true;
+            if (this.storesByType[previousType] === x) {
+                delete this.storesByType[previousType];
+            }
+        }
+        if (typeof previousX === 'number' && previousX !== x && this.storesXToType[previousX] === type) {
+            delete this.storesXToType[previousX];
+            shouldClearFocus = true;
+        }
+        if (shouldClearFocus) {
+            this.clearAll();
+        }
+    }
 }

package/dist/collection/store/dimension/dimension.recalculate.plugin.js

@@ -1,6 +1,21 @@
 /*!
  * Built by Revolist OU ❤️
  */
+function calculateRealSize({ count, originItemSize, sizes, }) {
+    const safeCount = Math.max(0, count);
+    let realSize = safeCount * originItemSize;
+    for (let index in sizes) {
+        const itemIndex = Number(index);
+        if (!Number.isInteger(itemIndex) ||
+            itemIndex < 0 ||
+            itemIndex >= safeCount ||
+            String(itemIndex) !== index) {
+            continue;
+        }
+        realSize += sizes[index] - originItemSize;
+    }
+    return realSize;
+}
 /**
  * Plugin which recalculates realSize on changes of sizes, originItemSize and count
  */
@@ -13,20 +28,18 @@ export const recalculateRealSizePlugin = (storeService) => {
          * Reacts on changes of count, sizes and originItemSize
          */
         set(k) {
-            var _a;
             switch (k) {
                 case 'count':
                 case 'sizes':
                 case 'originItemSize': {
                     // recalculate realSize
-                    let realSize = 0;
-                    const count = storeService.store.get('count');
-                    const sizes = storeService.store.get('sizes');
-                    const originItemSize = storeService.store.get('originItemSize');
-                    for (let i = 0; i < count; i++) {
-                        realSize += (_a = sizes[i]) !== null && _a !== void 0 ? _a : originItemSize;
-                    }
-                    storeService.setStore({ realSize });
+                    storeService.setStore({
+                        realSize: calculateRealSize({
+                            count: storeService.store.get('count'),
+                            sizes: storeService.store.get('sizes'),
+                            originItemSize: storeService.store.get('originItemSize'),
+                        }),
+                    });
                     break;
                 }
             }

package/dist/collection/store/dimension/dimension.store.js

@@ -31,7 +31,9 @@ function initialState() {
         // size which all items can take
         realSize: 0,
         // initial item size if it wasn't changed
-        originItemSize: 0
+        originItemSize: 0,
+        // logical-to-physical render offset used when scroll space is compressed
+        renderOffset: 0
     });
 }
 export class DimensionStore {
@@ -63,7 +65,7 @@ export class DimensionStore {
         setStore(this.store, data);
     }
     drop() {
-        setStore(this.store, initialBase());
+        setStore(this.store, Object.assign(Object.assign({}, initialBase()), { renderOffset: 0 }));
     }
     /**
      * Set custom dimension sizes and overwrite old

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

@@ -2,6 +2,15 @@
  * Built by Revolist OU ❤️
  */
 import { getItemByPosition } from "../dimension/dimension.helpers";
+export function getViewportMaxCoordinate(dimension, viewportSize, frameOffset = 1) {
+    if (!viewportSize || dimension.realSize <= viewportSize) {
+        return 0;
+    }
+    return Math.max(0, dimension.realSize - viewportSize - dimension.originItemSize * frameOffset);
+}
+export function clampViewportCoordinate(coordinate, dimension, viewportSize, frameOffset = 1) {
+    return Math.min(Math.max(0, coordinate), getViewportMaxCoordinate(dimension, viewportSize, frameOffset));
+}
 /**
  * Update items based on new scroll position
  * If viewport wasn't changed fully simple recombination of positions

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

@@ -1,7 +1,7 @@
 /*!
  * Built by Revolist OU ❤️
  */
-import { addMissingItems, getFirstItem, getLastItem, getUpdatedItemsByPosition, isActiveRange, setItemSizes, updateMissingAndRange, isActiveRangeOutsideLastItem, } from "./viewport.helpers";
+import { addMissingItems, getFirstItem, getLastItem, getUpdatedItemsByPosition, clampViewportCoordinate, getViewportMaxCoordinate, isActiveRange, setItemSizes, updateMissingAndRange, isActiveRangeOutsideLastItem, } from "./viewport.helpers";
 import { createStore } from "@stencil/store";
 import { setStore } from "../../utils";
 /**
@@ -22,6 +22,8 @@ function initialState() {
         realCount: 0,
         // size of viewport in px
         clientSize: 0,
+        // logical-to-physical render offset used when scroll space is compressed
+        renderOffset: 0,
     };
 }
 /**
@@ -57,21 +59,8 @@ export class ViewportStore {
         const outsize = singleOffsetInPx * 2;
         // math virtual size is based on visible area + 2 items outside of visible area
         const virtualSize = viewportSize + outsize;
-        // 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 > viewportSize) {
-            // max coordinate is real size minus virtual/rendered space
-            maxCoordinate = dimension.realSize - viewportSize - singleOffsetInPx;
-        }
-        let pos = position;
-        // limit position to max and min coordinates
-        if (pos < 0) {
-            pos = 0;
-        }
-        else if (pos > maxCoordinate) {
-            pos = maxCoordinate;
-        }
+        const maxCoordinate = getViewportMaxCoordinate(dimension, viewportSize, frameOffset);
+        let pos = clampViewportCoordinate(position, dimension, viewportSize, frameOffset);
         // store last coordinate for further restore on redraw
         this.lastCoordinate = pos;
         // actual position is less than first item start based on offset

package/dist/collection/utils/store.utils.js

@@ -8,7 +8,7 @@
  * @param data - The data to set on the store.
  */
 export function setStore(store, data) {
-    Object.entries(data).forEach(([key, value]) => {
-        store.set(key, value);
-    });
+    for (const key of Object.keys(data)) {
+        store.set(key, data[key]);
+    }
 }

package/dist/{revo-grid/cell-renderer-CALsEsnh.js → esm/cell-renderer-BtN-NGCk.js}

@@ -2,12 +2,18 @@
  * Built by Revolist OU ❤️
  */
 import { h, f as Build } from './index-Chp_81rd.js';
-import { y as DATA_ROW, G as DRAG_ICON_CLASS, I as DRAGGABLE_CLASS } from './dimension.helpers-DmIvjIa7.js';
-import { l as GROUP_EXPAND_BTN, m as GROUP_EXPAND_EVENT, G as GROUP_DEPTH, h as GROUP_EXPANDED, P as PSEUDO_GROUP_ITEM, O as isRowDragService, B as getCellDataParsed } from './column.service-CCvAi5l4.js';
+import { n as DATA_ROW, w as DRAG_ICON_CLASS, x as DRAGGABLE_CLASS } from './dimension.helpers-CGKwSvw6.js';
+import { l as GROUP_EXPAND_BTN, m as GROUP_EXPAND_EVENT, G as GROUP_DEPTH, h as GROUP_EXPANDED, P as PSEUDO_GROUP_ITEM, O as isRowDragService, B as getCellDataParsed } from './column.service-CC_SD8W3.js';
 
+/**
+ * Renders sorting direction and optional additive sorting rank.
+ */
 const SortingSign = ({ column }) => {
     var _a;
-    return h("i", { class: (_a = column === null || column === void 0 ? void 0 : column.order) !== null && _a !== void 0 ? _a : 'sort-off' });
+    const indicatorAttrs = { class: 'sort-indicator' };
+    const iconAttrs = { class: (_a = column === null || column === void 0 ? void 0 : column.order) !== null && _a !== void 0 ? _a : 'sort-off' };
+    const orderIndexAttrs = { class: 'sort-order-index' };
+    return (h("span", Object.assign({}, indicatorAttrs), h("i", Object.assign({}, iconAttrs)), (column === null || column === void 0 ? void 0 : column.sortIndex) ? (h("sup", Object.assign({}, orderIndexAttrs), column.sortIndex)) : null));
 };
 
 const PADDING_DEPTH = 10;