handsontable 12.1.3 → 12.2.0

package/pluginHooks.js

@@ -1,54 +1,34 @@
 "use strict";
 
 require("core-js/modules/es.array.slice.js");
-
 require("core-js/modules/es.object.freeze.js");
-
 exports.__esModule = true;
 exports.default = void 0;
-
 require("core-js/modules/es.array.iterator.js");
-
 require("core-js/modules/es.map.js");
-
 require("core-js/modules/es.object.to-string.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.splice.js");
-
 var _array = require("./helpers/array");
-
 var _object = require("./helpers/object");
-
 var _string = require("./helpers/string");
-
 var _console = require("./helpers/console");
-
 var _templateLiteralTag = require("./helpers/templateLiteralTag");
-
 var _function = require("./helpers/function");
-
 var _templateObject;
-
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-
 function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
-
 /**
  * @description
  * Handsontable events are the common interface that function in 2 ways: as __callbacks__ and as __hooks__.
  *
  * @example
  *
+ * ::: only-for javascript
  * ```js
  * // Using events as callbacks:
  * ...
@@ -62,7 +42,25 @@ function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(
  * });
  * ...
  * ```
+ * :::
+ *
+ * ::: only-for react
+ * ```jsx
+ * <HotTable
+ *   afterChange={(changes, source) => {
+ *     fetch('save.php', {
+ *       method: 'POST',
+ *       headers: {
+ *         'Accept': 'application/json',
+ *         'Content-Type': 'application/json'
+ *       },
+ *       body: JSON.stringify(changes)
+ *     });
+ *   }}
+ * />
+ * :::
  *
+ * ::: only-for javascript
  * ```js
  * // Using events as plugin hooks:
  * ...
@@ -87,12 +85,47 @@ function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(
  *   // function body - will only run in #example2
  * });
  * ```
+ * :::
+ *
+ * ::: only-for react
+ * ```jsx
+ * const hotRef1 = useRef(null);
+ * const hotRef2 = useRef(null);
+ *
+ * // Using events as plugin hooks:
+ * ...
+ *
+ * <HotTable
+ *   ref={hotRef1}
+ *   myPlugin={true}
+ * });
+ *
+ * <HotTable
+ *   ref={hotRef2}
+ *   myPlugin={false}
+ * });
+ *
+ * ...
+ *
+ * const hot2 = hotRef2.current.hotInstance;
+ * // local hook (has same effect as a callback)
+ * hot2.addHook('afterChange', function() {
+ *   // function body - will only run in #example2
+ * });
+ *
+ * // global hook
+ * Handsontable.hooks.add('afterChange', function() {
+ *   // Fired twice - for hot1 and hot2
+ *   if (this.getSettings().myPlugin) {
+ *     // function body - will only run for first instance
+ *   }
+ * });
+ * :::
  * ...
  */
-// @TODO: Move plugin description hooks to plugin?
-var REGISTERED_HOOKS = [
-/* eslint-disable jsdoc/require-description-complete-sentence */
 
+// @TODO: Move plugin description hooks to plugin?
+var REGISTERED_HOOKS = [/* eslint-disable jsdoc/require-description-complete-sentence */
 /**
  * Fired after resetting a cell's meta. This happens when the {@link Core#updateSettings} method is called.
  *
@@ -109,15 +142,29 @@ var REGISTERED_HOOKS = [
  * @param {Array[]} changes 2D array containing information about each of the edited cells `[[row, prop, oldVal, newVal], ...]`. `row` is a visual row index.
  * @param {string} [source] String that identifies source of hook call ([list of all available sources](@/guides/getting-started/events-and-hooks.md#definition-for-source-argument)).
  * @example
+ * ::: only-for javascript
  * ```js
  * new Handsontable(element, {
  *   afterChange: (changes) => {
- *     changes.forEach(([row, prop, oldValue, newValue]) => {
+ *     changes?.forEach(([row, prop, oldValue, newValue]) => {
  *       // Some logic...
  *     });
  *   }
  * })
  * ```
+ * :::
+ *
+ * ::: only-for react
+ * ```jsx
+ * <HotTable
+ *   afterChange={(changes, source) => {
+ *     changes?.forEach(([row, prop, oldValue, newValue]) => {
+ *       // Some logic...
+ *     });
+ *   }}
+ * />
+ * ```
+ * :::
  */
 'afterChange',
 /**
@@ -200,6 +247,7 @@ var REGISTERED_HOOKS = [
  *                          ([list of all available sources](@/guides/getting-started/events-and-hooks.md#definition-for-source-argument)).
  * @returns {*} If `false` then creating columns is cancelled.
  * @example
+ * ::: only-for javascript
  * ```js
  * // Return `false` to cancel column inserting.
  * new Handsontable(element, {
@@ -208,6 +256,18 @@ var REGISTERED_HOOKS = [
  *   }
  * });
  * ```
+ * :::
+ *
+ * ::: only-for react
+ * ```jsx
+ * // Return `false` to cancel column inserting.
+ * <HotTable
+ *   beforeCreateCol={(data, coords) => {
+ *     return false;
+ *   }}
+ * />
+ * ```
+ * :::
  */
 'beforeCreateCol',
 /**
@@ -292,9 +352,13 @@ var REGISTERED_HOOKS = [
 /**
  * Fired after retrieving information about a column header and appending it to the table header.
  *
+ * Since the 12.2 the hook is triggered with the 3rd `headerLevel` argument.
+ *
  * @event Hooks#afterGetColHeader
  * @param {number} column Visual column index.
  * @param {HTMLTableCellElement} TH Header's TH element.
+ * @param {number} [headerLevel=0] The index of header level counting from the top (positive
+ *                                 values counting from 0 to N).
  */
 'afterGetColHeader',
 /**
@@ -494,6 +558,7 @@ var REGISTERED_HOOKS = [
  * @param {object} preventScrolling Object with `value` property where its value change will be observed.
  * @param {number} selectionLayerLevel The number which indicates what selection layer is currently modified.
  * @example
+ * ::: only-for javascript
  * ```js
  * new Handsontable(element, {
  *   afterSelection: (row, column, row2, column2, preventScrolling, selectionLayerLevel) => {
@@ -505,6 +570,21 @@ var REGISTERED_HOOKS = [
  *   }
  * })
  * ```
+ * :::
+ *
+ * ::: only-for react
+ * ```jsx
+ * <HotTable
+ *   afterSelection={(row, column, row2, column2, preventScrolling, selectionLayerLevel) => {
+ *     // If set to `false` (default): when cell selection is outside the viewport,
+ *     // Handsontable scrolls the viewport to cell selection's end corner.
+ *     // If set to `true`: when cell selection is outside the viewport,
+ *     // Handsontable doesn't scroll to cell selection's end corner.
+ *     preventScrolling.value = true;
+ *   }}
+ * />
+ * ```
+ * :::
  */
 'afterSelection',
 /**
@@ -521,6 +601,7 @@ var REGISTERED_HOOKS = [
  * @param {number} selectionLayerLevel The number which indicates what selection layer is currently modified.
  * @example
  * ```js
+ * ::: only-for javascript
  * new Handsontable(element, {
  *   afterSelectionByProp: (row, column, row2, column2, preventScrolling, selectionLayerLevel) => {
  *     // setting if prevent scrolling after selection
@@ -528,6 +609,18 @@ var REGISTERED_HOOKS = [
  *   }
  * })
  * ```
+ * :::
+ *
+ * ::: only-for react
+ * ```jsx
+ * <HotTable
+ *   afterSelectionByProp={(row, column, row2, column2, preventScrolling, selectionLayerLevel) => {
+ *     // setting if prevent scrolling after selection
+ *     preventScrolling.value = true;
+ *   }}
+ * />
+ * ```
+ * :::
  */
 'afterSelectionByProp',
 /**
@@ -689,8 +782,11 @@ var REGISTERED_HOOKS = [
  */
 'beforeCellAlignment',
 /**
- * Fired before one or more cells is changed. Its main purpose is to alter changes silently after input and before
- * table rendering.
+ * Fired before one or more cells are changed.
+ *
+ * Use this hook to silently alter the user's changes before Handsontable re-renders.
+ *
+ * To ignore the user's changes, use a nullified array or return `false`.
  *
  * @event Hooks#beforeChange
  * @param {Array[]} changes 2D array containing information about each of the edited cells `[[row, prop, oldVal, newVal], ...]`. `row` is a visual row index.
@@ -698,22 +794,27 @@ var REGISTERED_HOOKS = [
  *                          ([list of all available sources](@/guides/getting-started/events-and-hooks.md#definition-for-source-argument)).
  * @returns {undefined | boolean} If `false` all changes were cancelled, `true` otherwise.
  * @example
+ * ::: only-for javascript
  * ```js
- * // To disregard a single change, set changes[i] to null or remove it from array using changes.splice(i, 1).
+ * // to alter a single change, overwrite the value with `changes[i][3]`
  * new Handsontable(element, {
  *   beforeChange: (changes, source) => {
  *     // [[row, prop, oldVal, newVal], ...]
- *     changes[0] = null;
+ *     changes[0][3] = 10;
  *   }
  * });
- * // To alter a single change, overwrite the desired value to changes[i][3].
+ *
+ * // to ignore a single change, set `changes[i]` to `null`
+ * // or remove `changes[i]` from the array, by using `changes.splice(i, 1)`
  * new Handsontable(element, {
  *   beforeChange: (changes, source) => {
  *     // [[row, prop, oldVal, newVal], ...]
- *     changes[0][3] = 10;
+ *     changes[0] = null;
  *   }
  * });
- * // To cancel all edit, return false from the callback or set array length to 0 (changes.length = 0).
+ *
+ * // to ignore all changes, return `false`
+ * // or set the array's length to 0, by using `changes.length = 0`
  * new Handsontable(element, {
  *   beforeChange: (changes, source) => {
  *     // [[row, prop, oldVal, newVal], ...]
@@ -721,6 +822,37 @@ var REGISTERED_HOOKS = [
  *   }
  * });
  * ```
+ * :::
+ *
+ * ::: only-for react
+ * ```jsx
+ * // to alter a single change, overwrite the desired value with `changes[i][3]`
+ * <HotTable
+ *   beforeChange={(changes, source) => {
+ *     // [[row, prop, oldVal, newVal], ...]
+ *     changes[0][3] = 10;
+ *   }}
+ * />
+ *
+ * // to ignore a single change, set `changes[i]` to `null`
+ * // or remove `changes[i]` from the array, by using changes.splice(i, 1).
+ * <HotTable
+ *   beforeChange={(changes, source) => {
+ *     // [[row, prop, oldVal, newVal], ...]
+ *     changes[0] = null;
+ *   }}
+ * />
+ *
+ * // to ignore all changes, return `false`
+ * // or set the array's length to 0 (`changes.length = 0`)
+ * <HotTable
+ *   beforeChange={(changes, source) => {
+ *     // [[row, prop, oldVal, newVal], ...]
+ *     return false;
+ *   }}
+ * />
+ * ```
+ * :::
  */
 'beforeChange',
 /**
@@ -1186,6 +1318,7 @@ var REGISTERED_HOOKS = [
  *                       which will be cut out.
  * @returns {*} If returns `false` then operation of the cutting out is canceled.
  * @example
+ * ::: only-for javascript
  * ```js
  * // To disregard a single row, remove it from the array using data.splice(i, 1).
  * new Handsontable(element, {
@@ -1203,6 +1336,27 @@ var REGISTERED_HOOKS = [
  *   }
  * });
  * ```
+ * :::
+ *
+ * ::: only-for react
+ * ```jsx
+ * // To disregard a single row, remove it from the array using data.splice(i, 1).
+ * <HotTable
+ *   beforeCut={(data, coords) => {
+ *     // data -> [[1, 2, 3], [4, 5, 6]]
+ *     data.splice(0, 1);
+ *     // data -> [[4, 5, 6]]
+ *     // coords -> [{startRow: 0, startCol: 0, endRow: 1, endCol: 2}]
+ *   }}
+ * />
+ * // To cancel a cutting action, just return `false`.
+ * <HotTable
+ *   beforeCut={(data, coords) => {
+ *     return false;
+ *   }}
+ * />
+ * ```
+ * :::
  */
 'beforeCut',
 /**
@@ -1225,6 +1379,7 @@ var REGISTERED_HOOKS = [
  * @returns {*} If returns `false` then copying is canceled.
  *
  * @example
+ * ::: only-for javascript
  * ```js
  * // To disregard a single row, remove it from array using data.splice(i, 1).
  * ...
@@ -1247,6 +1402,32 @@ var REGISTERED_HOOKS = [
  * });
  * ...
  * ```
+ * :::
+ *
+ * ::: only-for react
+ * ```jsx
+ * // To disregard a single row, remove it from array using data.splice(i, 1).
+ * ...
+ * <HotTable
+ *   beforeCopy={(data, coords) => {
+ *     // data -> [[1, 2, 3], [4, 5, 6]]
+ *     data.splice(0, 1);
+ *     // data -> [[4, 5, 6]]
+ *     // coords -> [{startRow: 0, startCol: 0, endRow: 1, endCol: 2}]
+ *   }}
+ * />
+ * ...
+ *
+ * // To cancel copying, return false from the callback.
+ * ...
+ * <HotTable
+ *   beforeCopy={(data, coords) => {
+ *     return false;
+ *   }}
+ * />
+ * ...
+ * ```
+ * :::
  */
 'beforeCopy',
 /**
@@ -1270,6 +1451,7 @@ var REGISTERED_HOOKS = [
  * @returns {*} If returns `false` then pasting is canceled.
  * @example
  * ```js
+ * ::: only-for javascript
  * // To disregard a single row, remove it from array using data.splice(i, 1).
  * new Handsontable(example, {
  *   beforePaste: (data, coords) => {
@@ -1286,6 +1468,27 @@ var REGISTERED_HOOKS = [
  *   }
  * });
  * ```
+ * :::
+ *
+ * ::: only-for react
+ * ```jsx
+ * // To disregard a single row, remove it from array using data.splice(i, 1).
+ * <HotTable
+ *   beforePaste={(data, coords) => {
+ *     // data -> [[1, 2, 3], [4, 5, 6]]
+ *     data.splice(0, 1);
+ *     // data -> [[4, 5, 6]]
+ *     // coords -> [{startRow: 0, startCol: 0, endRow: 1, endCol: 2}]
+ *   }}
+ * />
+ * // To cancel pasting, return false from the callback.
+ * <HotTable
+ *   beforePaste={(data, coords) => {
+ *     return false;
+ *   }}
+ * />
+ * ```
+ * :::
  */
 'beforePaste',
 /**
@@ -1533,15 +1736,25 @@ var REGISTERED_HOOKS = [
  */
 'afterFilter',
 /**
- * Called when a value is updated in the engine.
+ * Fired by the {@link Formulas} plugin, when any cell value changes.
+ *
+ * Returns an array of objects that contains:
+ * - The addresses (`sheet`, `row`, `col`) and new values (`newValue`) of the changed cells.
+ * - The addresses and new values of any cells that had to be recalculated (because their formulas depend on the cells that changed).
+ *
+ * This hook gets also fired on Handsontable's initialization, returning the addresses and values of all cells.
+ *
+ * Read more:
+ * - [Guides: Formula calculation](@/guides/formulas/formula-calculation.md)
+ * - [HyperFormula documentation: `valuesUpdated`](https://hyperformula.handsontable.com/api/interfaces/listeners.html#valuesupdated)
  *
  * @since 9.0.0
  * @event Hooks#afterFormulasValuesUpdate
- * @param {Array} changes The values and location of applied changes.
+ * @param {Array} changes The addresses and new values of all the changed and recalculated cells.
  */
 'afterFormulasValuesUpdate',
 /**
- * Called when a named expression is added to the Formulas' engine instance.
+ * Fired when a named expression is added to the Formulas' engine instance.
  *
  * @since 9.0.0
  * @event Hooks#afterNamedExpressionAdded
@@ -1550,7 +1763,7 @@ var REGISTERED_HOOKS = [
  */
 'afterNamedExpressionAdded',
 /**
- * Called when a named expression is removed from the Formulas' engine instance.
+ * Fired when a named expression is removed from the Formulas' engine instance.
  *
  * @since 9.0.0
  * @event Hooks#afterNamedExpressionRemoved
@@ -1559,7 +1772,7 @@ var REGISTERED_HOOKS = [
  */
 'afterNamedExpressionRemoved',
 /**
- * Called when a new sheet is added to the Formulas' engine instance.
+ * Fired when a new sheet is added to the Formulas' engine instance.
  *
  * @since 9.0.0
  * @event Hooks#afterSheetAdded
@@ -1567,7 +1780,7 @@ var REGISTERED_HOOKS = [
  */
 'afterSheetAdded',
 /**
- * Called when a sheet in the Formulas' engine instance is renamed.
+ * Fired when a sheet in the Formulas' engine instance is renamed.
  *
  * @since 9.0.0
  * @event Hooks#afterSheetRenamed
@@ -1576,7 +1789,7 @@ var REGISTERED_HOOKS = [
  */
 'afterSheetRenamed',
 /**
- * Called when a sheet is removed from the Formulas' engine instance.
+ * Fired when a sheet is removed from the Formulas' engine instance.
  *
  * @since 9.0.0
  * @event Hooks#afterSheetRemoved
@@ -2062,13 +2275,14 @@ var REGISTERED_HOOKS = [
  * @param {*} cellValue Value of the cell.
  */
 'modifyAutoColumnSizeSeed'];
+
 /**
  * Template warning message for removed hooks.
  *
  * @type {string}
  */
-
 var REMOVED_MESSAGE = (0, _templateLiteralTag.toSingleLine)(_templateObject || (_templateObject = _taggedTemplateLiteral(["The plugin hook \"[hookName]\" was removed in Handsontable [removedInVersion]. \n  Please consult release notes https://github.com/handsontable/handsontable/releases/tag/[removedInVersion] to \n  learn about the migration path."], ["The plugin hook \"[hookName]\" was removed in Handsontable [removedInVersion].\\x20\n  Please consult release notes https://github.com/handsontable/handsontable/releases/tag/[removedInVersion] to\\x20\n  learn about the migration path."])));
+
 /**
  * The list of the hooks which are removed from the API. The warning message is printed out in
  * the developer console when the hook is used.
@@ -2078,10 +2292,9 @@ var REMOVED_MESSAGE = (0, _templateLiteralTag.toSingleLine)(_templateObject || (
  *
  * @type {Map<string, string>}
  */
-
 var REMOVED_HOOKS = new Map([['modifyRow', '8.0.0'], ['modifyCol', '8.0.0'], ['unmodifyRow', '8.0.0'], ['unmodifyCol', '8.0.0'], ['skipLengthCache', '8.0.0'], ['hiddenColumn', '8.0.0'], ['hiddenRow', '8.0.0']]);
-/* eslint-disable jsdoc/require-description-complete-sentence */
 
+/* eslint-disable jsdoc/require-description-complete-sentence */
 /**
  * The list of the hooks which are deprecated. The warning message is printed out in
  * the developer console when the hook is used.
@@ -2101,20 +2314,17 @@ var REMOVED_HOOKS = new Map([['modifyRow', '8.0.0'], ['modifyCol', '8.0.0'], ['u
  *
  * @type {Map<string, string>}
  */
-
 /* eslint-enable jsdoc/require-description-complete-sentence */
-
 var DEPRECATED_HOOKS = new Map([['beforeAutofillInsidePopulate', 'The plugin hook "beforeAutofillInsidePopulate" is deprecated and will be removed in the next major release.']]);
-
 var Hooks = /*#__PURE__*/function () {
   /**
    *
    */
   function Hooks() {
     _classCallCheck(this, Hooks);
-
     this.globalBucket = this.createEmptyBucket();
   }
+
   /**
    * Returns a new object with empty handlers related to every registered hook name.
    *
@@ -2133,40 +2343,37 @@ var Hooks = /*#__PURE__*/function () {
    * }
    * ```
    */
-
-
   _createClass(Hooks, [{
     key: "createEmptyBucket",
     value: function createEmptyBucket() {
-      var bucket = Object.create(null); // eslint-disable-next-line no-return-assign
+      var bucket = Object.create(null);
 
+      // eslint-disable-next-line no-return-assign
       (0, _array.arrayEach)(REGISTERED_HOOKS, function (hook) {
         return bucket[hook] = [];
       });
       return bucket;
     }
+
     /**
      * Get hook bucket based on the context of the object or if argument is `undefined`, get the global hook bucket.
      *
      * @param {object} [context=null] A Handsontable instance.
      * @returns {object} Returns a global or Handsontable instance bucket.
      */
-
   }, {
     key: "getBucket",
     value: function getBucket() {
       var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-
       if (context) {
         if (!context.pluginHookBucket) {
           context.pluginHookBucket = this.createEmptyBucket();
         }
-
         return context.pluginHookBucket;
       }
-
       return this.globalBucket;
     }
+
     /**
      * Adds a listener (globally or locally) to a specified hook name.
      * If the `context` parameter is provided, the hook will be added only to the instance it references.
@@ -2195,14 +2402,11 @@ var Hooks = /*#__PURE__*/function () {
      * Handsontable.hooks.add('beforeInit', [myCallback, anotherCallback]);
      * ```
      */
-
   }, {
     key: "add",
     value: function add(key, callback) {
       var _this = this;
-
       var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-
       if (Array.isArray(callback)) {
         (0, _array.arrayEach)(callback, function (c) {
           return _this.add(key, c, context);
@@ -2214,24 +2418,18 @@ var Hooks = /*#__PURE__*/function () {
             removedInVersion: REMOVED_HOOKS.get(key)
           }));
         }
-
         if (DEPRECATED_HOOKS.has(key)) {
           (0, _console.warn)(DEPRECATED_HOOKS.get(key));
         }
-
         var bucket = this.getBucket(context);
-
         if (typeof bucket[key] === 'undefined') {
           this.register(key);
           bucket[key] = [];
         }
-
         callback.skip = false;
-
         if (bucket[key].indexOf(callback) === -1) {
           // only add a hook if it has not already been added (adding the same hook twice is now silently ignored)
           var foundInitialHook = false;
-
           if (callback.initialHook) {
             (0, _array.arrayEach)(bucket[key], function (cb, i) {
               if (cb.initialHook) {
@@ -2241,15 +2439,14 @@ var Hooks = /*#__PURE__*/function () {
               }
             });
           }
-
           if (!foundInitialHook) {
             bucket[key].push(callback);
           }
         }
       }
-
       return this;
     }
+
     /**
      * Adds a listener to a specified hook. After the hook runs this listener will be automatically removed from the bucket.
      *
@@ -2263,14 +2460,11 @@ var Hooks = /*#__PURE__*/function () {
      * Handsontable.hooks.once('beforeInit', myCallback, hotInstance);
      * ```
      */
-
   }, {
     key: "once",
     value: function once(key, callback) {
       var _this2 = this;
-
       var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-
       if (Array.isArray(callback)) {
         (0, _array.arrayEach)(callback, function (c) {
           return _this2.once(key, c, context);
@@ -2280,6 +2474,7 @@ var Hooks = /*#__PURE__*/function () {
         this.add(key, callback, context);
       }
     }
+
     /**
      * Removes a listener from a hook with a given name. If the `context` argument is provided, it removes a listener from a local hook assigned to the given Handsontable instance.
      *
@@ -2294,22 +2489,20 @@ var Hooks = /*#__PURE__*/function () {
      * Handsontable.hooks.remove('beforeInit', myCallback);
      * ```
      */
-
   }, {
     key: "remove",
     value: function remove(key, callback) {
       var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
       var bucket = this.getBucket(context);
-
       if (typeof bucket[key] !== 'undefined') {
         if (bucket[key].indexOf(callback) >= 0) {
           callback.skip = true;
           return true;
         }
       }
-
       return false;
     }
+
     /**
      * Checks whether there are any registered listeners for the provided hook name.
      * If the `context` parameter is provided, it only checks for listeners assigned to the given Handsontable instance.
@@ -2318,7 +2511,6 @@ var Hooks = /*#__PURE__*/function () {
      * @param {object} [context=null] A Handsontable instance.
      * @returns {boolean} `true` for success, `false` otherwise.
      */
-
   }, {
     key: "has",
     value: function has(key) {
@@ -2326,6 +2518,7 @@ var Hooks = /*#__PURE__*/function () {
       var bucket = this.getBucket(context);
       return !!(bucket[key] !== void 0 && bucket[key].length);
     }
+
     /**
      * Runs all local and global callbacks assigned to the hook identified by the `key` parameter.
      * It returns either a return value from the last called callback or the first parameter (`p1`) passed to the `run` function.
@@ -2346,7 +2539,6 @@ var Hooks = /*#__PURE__*/function () {
      * Handsontable.hooks.run(hot, 'beforeInit');
      * ```
      */
-
   }, {
     key: "run",
     value: function run(context, key, p1, p2, p3, p4, p5, p6) {
@@ -2354,66 +2546,53 @@ var Hooks = /*#__PURE__*/function () {
         var globalHandlers = this.globalBucket[key];
         var length = globalHandlers ? globalHandlers.length : 0;
         var index = 0;
-
         if (length) {
           // Do not optimise this loop with arrayEach or arrow function! If you do You'll decrease perf because of GC.
           while (index < length) {
             if (!globalHandlers[index] || globalHandlers[index].skip) {
               index += 1;
               /* eslint-disable no-continue */
-
               continue;
             }
-
             var res = (0, _function.fastCall)(globalHandlers[index], context, p1, p2, p3, p4, p5, p6);
-
             if (res !== void 0) {
               // eslint-disable-next-line no-param-reassign
               p1 = res;
             }
-
             if (globalHandlers[index] && globalHandlers[index].runOnce) {
               this.remove(key, globalHandlers[index]);
             }
-
             index += 1;
           }
         }
       }
       {
         var localHandlers = this.getBucket(context)[key];
-
         var _length = localHandlers ? localHandlers.length : 0;
-
         var _index = 0;
-
         if (_length) {
           // Do not optimise this loop with arrayEach or arrow function! If you do You'll decrease perf because of GC.
           while (_index < _length) {
             if (!localHandlers[_index] || localHandlers[_index].skip) {
               _index += 1;
               /* eslint-disable no-continue */
-
               continue;
             }
-
             var _res = (0, _function.fastCall)(localHandlers[_index], context, p1, p2, p3, p4, p5, p6);
-
             if (_res !== void 0) {
               // eslint-disable-next-line no-param-reassign
               p1 = _res;
             }
-
             if (localHandlers[_index] && localHandlers[_index].runOnce) {
               this.remove(key, localHandlers[_index], context);
             }
-
             _index += 1;
           }
         }
       }
       return p1;
     }
+
     /**
      * Destroy all listeners connected to the context. If no context is provided, the global listeners will be destroyed.
      *
@@ -2427,7 +2606,6 @@ var Hooks = /*#__PURE__*/function () {
      * Handsontable.hooks.destroy(hotInstance);
      * ```
      */
-
   }, {
     key: "destroy",
     value: function destroy() {
@@ -2437,6 +2615,7 @@ var Hooks = /*#__PURE__*/function () {
         return bucket[key].length = 0;
       });
     }
+
     /**
      * Registers a hook name (adds it to the list of the known hook names). Used by plugins.
      * It is not necessary to call register, but if you use it, your plugin hook will be used returned by
@@ -2449,7 +2628,6 @@ var Hooks = /*#__PURE__*/function () {
      * Handsontable.hooks.register('myHook');
      * ```
      */
-
   }, {
     key: "register",
     value: function register(key) {
@@ -2457,6 +2635,7 @@ var Hooks = /*#__PURE__*/function () {
         REGISTERED_HOOKS.push(key);
       }
     }
+
     /**
      * Deregisters a hook name (removes it from the list of known hook names).
      *
@@ -2467,7 +2646,6 @@ var Hooks = /*#__PURE__*/function () {
      * Handsontable.hooks.deregister('myHook');
      * ```
      */
-
   }, {
     key: "deregister",
     value: function deregister(key) {
@@ -2475,6 +2653,7 @@ var Hooks = /*#__PURE__*/function () {
         REGISTERED_HOOKS.splice(REGISTERED_HOOKS.indexOf(key), 1);
       }
     }
+
     /**
      * Returns a boolean value depending on if a hook by such name has been removed or deprecated.
      *
@@ -2489,12 +2668,12 @@ var Hooks = /*#__PURE__*/function () {
      * true
      * ```
      */
-
   }, {
     key: "isDeprecated",
     value: function isDeprecated(hookName) {
       return DEPRECATED_HOOKS.has(hookName) || REMOVED_HOOKS.has(hookName);
     }
+
     /**
      * Returns a boolean depending on if a hook by such name has been registered.
      *
@@ -2508,12 +2687,12 @@ var Hooks = /*#__PURE__*/function () {
      * true
      * ```
      */
-
   }, {
     key: "isRegistered",
     value: function isRegistered(hookName) {
       return REGISTERED_HOOKS.indexOf(hookName) >= 0;
     }
+
     /**
      * Returns an array of registered hooks.
      *
@@ -2535,7 +2714,6 @@ var Hooks = /*#__PURE__*/function () {
      * ]
      * ```
      */
-
   }, {
     key: "getRegistered",
     value: function getRegistered() {
@@ -2547,18 +2725,15 @@ var Hooks = /*#__PURE__*/function () {
       return getGlobalSingleton();
     }
   }]);
-
   return Hooks;
 }();
-
 var globalSingleton = new Hooks();
+
 /**
  * @returns {Hooks}
  */
-
 function getGlobalSingleton() {
   return globalSingleton;
 }
-
 var _default = Hooks;
 exports.default = _default;