handsontable 18.0.0 → 18.1.0-rc7

package/plugins/columnSorting/utils.mjs

@@ -2,7 +2,7 @@ import { isObject } from '../../helpers/object.mjs';
 import { isRightClick } from '../../helpers/dom/event.mjs';
 import { eventTargetEl, isBottomMostColumnHeader } from '../../helpers/dom/element.mjs';
 import { isEmpty } from '../../helpers/mixed.mjs';
-import { parseToLocalDate, parseToLocalTime } from '../../helpers/dateTime.mjs';
+import { parseToLocalDate, parseToLocalTime, parseToLocalDateTime } from '../../helpers/dateTime.mjs';
 import { DO_NOT_SWAP, FIRST_BEFORE_SECOND, FIRST_AFTER_SECOND } from './sortService/index.mjs';
 import { warn } from '../../helpers/console.mjs';
 import { toSingleLine } from '../../helpers/templateLiteralTag.mjs';
@@ -91,12 +91,26 @@ export const HEADER_SPAN_CLASS = 'colHeader';
     return targetHeader !== null && isBottomMostColumnHeader(targetHeader);
 }
 /**
- * Creates intl-date sorting compare function.
+ * Creates a date/time sorting compare function around the given parse function.
+ *
+ * Parse results are memoized per sort run as epoch milliseconds (or `null` for unparsable input).
+ * The compare function is created once per sort run, so each distinct cell value pays the
+ * regex-and-`Date` parsing once instead of on every comparison (~2*log(n) times per row in a sort).
  *
+ * @param {Function} parseValue Converts a raw cell value to a `Date` or `null` when unparsable.
  * @param {string} sortOrder Sort order (`asc` for ascending, `desc` for descending).
  * @param {object} columnPluginSettings Plugin settings for the column.
  * @returns {Function} The compare function.
- */ export function createIntlDateCompareFunction(sortOrder, columnPluginSettings) {
+ */ function createParsingCompareFunction(parseValue, sortOrder, columnPluginSettings) {
+    const parseCache = new Map();
+    const getParsedTime = (value)=>{
+        let parsedTime = parseCache.get(value);
+        if (parsedTime === undefined) {
+            parsedTime = parseValue(value)?.getTime() ?? null;
+            parseCache.set(value, parsedTime);
+        }
+        return parsedTime;
+    };
     return function(value, nextValue) {
         const { sortEmptyCells } = columnPluginSettings;
         if (value === nextValue) {
@@ -119,23 +133,32 @@ export const HEADER_SPAN_CLASS = 'colHeader';
             }
             return FIRST_BEFORE_SECOND;
         }
-        const firstDate = parseToLocalDate(value);
-        const nextDate = parseToLocalDate(nextValue);
-        if (firstDate === null) {
+        const firstTime = getParsedTime(value);
+        const nextTime = getParsedTime(nextValue);
+        if (firstTime === null) {
             return FIRST_AFTER_SECOND;
         }
-        if (nextDate === null) {
+        if (nextTime === null) {
             return FIRST_BEFORE_SECOND;
         }
-        if (nextDate > firstDate) {
+        if (nextTime > firstTime) {
             return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND;
         }
-        if (nextDate < firstDate) {
+        if (nextTime < firstTime) {
             return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND;
         }
         return DO_NOT_SWAP;
     };
 }
+/**
+ * Creates intl-date sorting compare function.
+ *
+ * @param {string} sortOrder Sort order (`asc` for ascending, `desc` for descending).
+ * @param {object} columnPluginSettings Plugin settings for the column.
+ * @returns {Function} The compare function.
+ */ export function createIntlDateCompareFunction(sortOrder, columnPluginSettings) {
+    return createParsingCompareFunction(parseToLocalDate, sortOrder, columnPluginSettings);
+}
 /**
  * Creates intl-time sorting compare function.
  *
@@ -143,44 +166,16 @@ export const HEADER_SPAN_CLASS = 'colHeader';
  * @param {object} columnPluginSettings Plugin settings for the column.
  * @returns {Function} The compare function.
  */ export function createIntlTimeCompareFunction(sortOrder, columnPluginSettings) {
-    return function(value, nextValue) {
-        const { sortEmptyCells } = columnPluginSettings;
-        if (value === nextValue) {
-            return DO_NOT_SWAP;
-        }
-        if (isEmpty(value)) {
-            if (isEmpty(nextValue)) {
-                return DO_NOT_SWAP;
-            }
-            // Just fist value is empty and `sortEmptyCells` option was set
-            if (sortEmptyCells) {
-                return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND;
-            }
-            return FIRST_AFTER_SECOND;
-        }
-        if (isEmpty(nextValue)) {
-            // Just second value is empty and `sortEmptyCells` option was set
-            if (sortEmptyCells) {
-                return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND;
-            }
-            return FIRST_BEFORE_SECOND;
-        }
-        const firstDate = parseToLocalTime(value);
-        const nextDate = parseToLocalTime(nextValue);
-        if (firstDate === null) {
-            return FIRST_AFTER_SECOND;
-        }
-        if (nextDate === null) {
-            return FIRST_BEFORE_SECOND;
-        }
-        if (nextDate > firstDate) {
-            return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND;
-        }
-        if (nextDate < firstDate) {
-            return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND;
-        }
-        return DO_NOT_SWAP;
-    };
+    return createParsingCompareFunction(parseToLocalTime, sortOrder, columnPluginSettings);
+}
+/**
+ * Creates a date-time sorting compare function.
+ *
+ * @param {string} sortOrder Sort order (`asc` for ascending, `desc` for descending).
+ * @param {object} columnPluginSettings Plugin settings for the column.
+ * @returns {Function} The compare function.
+ */ export function createDateTimeCompareFunction(sortOrder, columnPluginSettings) {
+    return createParsingCompareFunction(parseToLocalDateTime, sortOrder, columnPluginSettings);
 }
 /**
  * Warn users about problems when using `columnSorting` and `multiColumnSorting` plugins simultaneously.

package/plugins/columnSummary/columnSummary.js

@@ -376,11 +376,15 @@ class ColumnSummary extends _base.BasePlugin {
    */ getCellValue(row, col) {
         const visualRowIndex = this.hot.toVisualRow(row);
         let cellValue = visualRowIndex !== null ? this.hot.getDataAtCell(visualRowIndex, col) : this.hot.getSourceDataAtCell(row, col);
-        let cellClassName = '';
-        if (visualRowIndex !== null) {
-            cellClassName = this.hot.getCellMeta(visualRowIndex, col).className || '';
-        }
-        if (cellClassName.indexOf('columnSummaryResult') > -1) {
+        // A trimmed row has no visual coordinates, so its cell meta - and with it the
+        // `columnSummaryResult` class - cannot be read. Fall back to the endpoint destinations, or a
+        // hidden summary row is summed as plain data and inflates every summary covering it.
+        //
+        // The two tests are deliberately exclusive, not OR-ed: a *visible* destination cell still holds
+        // the user's own value on the first calculation pass, before any result was written, and that
+        // value counts towards the summary. Three long-standing specs pin that behavior.
+        const isSummaryResult = visualRowIndex !== null ? (this.hot.getCellMetaTransient(visualRowIndex, col).className || '').indexOf('columnSummaryResult') > -1 : this.endpoints.isSummaryDestination(row, col);
+        if (isSummaryResult) {
             return null;
         }
         if (this.endpoints.currentEndpoint.forceNumeric) {

package/plugins/columnSummary/columnSummary.mjs

@@ -468,11 +468,15 @@ var /**
    */ getCellValue(row, col) {
         const visualRowIndex = this.hot.toVisualRow(row);
         let cellValue = visualRowIndex !== null ? this.hot.getDataAtCell(visualRowIndex, col) : this.hot.getSourceDataAtCell(row, col);
-        let cellClassName = '';
-        if (visualRowIndex !== null) {
-            cellClassName = this.hot.getCellMeta(visualRowIndex, col).className || '';
-        }
-        if (cellClassName.indexOf('columnSummaryResult') > -1) {
+        // A trimmed row has no visual coordinates, so its cell meta - and with it the
+        // `columnSummaryResult` class - cannot be read. Fall back to the endpoint destinations, or a
+        // hidden summary row is summed as plain data and inflates every summary covering it.
+        //
+        // The two tests are deliberately exclusive, not OR-ed: a *visible* destination cell still holds
+        // the user's own value on the first calculation pass, before any result was written, and that
+        // value counts towards the summary. Three long-standing specs pin that behavior.
+        const isSummaryResult = visualRowIndex !== null ? (this.hot.getCellMetaTransient(visualRowIndex, col).className || '').indexOf('columnSummaryResult') > -1 : this.endpoints.isSummaryDestination(row, col);
+        if (isSummaryResult) {
             return null;
         }
         if (this.endpoints.currentEndpoint.forceNumeric) {

package/plugins/columnSummary/endpoints.d.ts

@@ -1,5 +1,16 @@
 import type { HotInstance } from '../../core/types';
 import type { ColumnSummary } from './columnSummary';
+/**
+ * `HotInstance` augmented with the internal `_setCellMetaDeclarative` method. The method exists on the
+ * Core runtime object but is intentionally NOT part of the public `HotInstance` type, so it is not
+ * exposed to third-party code (it is an implementation detail of how built-in plugins apply
+ * configuration-derived cell meta that must survive the viewport meta eviction but reset on
+ * `updateSettings`, without firing the public `setCellMeta` hooks). ColumnSummary is an internal
+ * consumer and reaches it through this local type.
+ */
+type HotInstanceInternal = HotInstance & {
+    _setCellMetaDeclarative(row: number, column: number, key: string, value: unknown): void;
+};
 export interface EndpointConfig {
     ranges?: number[][];
     reversedRowCoords?: boolean;
@@ -24,16 +35,18 @@ export interface EndpointConfig {
  * @class Endpoints
  */
 declare class Endpoints {
+    #private;
     /**
      * The main plugin instance.
      */
     plugin: ColumnSummary;
     /**
-     * Handsontable instance.
+     * Handsontable instance. Typed as `HotInstanceInternal` so this internal consumer can call the
+     * non-public `_setCellMetaDeclarative` method (see the type's note).
      *
      * @type {object}
      */
-    hot: HotInstance;
+    hot: HotInstanceInternal;
     /**
      * Array of declared plugin endpoints (calculation destination points).
      *
@@ -85,12 +98,66 @@ declare class Endpoints {
      * @returns {object}
      */
     getEndpoint(index: number): EndpointConfig;
+    /**
+     * Returns the number of physical rows the dataset holds, ignoring trimming.
+     *
+     * Endpoint destination rows and calculation ranges are physical indexes, so they must never be
+     * compared against `countRows()` - that counts only the *visible* rows and shrinks whenever a
+     * plugin trims rows (NestedRows collapsing a group, TrimRows, the Filters plugin).
+     *
+     * @returns {number}
+     */
+    countPhysicalRows(): number;
+    /**
+     * Returns the number of rows an endpoint may address, that is the physical row count capped by
+     * `maxRows`. Used for the settings defaults that need a row count rather than a bounds check.
+     *
+     * `maxRows` is normalized the same way `DataMap#getLength` does it: `0` or less means zero rows,
+     * anything falsy means no cap.
+     *
+     * @returns {number}
+     */
+    countAddressableRows(): number;
+    /**
+     * Checks whether an endpoint points outside the table.
+     *
+     * A *trimmed* destination row is not out of bounds - the row exists, it is only hidden - so it is
+     * deliberately not reported here. A row that is visible but sits past `maxRows` is out of bounds,
+     * because the grid renders no cell for it.
+     *
+     * @param {object} endpoint Contains the endpoint information.
+     * @param {number} [rowOffset=0] Row offset to apply before the check.
+     * @param {number} [colOffset=0] Column offset to apply before the check.
+     * @returns {boolean}
+     */
+    isEndpointOutOfBounds(endpoint: EndpointConfig, rowOffset?: number, colOffset?: number): boolean;
     /**
      * Get an array with all the endpoints.
      *
      * @returns {Array}
      */
     getAllEndpoints(): EndpointConfig[];
+    /**
+     * Records the destinations of the endpoints a refresh pass is about to calculate.
+     *
+     * The resolved endpoints are passed in rather than read through `getAllEndpoints()`, which would
+     * re-invoke a settings function and could describe a different layout than the pass is working on.
+     *
+     * @param {object[]} endpoints The endpoints the current pass will calculate.
+     */
+    cacheSummaryDestinations(endpoints: EndpointConfig[]): void;
+    /**
+     * Checks whether a physical cell holds the result of an endpoint.
+     *
+     * `getCellValue` normally recognizes a result by its `columnSummaryResult` class, but cell meta is
+     * addressed by visual coordinates, so a trimmed row has no readable class. Without this check a
+     * hidden summary row is summed as if it were plain data and inflates every summary covering it.
+     *
+     * @param {number} physicalRow Physical row index.
+     * @param {number} column Column index.
+     * @returns {boolean}
+     */
+    isSummaryDestination(physicalRow: number, column: number): boolean;
     /**
      * Used to fill the blanks in the endpoint data provided by a settings function.
      *

package/plugins/columnSummary/endpoints.js

@@ -11,6 +11,51 @@ Object.defineProperty(exports, "default", {
 const _array = require("../../helpers/array");
 const _console = require("../../helpers/console");
 const _utils = require("./utils");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var /**
+   * Destination columns keyed by physical destination row, built once per refresh pass. Used to
+   * keep summary results out of other summaries when their row is trimmed and the
+   * `columnSummaryResult` class is unreachable.
+   */ _summaryDestinations = /*#__PURE__*/ new WeakMap();
 /**
  * Class used to make all endpoint-related operations.
  *
@@ -35,6 +80,51 @@ const _utils = require("./utils");
         return this.endpoints[index];
     }
     /**
+   * Returns the number of physical rows the dataset holds, ignoring trimming.
+   *
+   * Endpoint destination rows and calculation ranges are physical indexes, so they must never be
+   * compared against `countRows()` - that counts only the *visible* rows and shrinks whenever a
+   * plugin trims rows (NestedRows collapsing a group, TrimRows, the Filters plugin).
+   *
+   * @returns {number}
+   */ countPhysicalRows() {
+        return this.hot.rowIndexMapper.getNumberOfIndexes();
+    }
+    /**
+   * Returns the number of rows an endpoint may address, that is the physical row count capped by
+   * `maxRows`. Used for the settings defaults that need a row count rather than a bounds check.
+   *
+   * `maxRows` is normalized the same way `DataMap#getLength` does it: `0` or less means zero rows,
+   * anything falsy means no cap.
+   *
+   * @returns {number}
+   */ countAddressableRows() {
+        const maxRows = this.hot.getSettings().maxRows;
+        let cap;
+        if ((maxRows ?? 0) < 0 || maxRows === 0) {
+            cap = 0;
+        } else {
+            cap = maxRows || Infinity;
+        }
+        return Math.min(this.countPhysicalRows(), cap);
+    }
+    /**
+   * Checks whether an endpoint points outside the table.
+   *
+   * A *trimmed* destination row is not out of bounds - the row exists, it is only hidden - so it is
+   * deliberately not reported here. A row that is visible but sits past `maxRows` is out of bounds,
+   * because the grid renders no cell for it.
+   *
+   * @param {object} endpoint Contains the endpoint information.
+   * @param {number} [rowOffset=0] Row offset to apply before the check.
+   * @param {number} [colOffset=0] Column offset to apply before the check.
+   * @returns {boolean}
+   */ isEndpointOutOfBounds(endpoint, rowOffset = 0, colOffset = 0) {
+        const destinationRow = endpoint.destinationRow + rowOffset;
+        const destinationVisualRow = this.hot.toVisualRow(destinationRow);
+        return destinationRow >= this.countPhysicalRows() || endpoint.destinationColumn + colOffset >= this.hot.countCols() || destinationVisualRow !== null && destinationVisualRow >= this.hot.countRows();
+    }
+    /**
    * Get an array with all the endpoints.
    *
    * @returns {Array}
@@ -45,6 +135,40 @@ const _utils = require("./utils");
         return this.endpoints;
     }
     /**
+   * Records the destinations of the endpoints a refresh pass is about to calculate.
+   *
+   * The resolved endpoints are passed in rather than read through `getAllEndpoints()`, which would
+   * re-invoke a settings function and could describe a different layout than the pass is working on.
+   *
+   * @param {object[]} endpoints The endpoints the current pass will calculate.
+   */ cacheSummaryDestinations(endpoints) {
+        _class_private_field_set(this, _summaryDestinations, new Map());
+        (0, _array.arrayEach)(endpoints, (endpoint)=>{
+            let columns = _class_private_field_get(this, _summaryDestinations).get(endpoint.destinationRow);
+            if (columns === undefined) {
+                columns = new Set();
+                _class_private_field_get(this, _summaryDestinations).set(endpoint.destinationRow, columns);
+            }
+            columns.add(endpoint.destinationColumn);
+        });
+    }
+    /**
+   * Checks whether a physical cell holds the result of an endpoint.
+   *
+   * `getCellValue` normally recognizes a result by its `columnSummaryResult` class, but cell meta is
+   * addressed by visual coordinates, so a trimmed row has no readable class. Without this check a
+   * hidden summary row is summed as if it were plain data and inflates every summary covering it.
+   *
+   * @param {number} physicalRow Physical row index.
+   * @param {number} column Column index.
+   * @returns {boolean}
+   */ isSummaryDestination(physicalRow, column) {
+        if (_class_private_field_get(this, _summaryDestinations) === null) {
+            this.cacheSummaryDestinations(this.getAllEndpoints());
+        }
+        return _class_private_field_get(this, _summaryDestinations).get(physicalRow)?.has(column) === true;
+    }
+    /**
    * Used to fill the blanks in the endpoint data provided by a settings function.
    *
    * @private
@@ -73,7 +197,7 @@ const _utils = require("./utils");
             this.assignSetting(val, newEndpoint, 'ranges', [
                 [
                     0,
-                    this.hot.countRows() - 1
+                    this.countAddressableRows() - 1
                 ]
             ]);
             this.assignSetting(val, newEndpoint, 'reversedRowCoords', false);
@@ -115,7 +239,7 @@ const _utils = require("./utils");
             endpoint[name] = defaultValue;
         } else {
             /* eslint-disable no-lonely-if */ if (name === 'destinationRow' && endpoint.reversedRowCoords) {
-                endpoint[name] = this.hot.countRows() - settings[name] - 1;
+                endpoint[name] = this.countAddressableRows() - settings[name] - 1;
             } else {
                 endpoint[name] = settings[name];
             }
@@ -311,12 +435,7 @@ const _utils = require("./utils");
    * @param {boolean} [useOffset=true] Use the cell offset value.
    */ resetAllEndpoints(endpoints = this.getAllEndpoints(), useOffset = true) {
         const anyEndpointOutOfRange = endpoints.some((endpoint)=>{
-            const alterRowOffset = endpoint.alterRowOffset || 0;
-            const alterColOffset = endpoint.alterColumnOffset || 0;
-            if (endpoint.destinationRow + alterRowOffset >= this.hot.countRows() || endpoint.destinationColumn + alterColOffset >= this.hot.countCols()) {
-                return true;
-            }
-            return false;
+            return this.isEndpointOutOfBounds(endpoint, endpoint.alterRowOffset || 0, endpoint.alterColumnOffset || 0);
         });
         if (anyEndpointOutOfRange) {
             return;
@@ -333,8 +452,10 @@ const _utils = require("./utils");
     /**
    * Calculate and refresh all defined endpoints.
    */ refreshAllEndpoints() {
+        const endpoints = this.getAllEndpoints();
         this.cellsToSetCache = [];
-        (0, _array.arrayEach)(this.getAllEndpoints(), (value)=>{
+        this.cacheSummaryDestinations(endpoints);
+        (0, _array.arrayEach)(endpoints, (value)=>{
             this.currentEndpoint = value;
             this.plugin.calculate(value);
             this.setEndpointValue(value, 'init');
@@ -350,21 +471,23 @@ const _utils = require("./utils");
    *
    * @param {Array} changes Array of changes from the `afterChange` hook.
    */ refreshChangedEndpoints(changes) {
+        const endpoints = this.getAllEndpoints();
         const needToRefresh = [];
         this.cellsToSetCache = [];
+        this.cacheSummaryDestinations(endpoints);
         (0, _array.arrayEach)(changes, (value, key, changesObj)=>{
             const change = value;
             if (`${change[2] || ''}` === `${change[3]}`) {
                 return;
             }
-            (0, _array.arrayEach)(this.getAllEndpoints(), (endpoint, j)=>{
+            (0, _array.arrayEach)(endpoints, (endpoint, j)=>{
                 if (this.hot.propToCol(changesObj[key][1]) === endpoint.sourceColumn && needToRefresh.indexOf(j) === -1) {
                     needToRefresh.push(j);
                 }
             });
         });
         (0, _array.arrayEach)(needToRefresh, (value)=>{
-            this.refreshEndpoint(this.getEndpoint(value));
+            this.refreshEndpoint(endpoints[value]);
         });
         if (this.cellsToSetCache.length) {
             this.hot.setDataAtCell(this.cellsToSetCache, null, undefined, 'ColumnSummary.reset');
@@ -377,11 +500,15 @@ const _utils = require("./utils");
    * @param {Set<number>|number[]} visualColumns Visual column indexes to match against.
    */ refreshEndpointsBySourceColumns(visualColumns) {
         const columnsSet = visualColumns instanceof Set ? visualColumns : new Set(visualColumns);
-        const matched = this.getAllEndpoints().filter((endpoint)=>columnsSet.has(endpoint.sourceColumn));
+        const endpoints = this.getAllEndpoints();
+        const matched = endpoints.filter((endpoint)=>columnsSet.has(endpoint.sourceColumn));
         if (matched.length === 0) {
             return;
         }
         this.cellsToSetCache = [];
+        // Every endpoint is cached, not just the matched ones - a summary result must stay excluded from
+        // the ranges of the endpoints being refreshed, whatever their own source column is.
+        this.cacheSummaryDestinations(endpoints);
         (0, _array.arrayEach)(matched, (endpoint)=>{
             this.refreshEndpoint(endpoint);
         });
@@ -394,12 +521,16 @@ const _utils = require("./utils");
    * Refreshes the cell meta information for the all endpoints after the `updateSettings` method call which in some
    * cases (call with `columns` option) can reset the cell metas to the initial state.
    */ refreshCellMetas() {
+        // Declarative writes: kept on the cell meta (so they survive the viewport meta eviction) but not
+        // recorded as user-defined, so an `updateSettings` cache reset clears them and they are re-applied
+        // for the current endpoints. `_setCellMetaDeclarative` does not fire `beforeSetCellMeta`/
+        // `afterSetCellMeta` and cannot be vetoed - matching the previous direct-write behavior.
         this.endpoints.forEach((endpoint)=>{
             const destinationVisualRow = this.hot.toVisualRow(endpoint.destinationRow);
+            const destinationColumn = endpoint.destinationColumn;
             if (destinationVisualRow !== null) {
-                const cellMeta = this.hot.getCellMeta(destinationVisualRow, endpoint.destinationColumn);
-                cellMeta.readOnly = endpoint.readOnly;
-                cellMeta.className = 'columnSummaryResult';
+                this.hot._setCellMetaDeclarative(destinationVisualRow, destinationColumn, 'readOnly', endpoint.readOnly);
+                this.hot._setCellMetaDeclarative(destinationVisualRow, destinationColumn, 'className', 'columnSummaryResult');
             }
         });
     }
@@ -421,8 +552,14 @@ const _utils = require("./utils");
    */ resetEndpointValue(endpoint, useOffset = true) {
         const alterRowOffset = endpoint.alterRowOffset || 0;
         const alterColOffset = endpoint.alterColumnOffset || 0;
+        const destinationVisualRow = this.hot.toVisualRow(endpoint.destinationRow + (useOffset ? alterRowOffset : 0));
+        // The destination row is trimmed (for example it sits inside a collapsed NestedRows group), so
+        // there is no cell to clear.
+        if (destinationVisualRow === null) {
+            return;
+        }
         this.cellsToSetCache.push([
-            this.hot.toVisualRow(endpoint.destinationRow + (useOffset ? alterRowOffset : 0)),
+            destinationVisualRow,
             this.hot.toVisualColumn(endpoint.destinationColumn + (useOffset ? alterColOffset : 0)),
             ''
         ]);
@@ -434,28 +571,36 @@ const _utils = require("./utils");
    * @param {string} [source] Source of the call information.
    * @param {boolean} [render=false] `true` if it needs to render the table afterwards.
    */ setEndpointValue(endpoint, source, render = false) {
-        const visualEndpointRowIndex = this.hot.toVisualRow(endpoint.destinationRow);
-        if (endpoint.destinationRow >= this.hot.countRows() || endpoint.destinationColumn >= this.hot.countCols()) {
+        if (this.isEndpointOutOfBounds(endpoint)) {
             this.throwOutOfBoundsWarning();
             return;
         }
         const destinationVisualRow = this.hot.toVisualRow(endpoint.destinationRow);
         if (destinationVisualRow !== null) {
-            const cellMeta = this.hot.getCellMeta(destinationVisualRow, endpoint.destinationColumn);
+            const destinationColumn = endpoint.destinationColumn;
+            const cellMeta = this.hot.getCellMetaTransient(destinationVisualRow, destinationColumn);
             if (source === 'init' || cellMeta.readOnly !== endpoint.readOnly) {
-                cellMeta.readOnly = endpoint.readOnly;
-                cellMeta.className = 'columnSummaryResult';
+                // Declarative writes (see `refreshCellMetas`) so the styling survives viewport meta eviction
+                // without firing the public `setCellMeta` hooks or being vetoable.
+                this.hot._setCellMetaDeclarative(destinationVisualRow, destinationColumn, 'readOnly', endpoint.readOnly);
+                this.hot._setCellMetaDeclarative(destinationVisualRow, destinationColumn, 'className', 'columnSummaryResult');
             }
         }
         endpoint.result = (0, _utils.roundFloat)(endpoint.result, endpoint.roundFloat);
-        if (render) {
-            this.hot.setDataAtCell(visualEndpointRowIndex, endpoint.destinationColumn, endpoint.result, 'ColumnSummary.set');
-        } else {
-            this.cellsToSetCache.push([
-                visualEndpointRowIndex,
-                endpoint.destinationColumn,
-                endpoint.result
-            ]);
+        // A trimmed destination row has no cell to write to - writing one throws in `DataMap.set`. The
+        // result stays on the endpoint; the cell keeps its previous value until the next recalculation
+        // that runs while the row is visible. Nothing re-runs the endpoints on untrim, so a destination
+        // hidden at the moment of a change shows a stale value until then.
+        if (destinationVisualRow !== null) {
+            if (render) {
+                this.hot.setDataAtCell(destinationVisualRow, endpoint.destinationColumn, endpoint.result, 'ColumnSummary.set');
+            } else {
+                this.cellsToSetCache.push([
+                    destinationVisualRow,
+                    endpoint.destinationColumn,
+                    endpoint.result
+                ]);
+            }
         }
         endpoint.alterRowOffset = undefined;
         endpoint.alterColumnOffset = undefined;
@@ -470,6 +615,10 @@ const _utils = require("./utils");
     /**
    * Initializes the endpoints manager with a reference to the ColumnSummary plugin and the summary endpoint configuration.
    */ constructor(plugin, settings){
+        _class_private_field_init(this, _summaryDestinations, {
+            writable: true,
+            value: void 0
+        });
         /**
    * Array of declared plugin endpoints (calculation destination points).
    *
@@ -495,7 +644,10 @@ const _utils = require("./utils");
    * @type {Array}
    * @default {[]}
    */ this.cellsToSetCache = [];
+        _class_private_field_set(this, _summaryDestinations, null);
         this.plugin = plugin;
+        // `_setCellMetaDeclarative` is defined on the Core runtime object but kept off the public
+        // `HotInstance` type; this internal plugin reaches it through the `HotInstanceInternal` view.
         this.hot = this.plugin.hot;
         this.settings = settings;
     }