handsontable 18.0.0 → 18.1.0-rc7

package/plugins/columnSorting/columnStatesManager.js

@@ -9,7 +9,6 @@ Object.defineProperty(exports, "ColumnStatesManager", {
     }
 });
 const _object = require("../../helpers/object");
-const _translations = require("../../translations");
 const inheritedColumnProperties = [
     'sortEmptyCells',
     'indicator',
@@ -145,11 +144,6 @@ class ColumnStatesManager {
    * Initializes the column states manager with the Handsontable instance and registers the sorting states index map under the given map name.
    */ constructor(hot, mapName){
         /**
-   * Index map storing sorting states for every column. ColumnStatesManager write and read to/from this element.
-   *
-   * @type {LinkedPhysicalIndexToValueMap}
-   */ this.sortingStates = new _translations.LinkedPhysicalIndexToValueMap();
-        /**
    * Determines whether we should sort empty cells.
    *
    * @type {boolean}
@@ -166,6 +160,6 @@ class ColumnStatesManager {
    */ this.headerAction = HEADER_ACTION_DEFAULT;
         this.hot = hot;
         this.mapName = mapName;
-        this.hot.columnIndexMapper.registerMap(mapName, this.sortingStates);
+        this.sortingStates = this.hot.columnIndexMapper.createAndRegisterIndexMap(mapName, 'linkedPhysicalIndexToValue');
     }
 }

package/plugins/columnSorting/columnStatesManager.mjs

@@ -1,5 +1,4 @@
 import { isObject, objectEach } from '../../helpers/object.mjs';
-import { LinkedPhysicalIndexToValueMap as IndexToValueMap } from '../../translations/index.mjs';
 const inheritedColumnProperties = [
     'sortEmptyCells',
     'indicator',
@@ -140,11 +139,6 @@ const HEADER_ACTION_DEFAULT = true;
    * Initializes the column states manager with the Handsontable instance and registers the sorting states index map under the given map name.
    */ constructor(hot, mapName){
         /**
-   * Index map storing sorting states for every column. ColumnStatesManager write and read to/from this element.
-   *
-   * @type {LinkedPhysicalIndexToValueMap}
-   */ this.sortingStates = new IndexToValueMap();
-        /**
    * Determines whether we should sort empty cells.
    *
    * @type {boolean}
@@ -161,6 +155,6 @@ const HEADER_ACTION_DEFAULT = true;
    */ this.headerAction = HEADER_ACTION_DEFAULT;
         this.hot = hot;
         this.mapName = mapName;
-        this.hot.columnIndexMapper.registerMap(mapName, this.sortingStates);
+        this.sortingStates = this.hot.columnIndexMapper.createAndRegisterIndexMap(mapName, 'linkedPhysicalIndexToValue');
     }
 }

package/plugins/columnSorting/domHelpers.d.ts

@@ -1,4 +1,7 @@
 import type { ColumnStatesManager } from './columnStatesManager';
+export declare const HEADER_CLASS_ASC_SORT = "ascending";
+export declare const HEADER_CLASS_DESC_SORT = "descending";
+export declare const HEADER_ACTION_CLASS = "sortAction";
 /**
  * Get CSS classes which should be added to particular column header.
  *

package/plugins/columnSorting/domHelpers.js

@@ -9,6 +9,15 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get HEADER_ACTION_CLASS () {
+        return HEADER_ACTION_CLASS;
+    },
+    get HEADER_CLASS_ASC_SORT () {
+        return HEADER_CLASS_ASC_SORT;
+    },
+    get HEADER_CLASS_DESC_SORT () {
+        return HEADER_CLASS_DESC_SORT;
+    },
     get getClassesToAdd () {
         return getClassesToAdd;
     },

package/plugins/columnSorting/domHelpers.mjs

@@ -1,9 +1,9 @@
 import { ASC_SORT_STATE, DESC_SORT_STATE } from './utils.mjs';
-const HEADER_CLASS_ASC_SORT = 'ascending';
-const HEADER_CLASS_DESC_SORT = 'descending';
+export const HEADER_CLASS_ASC_SORT = 'ascending';
+export const HEADER_CLASS_DESC_SORT = 'descending';
 const HEADER_CLASS_INDICATOR_DISABLED = 'indicatorDisabled';
 const HEADER_SORT_CLASS = 'columnSorting';
-const HEADER_ACTION_CLASS = 'sortAction';
+export const HEADER_ACTION_CLASS = 'sortAction';
 const orderToCssClass = new Map([
     [
         ASC_SORT_STATE,

package/plugins/columnSorting/rootComparator.js

@@ -9,23 +9,28 @@ Object.defineProperty(exports, "rootComparator", {
     }
 });
 const _sortService = require("./sortService");
+/**
+ * Creates the compare function for a single sorted column. Resolved once per sort run — the
+ * factory result is reused for every comparison, so any per-run caching inside the returned
+ * compare function (e.g. normalized-value memoization) stays effective.
+ *
+ * @param {unknown} sortingOrder Sort order (`asc` for ascending, `desc` for descending).
+ * @param {unknown} columnMeta Column meta object.
+ * @returns {Function} The compare function.
+ */ function createColumnCompareFunction(sortingOrder, columnMeta) {
+    const typedMeta = columnMeta;
+    const pluginSettings = typedMeta.columnSorting;
+    const compareFunctionFactory = pluginSettings?.compareFunctionFactory ? pluginSettings.compareFunctionFactory : (0, _sortService.getCompareFunctionFactory)(typedMeta.type ?? '');
+    return compareFunctionFactory(sortingOrder, columnMeta, pluginSettings);
+}
 function rootComparator(sortingOrders, columnMetas) {
+    // The compare function is created once per sort run, not once per comparison. Re-invoking the
+    // factory inside the comparator would allocate a fresh closure ~n*log(n) times and defeat the
+    // per-run value caches the built-in compare functions rely on.
+    const compareFunction = createColumnCompareFunction(sortingOrders[0], columnMetas[0]);
     return function(rowIndexWithValues, nextRowIndexWithValues) {
-        // We sort array of arrays. Single array is in form [rowIndex, ...values].
-        // We compare just values, stored at second index of array.
-        const [, ...values] = rowIndexWithValues;
-        const [, ...nextValues] = nextRowIndexWithValues;
-        return function getCompareResult(column) {
-            const sortingOrder = sortingOrders[column];
-            const columnMeta = columnMetas[column];
-            const value = values[column];
-            const nextValue = nextValues[column];
-            const typedMeta = columnMeta;
-            const pluginSettings = typedMeta.columnSorting;
-            const compareFunctionFactory = pluginSettings?.compareFunctionFactory ? pluginSettings.compareFunctionFactory : (0, _sortService.getCompareFunctionFactory)(typedMeta.type ?? '');
-            const compareResult = compareFunctionFactory(sortingOrder, columnMeta, pluginSettings)(value, nextValue);
-            // DIFF - MultiColumnSorting & ColumnSorting: removed iteration through next sorted columns.
-            return compareResult;
-        }(0);
+        // We sort array of arrays. Single array is in form [rowIndex, ...values],
+        // so the value of the only sorted column is stored at index 1.
+        return compareFunction(rowIndexWithValues[1], nextRowIndexWithValues[1]);
     };
 }

package/plugins/columnSorting/rootComparator.mjs

@@ -1,4 +1,18 @@
 import { getCompareFunctionFactory } from './sortService/index.mjs';
+/**
+ * Creates the compare function for a single sorted column. Resolved once per sort run — the
+ * factory result is reused for every comparison, so any per-run caching inside the returned
+ * compare function (e.g. normalized-value memoization) stays effective.
+ *
+ * @param {unknown} sortingOrder Sort order (`asc` for ascending, `desc` for descending).
+ * @param {unknown} columnMeta Column meta object.
+ * @returns {Function} The compare function.
+ */ function createColumnCompareFunction(sortingOrder, columnMeta) {
+    const typedMeta = columnMeta;
+    const pluginSettings = typedMeta.columnSorting;
+    const compareFunctionFactory = pluginSettings?.compareFunctionFactory ? pluginSettings.compareFunctionFactory : getCompareFunctionFactory(typedMeta.type ?? '');
+    return compareFunctionFactory(sortingOrder, columnMeta, pluginSettings);
+}
 /**
  * Sort comparator handled by conventional sort algorithm.
  *
@@ -6,22 +20,13 @@ import { getCompareFunctionFactory } from './sortService/index.mjs';
  * @param {Array} columnMetas Column meta objects.
  * @returns {Function}
  */ export function rootComparator(sortingOrders, columnMetas) {
+    // The compare function is created once per sort run, not once per comparison. Re-invoking the
+    // factory inside the comparator would allocate a fresh closure ~n*log(n) times and defeat the
+    // per-run value caches the built-in compare functions rely on.
+    const compareFunction = createColumnCompareFunction(sortingOrders[0], columnMetas[0]);
     return function(rowIndexWithValues, nextRowIndexWithValues) {
-        // We sort array of arrays. Single array is in form [rowIndex, ...values].
-        // We compare just values, stored at second index of array.
-        const [, ...values] = rowIndexWithValues;
-        const [, ...nextValues] = nextRowIndexWithValues;
-        return function getCompareResult(column) {
-            const sortingOrder = sortingOrders[column];
-            const columnMeta = columnMetas[column];
-            const value = values[column];
-            const nextValue = nextValues[column];
-            const typedMeta = columnMeta;
-            const pluginSettings = typedMeta.columnSorting;
-            const compareFunctionFactory = pluginSettings?.compareFunctionFactory ? pluginSettings.compareFunctionFactory : getCompareFunctionFactory(typedMeta.type ?? '');
-            const compareResult = compareFunctionFactory(sortingOrder, columnMeta, pluginSettings)(value, nextValue);
-            // DIFF - MultiColumnSorting & ColumnSorting: removed iteration through next sorted columns.
-            return compareResult;
-        }(0);
+        // We sort array of arrays. Single array is in form [rowIndex, ...values],
+        // so the value of the only sorted column is stored at index 1.
+        return compareFunction(rowIndexWithValues[1], nextRowIndexWithValues[1]);
     };
 }

package/plugins/columnSorting/sortFunction/checkbox.js

@@ -43,12 +43,11 @@ const _mixed = require("../../../helpers/mixed");
  * @param {boolean} isValueFromTemplate Whether the first value is from the template.
  * @param {boolean} isNextValueFromTemplate Whether the second value is from the template.
  * @param {string} sortOrder Sort order (`asc` for ascending, `desc` for descending).
- * @param {object} columnMeta Column meta object.
- * @param {object} columnPluginSettings Plugin settings for the column.
+ * @param {Function} compareDefaultValues Compare function used for two non-template values.
  * @param {unknown} value The first value.
  * @param {unknown} nextValue The second value.
  * @returns {number | null} The comparison result or null if both values are from template.
- */ function compareBadValues(isValueFromTemplate, isNextValueFromTemplate, sortOrder, columnMeta, columnPluginSettings, value, nextValue) {
+ */ function compareBadValues(isValueFromTemplate, isNextValueFromTemplate, sortOrder, compareDefaultValues, value, nextValue) {
     // 1st value === #BAD_VALUE#
     if (isValueFromTemplate === false && isNextValueFromTemplate) {
         return sortOrder === 'asc' ? _sortService.FIRST_BEFORE_SECOND : _sortService.FIRST_AFTER_SECOND;
@@ -60,7 +59,7 @@ const _mixed = require("../../../helpers/mixed");
     // 1st value === #BAD_VALUE# && 2nd value === #BAD_VALUE#
     if (isValueFromTemplate === false && isNextValueFromTemplate === false) {
         // Sorting by values (not just by visual representation).
-        return (0, _default.compareFunctionFactory)(sortOrder, columnMeta, columnPluginSettings)(value, nextValue);
+        return compareDefaultValues(value, nextValue);
     }
     return null;
 }
@@ -68,6 +67,9 @@ function compareFunctionFactory(sortOrder, columnMeta, columnPluginSettings) {
     const checkedTemplate = columnMeta.checkedTemplate;
     const uncheckedTemplate = columnMeta.uncheckedTemplate;
     const { sortEmptyCells } = columnPluginSettings;
+    // Created once per sort run so the default comparator's per-run caches stay effective when
+    // non-template ("bad") values fall back to value-based sorting.
+    const compareDefaultValues = (0, _default.compareFunctionFactory)(sortOrder, columnMeta, columnPluginSettings);
     return function(value, nextValue) {
         const isEmptyValue = (0, _mixed.isEmpty)(value);
         const isEmptyNextValue = (0, _mixed.isEmpty)(nextValue);
@@ -84,7 +86,7 @@ function compareFunctionFactory(sortOrder, columnMeta, columnPluginSettings) {
                 return _sortService.FIRST_BEFORE_SECOND;
             }
         }
-        const badValueResult = compareBadValues(isValueFromTemplate, isNextValueFromTemplate, sortOrder, columnMeta, columnPluginSettings, value, nextValue);
+        const badValueResult = compareBadValues(isValueFromTemplate, isNextValueFromTemplate, sortOrder, compareDefaultValues, value, nextValue);
         if (badValueResult !== null) {
             return badValueResult;
         }

package/plugins/columnSorting/sortFunction/checkbox.mjs

@@ -25,12 +25,11 @@ import { isEmpty } from '../../../helpers/mixed.mjs';
  * @param {boolean} isValueFromTemplate Whether the first value is from the template.
  * @param {boolean} isNextValueFromTemplate Whether the second value is from the template.
  * @param {string} sortOrder Sort order (`asc` for ascending, `desc` for descending).
- * @param {object} columnMeta Column meta object.
- * @param {object} columnPluginSettings Plugin settings for the column.
+ * @param {Function} compareDefaultValues Compare function used for two non-template values.
  * @param {unknown} value The first value.
  * @param {unknown} nextValue The second value.
  * @returns {number | null} The comparison result or null if both values are from template.
- */ function compareBadValues(isValueFromTemplate, isNextValueFromTemplate, sortOrder, columnMeta, columnPluginSettings, value, nextValue) {
+ */ function compareBadValues(isValueFromTemplate, isNextValueFromTemplate, sortOrder, compareDefaultValues, value, nextValue) {
     // 1st value === #BAD_VALUE#
     if (isValueFromTemplate === false && isNextValueFromTemplate) {
         return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND;
@@ -42,7 +41,7 @@ import { isEmpty } from '../../../helpers/mixed.mjs';
     // 1st value === #BAD_VALUE# && 2nd value === #BAD_VALUE#
     if (isValueFromTemplate === false && isNextValueFromTemplate === false) {
         // Sorting by values (not just by visual representation).
-        return defaultCompareFunctionFactory(sortOrder, columnMeta, columnPluginSettings)(value, nextValue);
+        return compareDefaultValues(value, nextValue);
     }
     return null;
 }
@@ -57,6 +56,9 @@ import { isEmpty } from '../../../helpers/mixed.mjs';
     const checkedTemplate = columnMeta.checkedTemplate;
     const uncheckedTemplate = columnMeta.uncheckedTemplate;
     const { sortEmptyCells } = columnPluginSettings;
+    // Created once per sort run so the default comparator's per-run caches stay effective when
+    // non-template ("bad") values fall back to value-based sorting.
+    const compareDefaultValues = defaultCompareFunctionFactory(sortOrder, columnMeta, columnPluginSettings);
     return function(value, nextValue) {
         const isEmptyValue = isEmpty(value);
         const isEmptyNextValue = isEmpty(nextValue);
@@ -73,7 +75,7 @@ import { isEmpty } from '../../../helpers/mixed.mjs';
                 return FIRST_BEFORE_SECOND;
             }
         }
-        const badValueResult = compareBadValues(isValueFromTemplate, isNextValueFromTemplate, sortOrder, columnMeta, columnPluginSettings, value, nextValue);
+        const badValueResult = compareBadValues(isValueFromTemplate, isNextValueFromTemplate, sortOrder, compareDefaultValues, value, nextValue);
         if (badValueResult !== null) {
             return badValueResult;
         }

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.`);