handsontable 18.0.0 → 18.1.0-rc1

package/plugins/columnSorting/sortFunction/default.js

@@ -22,15 +22,25 @@ const _string = require("../../../helpers/string");
 /**
  * Normalizes a cell value for comparison by converting booleans to numbers and strings to lowercase.
  *
+ * Lowercased strings are memoized in the provided cache. The compare function is created once per
+ * sort run, so each distinct string pays the locale-aware lowercasing once instead of on every
+ * comparison (~2*log(n) times per row in a sort).
+ *
  * @param {unknown} value The value to normalize.
  * @param {string | undefined} locale The locale to use for string lowercasing.
+ * @param {Map} lowerCaseCache Per-sort-run cache mapping original strings to lowercased ones.
  * @returns {unknown} The normalized value.
- */ function normalizeValue(value, locale) {
+ */ function normalizeValue(value, locale, lowerCaseCache) {
     if (typeof value === 'boolean') {
         return Number(value);
     }
     if (typeof value === 'string') {
-        return (0, _string.localeLowerCase)(value, locale);
+        let lowerCasedValue = lowerCaseCache.get(value);
+        if (lowerCasedValue === undefined) {
+            lowerCasedValue = (0, _string.localeLowerCase)(value, locale);
+            lowerCaseCache.set(value, lowerCasedValue);
+        }
+        return lowerCasedValue;
     }
     return value;
 }
@@ -68,10 +78,11 @@ const _string = require("../../../helpers/string");
 }
 function compareFunctionFactory(sortOrder, columnMeta, columnPluginSettings) {
     const locale = columnMeta.locale;
+    const lowerCaseCache = new Map();
     return function(value, nextValue) {
         const { sortEmptyCells } = columnPluginSettings;
-        const normalizedValue = normalizeValue(value, locale);
-        const normalizedNextValue = normalizeValue(nextValue, locale);
+        const normalizedValue = normalizeValue(value, locale, lowerCaseCache);
+        const normalizedNextValue = normalizeValue(nextValue, locale, lowerCaseCache);
         if (normalizedValue === normalizedNextValue) {
             return _sortService.DO_NOT_SWAP;
         }

package/plugins/columnSorting/sortFunction/default.mjs

@@ -4,15 +4,25 @@ import { localeLowerCase } from '../../../helpers/string.mjs';
 /**
  * Normalizes a cell value for comparison by converting booleans to numbers and strings to lowercase.
  *
+ * Lowercased strings are memoized in the provided cache. The compare function is created once per
+ * sort run, so each distinct string pays the locale-aware lowercasing once instead of on every
+ * comparison (~2*log(n) times per row in a sort).
+ *
  * @param {unknown} value The value to normalize.
  * @param {string | undefined} locale The locale to use for string lowercasing.
+ * @param {Map} lowerCaseCache Per-sort-run cache mapping original strings to lowercased ones.
  * @returns {unknown} The normalized value.
- */ function normalizeValue(value, locale) {
+ */ function normalizeValue(value, locale, lowerCaseCache) {
     if (typeof value === 'boolean') {
         return Number(value);
     }
     if (typeof value === 'string') {
-        return localeLowerCase(value, locale);
+        let lowerCasedValue = lowerCaseCache.get(value);
+        if (lowerCasedValue === undefined) {
+            lowerCasedValue = localeLowerCase(value, locale);
+            lowerCaseCache.set(value, lowerCasedValue);
+        }
+        return lowerCasedValue;
     }
     return value;
 }
@@ -57,10 +67,11 @@ import { localeLowerCase } from '../../../helpers/string.mjs';
  * @returns {Function} The compare function.
  */ export function compareFunctionFactory(sortOrder, columnMeta, columnPluginSettings) {
     const locale = columnMeta.locale;
+    const lowerCaseCache = new Map();
     return function(value, nextValue) {
         const { sortEmptyCells } = columnPluginSettings;
-        const normalizedValue = normalizeValue(value, locale);
-        const normalizedNextValue = normalizeValue(nextValue, locale);
+        const normalizedValue = normalizeValue(value, locale, lowerCaseCache);
+        const normalizedNextValue = normalizeValue(nextValue, locale, lowerCaseCache);
         if (normalizedValue === normalizedNextValue) {
             return DO_NOT_SWAP;
         }

package/plugins/columnSorting/sortFunction/intlDatetime.d.mts

@@ -0,0 +1 @@
+export * from './intlDatetime.js';

package/plugins/columnSorting/sortFunction/intlDatetime.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Intl date-time sorting compare function factory.
+ *
+ * @param {string} sortOrder Sort order (`asc` for ascending, `desc` for descending).
+ * @param {object} _columnMeta Column meta object (unused).
+ * @param {object} columnPluginSettings Plugin settings for the column.
+ * @returns {Function} The compare function.
+ */
+export declare function compareFunctionFactory(sortOrder: string, _columnMeta: Record<string, unknown>, columnPluginSettings: Record<string, unknown>): (value: unknown, nextValue: unknown) => number;
+export declare const COLUMN_DATA_TYPE = "intl-datetime";

package/plugins/columnSorting/sortFunction/intlDatetime.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get COLUMN_DATA_TYPE () {
+        return COLUMN_DATA_TYPE;
+    },
+    get compareFunctionFactory () {
+        return compareFunctionFactory;
+    }
+});
+const _utils = require("../utils");
+function compareFunctionFactory(sortOrder, _columnMeta, columnPluginSettings) {
+    return (0, _utils.createDateTimeCompareFunction)(sortOrder, columnPluginSettings);
+}
+const COLUMN_DATA_TYPE = 'intl-datetime';

package/plugins/columnSorting/sortFunction/intlDatetime.mjs

@@ -0,0 +1,12 @@
+import { createDateTimeCompareFunction } from '../utils.mjs';
+/**
+ * Intl date-time sorting compare function factory.
+ *
+ * @param {string} sortOrder Sort order (`asc` for ascending, `desc` for descending).
+ * @param {object} _columnMeta Column meta object (unused).
+ * @param {object} columnPluginSettings Plugin settings for the column.
+ * @returns {Function} The compare function.
+ */ export function compareFunctionFactory(sortOrder, _columnMeta, columnPluginSettings) {
+    return createDateTimeCompareFunction(sortOrder, columnPluginSettings);
+}
+export const COLUMN_DATA_TYPE = 'intl-datetime';

package/plugins/columnSorting/sortService/registry.js

@@ -26,6 +26,7 @@ const _date = require("../sortFunction/date");
 const _intlDate = require("../sortFunction/intlDate");
 const _time = require("../sortFunction/time");
 const _intlTime = require("../sortFunction/intlTime");
+const _intlDatetime = require("../sortFunction/intlDatetime");
 const _staticRegister = require("../../../utils/staticRegister");
 const { register: registerCompareFunctionFactory, getItem: getGloballyCompareFunctionFactory, hasItem: hasGloballyCompareFunctionFactory } = (0, _staticRegister.staticRegister)('sorting.compareFunctionFactory');
 const { register: registerRootComparator, getItem: getRootComparator } = (0, _staticRegister.staticRegister)('sorting.mainSortComparator');
@@ -42,3 +43,4 @@ registerCompareFunctionFactory(_default.COLUMN_DATA_TYPE, _default.compareFuncti
 registerCompareFunctionFactory(_numeric.COLUMN_DATA_TYPE, _numeric.compareFunctionFactory);
 registerCompareFunctionFactory(_time.COLUMN_DATA_TYPE, _time.compareFunctionFactory);
 registerCompareFunctionFactory(_intlTime.COLUMN_DATA_TYPE, _intlTime.compareFunctionFactory);
+registerCompareFunctionFactory(_intlDatetime.COLUMN_DATA_TYPE, _intlDatetime.compareFunctionFactory);

package/plugins/columnSorting/sortService/registry.mjs

@@ -5,6 +5,7 @@ import { compareFunctionFactory as dateSort, COLUMN_DATA_TYPE as DATE_DATA_TYPE
 import { compareFunctionFactory as intlDateSort, COLUMN_DATA_TYPE as INTL_DATE_DATA_TYPE } from '../sortFunction/intlDate.mjs';
 import { compareFunctionFactory as timeSort, COLUMN_DATA_TYPE as TIME_DATA_TYPE } from '../sortFunction/time.mjs';
 import { compareFunctionFactory as intlTimeSort, COLUMN_DATA_TYPE as INTL_TIME_DATA_TYPE } from '../sortFunction/intlTime.mjs';
+import { compareFunctionFactory as intlDatetimeSort, COLUMN_DATA_TYPE as INTL_DATETIME_DATA_TYPE } from '../sortFunction/intlDatetime.mjs';
 import { staticRegister } from '../../../utils/staticRegister.mjs';
 const { register: registerCompareFunctionFactory, getItem: getGloballyCompareFunctionFactory, hasItem: hasGloballyCompareFunctionFactory } = staticRegister('sorting.compareFunctionFactory');
 const { register: registerRootComparator, getItem: getRootComparator } = staticRegister('sorting.mainSortComparator');
@@ -26,4 +27,5 @@ registerCompareFunctionFactory(DEFAULT_DATA_TYPE, defaultSort);
 registerCompareFunctionFactory(NUMERIC_DATA_TYPE, numericSort);
 registerCompareFunctionFactory(TIME_DATA_TYPE, timeSort);
 registerCompareFunctionFactory(INTL_TIME_DATA_TYPE, intlTimeSort);
+registerCompareFunctionFactory(INTL_DATETIME_DATA_TYPE, intlDatetimeSort);
 export { registerRootComparator, getRootComparator };

package/plugins/columnSorting/utils.d.ts

@@ -56,6 +56,14 @@ export declare function createIntlDateCompareFunction(sortOrder: string, columnP
  * @returns {Function} The compare function.
  */
 export declare function createIntlTimeCompareFunction(sortOrder: string, columnPluginSettings: Record<string, unknown>): (value: unknown, nextValue: unknown) => number;
+/**
+ * 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 declare function createDateTimeCompareFunction(sortOrder: string, columnPluginSettings: Record<string, unknown>): (value: unknown, nextValue: unknown) => number;
 /**
  * Warn users about problems when using `columnSorting` and `multiColumnSorting` plugins simultaneously.
  *

package/plugins/columnSorting/utils.js

@@ -21,6 +21,9 @@ _export(exports, {
     get areValidSortStates () {
         return areValidSortStates;
     },
+    get createDateTimeCompareFunction () {
+        return createDateTimeCompareFunction;
+    },
     get createIntlDateCompareFunction () {
         return createIntlDateCompareFunction;
     },
@@ -106,47 +109,27 @@ function wasHeaderClickedProperly(row, column, clickEvent) {
     const targetHeader = typeof (0, _element.eventTargetEl)(clickEvent)?.closest === 'function' ? (0, _element.eventTargetEl)(clickEvent).closest('th') : null;
     return targetHeader !== null && (0, _element.isBottomMostColumnHeader)(targetHeader);
 }
-function createIntlDateCompareFunction(sortOrder, columnPluginSettings) {
-    return function(value, nextValue) {
-        const { sortEmptyCells } = columnPluginSettings;
-        if (value === nextValue) {
-            return _sortService.DO_NOT_SWAP;
-        }
-        if ((0, _mixed.isEmpty)(value)) {
-            if ((0, _mixed.isEmpty)(nextValue)) {
-                return _sortService.DO_NOT_SWAP;
-            }
-            // Just fist value is empty and `sortEmptyCells` option was set
-            if (sortEmptyCells) {
-                return sortOrder === 'asc' ? _sortService.FIRST_BEFORE_SECOND : _sortService.FIRST_AFTER_SECOND;
-            }
-            return _sortService.FIRST_AFTER_SECOND;
-        }
-        if ((0, _mixed.isEmpty)(nextValue)) {
-            // Just second value is empty and `sortEmptyCells` option was set
-            if (sortEmptyCells) {
-                return sortOrder === 'asc' ? _sortService.FIRST_AFTER_SECOND : _sortService.FIRST_BEFORE_SECOND;
-            }
-            return _sortService.FIRST_BEFORE_SECOND;
-        }
-        const firstDate = (0, _dateTime.parseToLocalDate)(value);
-        const nextDate = (0, _dateTime.parseToLocalDate)(nextValue);
-        if (firstDate === null) {
-            return _sortService.FIRST_AFTER_SECOND;
-        }
-        if (nextDate === null) {
-            return _sortService.FIRST_BEFORE_SECOND;
-        }
-        if (nextDate > firstDate) {
-            return sortOrder === 'asc' ? _sortService.FIRST_BEFORE_SECOND : _sortService.FIRST_AFTER_SECOND;
-        }
-        if (nextDate < firstDate) {
-            return sortOrder === 'asc' ? _sortService.FIRST_AFTER_SECOND : _sortService.FIRST_BEFORE_SECOND;
+/**
+ * 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.
+ */ 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 _sortService.DO_NOT_SWAP;
+        return parsedTime;
     };
-}
-function createIntlTimeCompareFunction(sortOrder, columnPluginSettings) {
     return function(value, nextValue) {
         const { sortEmptyCells } = columnPluginSettings;
         if (value === nextValue) {
@@ -169,23 +152,32 @@ function createIntlTimeCompareFunction(sortOrder, columnPluginSettings) {
             }
             return _sortService.FIRST_BEFORE_SECOND;
         }
-        const firstDate = (0, _dateTime.parseToLocalTime)(value);
-        const nextDate = (0, _dateTime.parseToLocalTime)(nextValue);
-        if (firstDate === null) {
+        const firstTime = getParsedTime(value);
+        const nextTime = getParsedTime(nextValue);
+        if (firstTime === null) {
             return _sortService.FIRST_AFTER_SECOND;
         }
-        if (nextDate === null) {
+        if (nextTime === null) {
             return _sortService.FIRST_BEFORE_SECOND;
         }
-        if (nextDate > firstDate) {
+        if (nextTime > firstTime) {
             return sortOrder === 'asc' ? _sortService.FIRST_BEFORE_SECOND : _sortService.FIRST_AFTER_SECOND;
         }
-        if (nextDate < firstDate) {
+        if (nextTime < firstTime) {
             return sortOrder === 'asc' ? _sortService.FIRST_AFTER_SECOND : _sortService.FIRST_BEFORE_SECOND;
         }
         return _sortService.DO_NOT_SWAP;
     };
 }
+function createIntlDateCompareFunction(sortOrder, columnPluginSettings) {
+    return createParsingCompareFunction(_dateTime.parseToLocalDate, sortOrder, columnPluginSettings);
+}
+function createIntlTimeCompareFunction(sortOrder, columnPluginSettings) {
+    return createParsingCompareFunction(_dateTime.parseToLocalTime, sortOrder, columnPluginSettings);
+}
+function createDateTimeCompareFunction(sortOrder, columnPluginSettings) {
+    return createParsingCompareFunction(_dateTime.parseToLocalDateTime, sortOrder, columnPluginSettings);
+}
 function warnAboutPluginsConflict(workingPlugin, disabledPlugin) {
     (0, _console.warn)((0, _templateLiteralTag.toSingleLine)`Plugins \`columnSorting\` and \`multiColumnSorting\` should not be enabled simultaneously.\x20
     Only \`${workingPlugin}\` will work. The \`${disabledPlugin}\` plugin will remain disabled.`);

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

@@ -30,15 +30,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    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.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -46,9 +43,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    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) {
@@ -376,11 +371,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

@@ -4,15 +4,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    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.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -20,9 +17,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    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) {
@@ -468,11 +463,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.
      *