handsontable 12.1.3 → 12.2.0

package/plugins/columnSorting/sortFunction/default.mjs

@@ -1,53 +1,43 @@
 import { isEmpty } from "../../../helpers/mixed.mjs";
-import { DO_NOT_SWAP, FIRST_BEFORE_SECOND, FIRST_AFTER_SECOND } from "../sortService/index.mjs";
-/**
- * Default sorting compare function factory. Method get as parameters `sortOrder` and `columnMeta` and return compare function.
- *
- * @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.
- * @returns {Function} The compare function.
- */
-
+import { DO_NOT_SWAP, FIRST_BEFORE_SECOND, FIRST_AFTER_SECOND } from "../sortService/index.mjs"; /**
+                                                                                                  * Default sorting compare function factory. Method get as parameters `sortOrder` and `columnMeta` and return compare function.
+                                                                                                  *
+                                                                                                  * @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.
+                                                                                                  * @returns {Function} The compare function.
+                                                                                                  */
 export function compareFunctionFactory(sortOrder, columnMeta, columnPluginSettings) {
   var locale = columnMeta.locale;
   return function (value, nextValue) {
     var sortEmptyCells = columnPluginSettings.sortEmptyCells;
-
     if (typeof value === 'string') {
       value = value.toLocaleLowerCase(locale);
     }
-
     if (typeof nextValue === 'string') {
       nextValue = nextValue.toLocaleLowerCase(locale);
     }
-
     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
-
+      }
 
+      // 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;
     }
-
     if (isNaN(value) && !isNaN(nextValue)) {
       return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND;
     } else if (!isNaN(value) && isNaN(nextValue)) {
@@ -56,15 +46,12 @@ export function compareFunctionFactory(sortOrder, columnMeta, columnPluginSettin
       value = parseFloat(value);
       nextValue = parseFloat(nextValue);
     }
-
     if (value < nextValue) {
       return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND;
     }
-
     if (value > nextValue) {
       return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND;
     }
-
     return DO_NOT_SWAP;
   };
 }

package/plugins/columnSorting/sortFunction/numeric.js

@@ -3,11 +3,8 @@
 exports.__esModule = true;
 exports.COLUMN_DATA_TYPE = void 0;
 exports.compareFunctionFactory = compareFunctionFactory;
-
 var _mixed = require("../../../helpers/mixed");
-
 var _sortService = require("../sortService");
-
 /**
  * Numeric sorting compare function factory. Method get as parameters `sortOrder` and `columnMeta` and return compare function.
  *
@@ -20,39 +17,33 @@ function compareFunctionFactory(sortOrder, columnMeta, columnPluginSettings) {
   return function (value, nextValue) {
     var parsedFirstValue = parseFloat(value);
     var parsedSecondValue = parseFloat(nextValue);
-    var sortEmptyCells = columnPluginSettings.sortEmptyCells; // Watch out when changing this part of code! Check below returns 0 (as expected) when comparing empty string, null, undefined
+    var sortEmptyCells = columnPluginSettings.sortEmptyCells;
 
+    // Watch out when changing this part of code! Check below returns 0 (as expected) when comparing empty string, null, undefined
     if (parsedFirstValue === parsedSecondValue || isNaN(parsedFirstValue) && isNaN(parsedSecondValue)) {
       return _sortService.DO_NOT_SWAP;
     }
-
     if (sortEmptyCells) {
       if ((0, _mixed.isEmpty)(value)) {
         return sortOrder === 'asc' ? _sortService.FIRST_BEFORE_SECOND : _sortService.FIRST_AFTER_SECOND;
       }
-
       if ((0, _mixed.isEmpty)(nextValue)) {
         return sortOrder === 'asc' ? _sortService.FIRST_AFTER_SECOND : _sortService.FIRST_BEFORE_SECOND;
       }
     }
-
     if (isNaN(parsedFirstValue)) {
       return _sortService.FIRST_AFTER_SECOND;
     }
-
     if (isNaN(parsedSecondValue)) {
       return _sortService.FIRST_BEFORE_SECOND;
     }
-
     if (parsedFirstValue < parsedSecondValue) {
       return sortOrder === 'asc' ? _sortService.FIRST_BEFORE_SECOND : _sortService.FIRST_AFTER_SECOND;
     } else if (parsedFirstValue > parsedSecondValue) {
       return sortOrder === 'asc' ? _sortService.FIRST_AFTER_SECOND : _sortService.FIRST_BEFORE_SECOND;
     }
-
     return _sortService.DO_NOT_SWAP;
   };
 }
-
 var COLUMN_DATA_TYPE = 'numeric';
 exports.COLUMN_DATA_TYPE = COLUMN_DATA_TYPE;

package/plugins/columnSorting/sortFunction/numeric.mjs

@@ -1,48 +1,41 @@
 import { isEmpty } from "../../../helpers/mixed.mjs";
-import { DO_NOT_SWAP, FIRST_BEFORE_SECOND, FIRST_AFTER_SECOND } from "../sortService/index.mjs";
-/**
- * Numeric sorting compare function factory. Method get as parameters `sortOrder` and `columnMeta` and return compare function.
- *
- * @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.
- * @returns {Function} The compare function.
- */
-
+import { DO_NOT_SWAP, FIRST_BEFORE_SECOND, FIRST_AFTER_SECOND } from "../sortService/index.mjs"; /**
+                                                                                                  * Numeric sorting compare function factory. Method get as parameters `sortOrder` and `columnMeta` and return compare function.
+                                                                                                  *
+                                                                                                  * @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.
+                                                                                                  * @returns {Function} The compare function.
+                                                                                                  */
 export function compareFunctionFactory(sortOrder, columnMeta, columnPluginSettings) {
   return function (value, nextValue) {
     var parsedFirstValue = parseFloat(value);
     var parsedSecondValue = parseFloat(nextValue);
-    var sortEmptyCells = columnPluginSettings.sortEmptyCells; // Watch out when changing this part of code! Check below returns 0 (as expected) when comparing empty string, null, undefined
+    var sortEmptyCells = columnPluginSettings.sortEmptyCells;
 
+    // Watch out when changing this part of code! Check below returns 0 (as expected) when comparing empty string, null, undefined
     if (parsedFirstValue === parsedSecondValue || isNaN(parsedFirstValue) && isNaN(parsedSecondValue)) {
       return DO_NOT_SWAP;
     }
-
     if (sortEmptyCells) {
       if (isEmpty(value)) {
         return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND;
       }
-
       if (isEmpty(nextValue)) {
         return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND;
       }
     }
-
     if (isNaN(parsedFirstValue)) {
       return FIRST_AFTER_SECOND;
     }
-
     if (isNaN(parsedSecondValue)) {
       return FIRST_BEFORE_SECOND;
     }
-
     if (parsedFirstValue < parsedSecondValue) {
       return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND;
     } else if (parsedFirstValue > parsedSecondValue) {
       return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND;
     }
-
     return DO_NOT_SWAP;
   };
 }

package/plugins/columnSorting/sortService/engine.js

@@ -3,30 +3,24 @@
 exports.__esModule = true;
 exports.FIRST_BEFORE_SECOND = exports.FIRST_AFTER_SECOND = exports.DO_NOT_SWAP = void 0;
 exports.sort = sort;
-
 require("core-js/modules/es.array.sort.js");
-
 var _registry = require("./registry");
-
 var DO_NOT_SWAP = 0;
 exports.DO_NOT_SWAP = DO_NOT_SWAP;
 var FIRST_BEFORE_SECOND = -1;
 exports.FIRST_BEFORE_SECOND = FIRST_BEFORE_SECOND;
 var FIRST_AFTER_SECOND = 1;
+
 /**
  * @param {Array} indexesWithData The data to sort.
  * @param {string} rootComparatorId The comparator logic to use.
  * @param {Array} argsForRootComparator Additional arguments for comparator function.
  */
-
 exports.FIRST_AFTER_SECOND = FIRST_AFTER_SECOND;
-
 function sort(indexesWithData, rootComparatorId) {
   var rootComparator = (0, _registry.getRootComparator)(rootComparatorId);
-
   for (var _len = arguments.length, argsForRootComparator = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
     argsForRootComparator[_key - 2] = arguments[_key];
   }
-
   indexesWithData.sort(rootComparator.apply(void 0, argsForRootComparator));
 }

package/plugins/columnSorting/sortService/engine.mjs

@@ -3,18 +3,16 @@ import { getRootComparator } from "./registry.mjs";
 export var DO_NOT_SWAP = 0;
 export var FIRST_BEFORE_SECOND = -1;
 export var FIRST_AFTER_SECOND = 1;
+
 /**
  * @param {Array} indexesWithData The data to sort.
  * @param {string} rootComparatorId The comparator logic to use.
  * @param {Array} argsForRootComparator Additional arguments for comparator function.
  */
-
 export function sort(indexesWithData, rootComparatorId) {
   var rootComparator = getRootComparator(rootComparatorId);
-
   for (var _len = arguments.length, argsForRootComparator = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
     argsForRootComparator[_key - 2] = arguments[_key];
   }
-
   indexesWithData.sort(rootComparator.apply(void 0, argsForRootComparator));
 }

package/plugins/columnSorting/sortService/index.js

@@ -1,17 +1,12 @@
 "use strict";
 
 require("core-js/modules/es.array.sort.js");
-
 exports.__esModule = true;
-
 var _registry = require("./registry");
-
 exports.registerRootComparator = _registry.registerRootComparator;
 exports.getRootComparator = _registry.getRootComparator;
 exports.getCompareFunctionFactory = _registry.getCompareFunctionFactory;
-
 var _engine = require("./engine");
-
 exports.FIRST_AFTER_SECOND = _engine.FIRST_AFTER_SECOND;
 exports.FIRST_BEFORE_SECOND = _engine.FIRST_BEFORE_SECOND;
 exports.DO_NOT_SWAP = _engine.DO_NOT_SWAP;

package/plugins/columnSorting/sortService/registry.js

@@ -3,46 +3,34 @@
 exports.__esModule = true;
 exports.getCompareFunctionFactory = getCompareFunctionFactory;
 exports.registerRootComparator = exports.getRootComparator = void 0;
-
 var _default = require("../sortFunction/default");
-
 var _numeric = require("../sortFunction/numeric");
-
 var _checkbox = require("../sortFunction/checkbox");
-
 var _date = require("../sortFunction/date");
-
 var _staticRegister3 = _interopRequireDefault(require("../../../utils/staticRegister"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 var _staticRegister = (0, _staticRegister3.default)('sorting.compareFunctionFactory'),
-    registerCompareFunctionFactory = _staticRegister.register,
-    getGloballyCompareFunctionFactory = _staticRegister.getItem,
-    hasGloballyCompareFunctionFactory = _staticRegister.hasItem;
-
+  registerCompareFunctionFactory = _staticRegister.register,
+  getGloballyCompareFunctionFactory = _staticRegister.getItem,
+  hasGloballyCompareFunctionFactory = _staticRegister.hasItem;
 var _staticRegister2 = (0, _staticRegister3.default)('sorting.mainSortComparator'),
-    registerRootComparator = _staticRegister2.register,
-    getRootComparator = _staticRegister2.getItem;
+  registerRootComparator = _staticRegister2.register,
+  getRootComparator = _staticRegister2.getItem;
+
 /**
  * Gets sort function for the particular column basing on it's data type.
  *
  * @param {string} type The data type.
  * @returns {Function}
  */
-
-
 exports.getRootComparator = getRootComparator;
 exports.registerRootComparator = registerRootComparator;
-
 function getCompareFunctionFactory(type) {
   if (hasGloballyCompareFunctionFactory(type)) {
     return getGloballyCompareFunctionFactory(type);
   }
-
   return getGloballyCompareFunctionFactory(_default.COLUMN_DATA_TYPE);
 }
-
 registerCompareFunctionFactory(_numeric.COLUMN_DATA_TYPE, _numeric.compareFunctionFactory);
 registerCompareFunctionFactory(_checkbox.COLUMN_DATA_TYPE, _checkbox.compareFunctionFactory);
 registerCompareFunctionFactory(_date.COLUMN_DATA_TYPE, _date.compareFunctionFactory);

package/plugins/columnSorting/sortService/registry.mjs

@@ -3,28 +3,24 @@ import { compareFunctionFactory as numericSort, COLUMN_DATA_TYPE as NUMERIC_DATA
 import { compareFunctionFactory as checkboxSort, COLUMN_DATA_TYPE as CHECKBOX_DATA_TYPE } from "../sortFunction/checkbox.mjs";
 import { compareFunctionFactory as dateSort, COLUMN_DATA_TYPE as DATE_DATA_TYPE } from "../sortFunction/date.mjs";
 import staticRegister from "../../../utils/staticRegister.mjs";
-
 var _staticRegister = staticRegister('sorting.compareFunctionFactory'),
-    registerCompareFunctionFactory = _staticRegister.register,
-    getGloballyCompareFunctionFactory = _staticRegister.getItem,
-    hasGloballyCompareFunctionFactory = _staticRegister.hasItem;
-
+  registerCompareFunctionFactory = _staticRegister.register,
+  getGloballyCompareFunctionFactory = _staticRegister.getItem,
+  hasGloballyCompareFunctionFactory = _staticRegister.hasItem;
 var _staticRegister2 = staticRegister('sorting.mainSortComparator'),
-    registerRootComparator = _staticRegister2.register,
-    getRootComparator = _staticRegister2.getItem;
+  registerRootComparator = _staticRegister2.register,
+  getRootComparator = _staticRegister2.getItem;
+
 /**
  * Gets sort function for the particular column basing on it's data type.
  *
  * @param {string} type The data type.
  * @returns {Function}
  */
-
-
 export function getCompareFunctionFactory(type) {
   if (hasGloballyCompareFunctionFactory(type)) {
     return getGloballyCompareFunctionFactory(type);
   }
-
   return getGloballyCompareFunctionFactory(DEFAULT_DATA_TYPE);
 }
 registerCompareFunctionFactory(NUMERIC_DATA_TYPE, numericSort);

package/plugins/columnSorting/utils.js

@@ -7,107 +7,88 @@ exports.getHeaderSpanElement = getHeaderSpanElement;
 exports.getNextSortOrder = getNextSortOrder;
 exports.isFirstLevelColumnHeader = isFirstLevelColumnHeader;
 exports.wasHeaderClickedProperly = wasHeaderClickedProperly;
-
 require("core-js/modules/es.number.is-integer.js");
-
 require("core-js/modules/es.number.constructor.js");
-
 require("core-js/modules/es.array.includes.js");
-
 require("core-js/modules/es.object.to-string.js");
-
 require("core-js/modules/es.array.map.js");
-
 require("core-js/modules/es.array.iterator.js");
-
 require("core-js/modules/es.set.js");
-
 require("core-js/modules/es.string.iterator.js");
-
 require("core-js/modules/web.dom-collections.iterator.js");
-
 require("core-js/modules/es.array.index-of.js");
-
 require("core-js/modules/es.array.from.js");
-
 var _object = require("../../helpers/object");
-
 var _event = require("../../helpers/dom/event");
-
 var ASC_SORT_STATE = 'asc';
 exports.ASC_SORT_STATE = ASC_SORT_STATE;
 var DESC_SORT_STATE = 'desc';
 exports.DESC_SORT_STATE = DESC_SORT_STATE;
 var HEADER_SPAN_CLASS = 'colHeader';
+
 /**
  * Get if column state is valid.
  *
  * @param {number} columnState Particular column state.
  * @returns {boolean}
  */
-
 exports.HEADER_SPAN_CLASS = HEADER_SPAN_CLASS;
-
 function isValidColumnState(columnState) {
   if ((0, _object.isObject)(columnState) === false) {
     return false;
   }
-
   var column = columnState.column,
-      sortOrder = columnState.sortOrder;
+    sortOrder = columnState.sortOrder;
   return Number.isInteger(column) && [ASC_SORT_STATE, DESC_SORT_STATE].includes(sortOrder);
 }
+
 /**
  * Get if all sorted columns states are valid.
  *
  * @param {Array} sortStates The sort state collection.
  * @returns {boolean}
  */
-
-
 function areValidSortStates(sortStates) {
   if (sortStates.some(function (columnState) {
     return isValidColumnState(columnState) === false;
   })) {
     return false;
   }
-
   var sortedColumns = sortStates.map(function (_ref) {
     var column = _ref.column;
     return column;
-  }); // Indexes occurs only once.
+  });
 
+  // Indexes occurs only once.
   return new Set(sortedColumns).size === sortedColumns.length;
 }
+
 /**
  * Get next sort order for particular column. The order sequence looks as follows: 'asc' -> 'desc' -> undefined -> 'asc'.
  *
  * @param {string|undefined} sortOrder Sort order (`asc` for ascending, `desc` for descending and undefined for not sorted).
  * @returns {string|undefined} Next sort order (`asc` for ascending, `desc` for descending and undefined for not sorted).
  */
-
-
 function getNextSortOrder(sortOrder) {
   if (sortOrder === DESC_SORT_STATE) {
     return;
   } else if (sortOrder === ASC_SORT_STATE) {
     return DESC_SORT_STATE;
   }
-
   return ASC_SORT_STATE;
 }
+
 /**
  * Get `span` DOM element inside `th` DOM element.
  *
  * @param {Element} TH Th HTML element.
  * @returns {Element | null}
  */
-
-
 function getHeaderSpanElement(TH) {
   var headerSpanElement = TH.querySelector(".".concat(HEADER_SPAN_CLASS));
   return headerSpanElement;
 }
+
 /**
  *
  * Get if handled header is first level column header.
@@ -116,22 +97,18 @@ function getHeaderSpanElement(TH) {
  * @param {Element} TH Th HTML element.
  * @returns {boolean}
  */
-
-
 function isFirstLevelColumnHeader(column, TH) {
   if (column < 0 || !TH.parentNode) {
     return false;
   }
-
   var TRs = TH.parentNode.parentNode.childNodes;
   var headerLevel = Array.from(TRs).indexOf(TH.parentNode) - TRs.length;
-
   if (headerLevel !== -1) {
     return false;
   }
-
   return true;
 }
+
 /**
  *  Get if header was clicked properly. Click on column header and NOT done by right click return `true`.
  *
@@ -140,8 +117,6 @@ function isFirstLevelColumnHeader(column, TH) {
  * @param {Event} clickEvent Click event.
  * @returns {boolean}
  */
-
-
 function wasHeaderClickedProperly(row, column, clickEvent) {
   return row === -1 && column >= 0 && (0, _event.isRightClick)(clickEvent) === false;
 }

package/plugins/columnSorting/utils.mjs

@@ -14,71 +14,69 @@ import { isRightClick } from "../../helpers/dom/event.mjs";
 export var ASC_SORT_STATE = 'asc';
 export var DESC_SORT_STATE = 'desc';
 export var HEADER_SPAN_CLASS = 'colHeader';
+
 /**
  * Get if column state is valid.
  *
  * @param {number} columnState Particular column state.
  * @returns {boolean}
  */
-
 function isValidColumnState(columnState) {
   if (isObject(columnState) === false) {
     return false;
   }
-
   var column = columnState.column,
-      sortOrder = columnState.sortOrder;
+    sortOrder = columnState.sortOrder;
   return Number.isInteger(column) && [ASC_SORT_STATE, DESC_SORT_STATE].includes(sortOrder);
 }
+
 /**
  * Get if all sorted columns states are valid.
  *
  * @param {Array} sortStates The sort state collection.
  * @returns {boolean}
  */
-
-
 export function areValidSortStates(sortStates) {
   if (sortStates.some(function (columnState) {
     return isValidColumnState(columnState) === false;
   })) {
     return false;
   }
-
   var sortedColumns = sortStates.map(function (_ref) {
     var column = _ref.column;
     return column;
-  }); // Indexes occurs only once.
+  });
 
+  // Indexes occurs only once.
   return new Set(sortedColumns).size === sortedColumns.length;
 }
+
 /**
  * Get next sort order for particular column. The order sequence looks as follows: 'asc' -> 'desc' -> undefined -> 'asc'.
  *
  * @param {string|undefined} sortOrder Sort order (`asc` for ascending, `desc` for descending and undefined for not sorted).
  * @returns {string|undefined} Next sort order (`asc` for ascending, `desc` for descending and undefined for not sorted).
  */
-
 export function getNextSortOrder(sortOrder) {
   if (sortOrder === DESC_SORT_STATE) {
     return;
   } else if (sortOrder === ASC_SORT_STATE) {
     return DESC_SORT_STATE;
   }
-
   return ASC_SORT_STATE;
 }
+
 /**
  * Get `span` DOM element inside `th` DOM element.
  *
  * @param {Element} TH Th HTML element.
  * @returns {Element | null}
  */
-
 export function getHeaderSpanElement(TH) {
   var headerSpanElement = TH.querySelector(".".concat(HEADER_SPAN_CLASS));
   return headerSpanElement;
 }
+
 /**
  *
  * Get if handled header is first level column header.
@@ -87,21 +85,18 @@ export function getHeaderSpanElement(TH) {
  * @param {Element} TH Th HTML element.
  * @returns {boolean}
  */
-
 export function isFirstLevelColumnHeader(column, TH) {
   if (column < 0 || !TH.parentNode) {
     return false;
   }
-
   var TRs = TH.parentNode.parentNode.childNodes;
   var headerLevel = Array.from(TRs).indexOf(TH.parentNode) - TRs.length;
-
   if (headerLevel !== -1) {
     return false;
   }
-
   return true;
 }
+
 /**
  *  Get if header was clicked properly. Click on column header and NOT done by right click return `true`.
  *
@@ -110,7 +105,6 @@ export function isFirstLevelColumnHeader(column, TH) {
  * @param {Event} clickEvent Click event.
  * @returns {boolean}
  */
-
 export function wasHeaderClickedProperly(row, column, clickEvent) {
   return row === -1 && column >= 0 && isRightClick(clickEvent) === false;
 }