handsontable 9.0.1 → 11.0.1

package/dataMap/metaManager/mods/dynamicCellMeta.js

@@ -0,0 +1,136 @@
+"use strict";
+
+exports.__esModule = true;
+exports.DynamicCellMetaMod = 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.set.js");
+
+var _pluginHooks = _interopRequireDefault(require("../../../pluginHooks"));
+
+var _object = require("../../../helpers/object");
+
+var _function = require("../../../helpers/function");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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); return Constructor; }
+
+/**
+ * @class DynamicCellMetaMod
+ *
+ * The `DynamicCellMetaMod` modifier allows for extending cell meta objects
+ * (returned by `getCellMeta()` from `MetaManager`)
+ * by user-specific properties.
+ *
+ * The user-specific properties can be added and changed dynamically,
+ * either by Handsontable's hooks (`beforeGetCellMeta` and`afterGetCellMeta`),
+ * or by Handsontable's `cells` option.
+ *
+ * The `getCellMeta()` method is used widely throughout the source code.
+ * To boost the method's execution time,
+ * the logic is triggered only once per one Handsontable slow render cycle.
+ */
+var DynamicCellMetaMod = /*#__PURE__*/function () {
+  function DynamicCellMetaMod(metaManager) {
+    var _this = this;
+
+    _classCallCheck(this, DynamicCellMetaMod);
+
+    /**
+     * @type {MetaManager}
+     */
+    this.metaManager = metaManager;
+    /**
+     * @type {Map}
+     */
+
+    this.metaSyncMemo = new Map();
+    metaManager.addLocalHook('afterGetCellMeta', function (cellMeta) {
+      return _this.extendCellMeta(cellMeta);
+    });
+
+    _pluginHooks.default.getSingleton().add('beforeRender', function (forceFullRender) {
+      if (forceFullRender) {
+        _this.metaSyncMemo.clear();
+      }
+    }, this.metaManager.hot);
+  }
+  /**
+   * Extends the cell meta object by user-specific properties.
+   *
+   * The cell meta object can be extended dynamically,
+   * either by Handsontable's hooks (`beforeGetCellMeta` and`afterGetCellMeta`),
+   * or by Handsontable's `cells` option.
+   *
+   * To boost performance, the extending process is triggered only once per one slow Handsontable render cycle.
+   *
+   * @param {object} cellMeta The cell meta object.
+   */
+
+
+  _createClass(DynamicCellMetaMod, [{
+    key: "extendCellMeta",
+    value: function extendCellMeta(cellMeta) {
+      var _this$metaSyncMemo$ge;
+
+      var physicalRow = cellMeta.row,
+          physicalColumn = cellMeta.col;
+
+      if ((_this$metaSyncMemo$ge = this.metaSyncMemo.get(physicalRow)) !== null && _this$metaSyncMemo$ge !== void 0 && _this$metaSyncMemo$ge.has(physicalColumn)) {
+        return;
+      }
+
+      var visualRow = cellMeta.visualRow,
+          visualCol = cellMeta.visualCol;
+      var hot = this.metaManager.hot;
+      var prop = hot.colToProp(visualCol);
+      cellMeta.prop = prop;
+      hot.runHooks('beforeGetCellMeta', visualRow, visualCol, cellMeta); // extend a `type` value, added or changed in the `beforeGetCellMeta` hook
+
+      var cellType = (0, _object.hasOwnProperty)(cellMeta, 'type') ? cellMeta.type : null;
+      var cellSettings = (0, _function.isFunction)(cellMeta.cells) ? cellMeta.cells(physicalRow, physicalColumn, prop) : null;
+
+      if (cellType) {
+        if (cellSettings) {
+          var _cellSettings$type;
+
+          cellSettings.type = (_cellSettings$type = cellSettings.type) !== null && _cellSettings$type !== void 0 ? _cellSettings$type : cellType;
+        } else {
+          cellSettings = {
+            type: cellType
+          };
+        }
+      }
+
+      if (cellSettings) {
+        this.metaManager.updateCellMeta(physicalRow, physicalColumn, cellSettings);
+      }
+
+      hot.runHooks('afterGetCellMeta', visualRow, visualCol, cellMeta);
+
+      if (!this.metaSyncMemo.has(physicalRow)) {
+        this.metaSyncMemo.set(physicalRow, new Set());
+      }
+
+      this.metaSyncMemo.get(physicalRow).add(physicalColumn);
+    }
+  }]);
+
+  return DynamicCellMetaMod;
+}();
+
+exports.DynamicCellMetaMod = DynamicCellMetaMod;

package/dataMap/metaManager/mods/dynamicCellMeta.mjs

@@ -0,0 +1,119 @@
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.set.js";
+
+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); return Constructor; }
+
+import Hooks from "../../../pluginHooks.mjs";
+import { hasOwnProperty } from "../../../helpers/object.mjs";
+import { isFunction } from "../../../helpers/function.mjs";
+/**
+ * @class DynamicCellMetaMod
+ *
+ * The `DynamicCellMetaMod` modifier allows for extending cell meta objects
+ * (returned by `getCellMeta()` from `MetaManager`)
+ * by user-specific properties.
+ *
+ * The user-specific properties can be added and changed dynamically,
+ * either by Handsontable's hooks (`beforeGetCellMeta` and`afterGetCellMeta`),
+ * or by Handsontable's `cells` option.
+ *
+ * The `getCellMeta()` method is used widely throughout the source code.
+ * To boost the method's execution time,
+ * the logic is triggered only once per one Handsontable slow render cycle.
+ */
+
+export var DynamicCellMetaMod = /*#__PURE__*/function () {
+  function DynamicCellMetaMod(metaManager) {
+    var _this = this;
+
+    _classCallCheck(this, DynamicCellMetaMod);
+
+    /**
+     * @type {MetaManager}
+     */
+    this.metaManager = metaManager;
+    /**
+     * @type {Map}
+     */
+
+    this.metaSyncMemo = new Map();
+    metaManager.addLocalHook('afterGetCellMeta', function (cellMeta) {
+      return _this.extendCellMeta(cellMeta);
+    });
+    Hooks.getSingleton().add('beforeRender', function (forceFullRender) {
+      if (forceFullRender) {
+        _this.metaSyncMemo.clear();
+      }
+    }, this.metaManager.hot);
+  }
+  /**
+   * Extends the cell meta object by user-specific properties.
+   *
+   * The cell meta object can be extended dynamically,
+   * either by Handsontable's hooks (`beforeGetCellMeta` and`afterGetCellMeta`),
+   * or by Handsontable's `cells` option.
+   *
+   * To boost performance, the extending process is triggered only once per one slow Handsontable render cycle.
+   *
+   * @param {object} cellMeta The cell meta object.
+   */
+
+
+  _createClass(DynamicCellMetaMod, [{
+    key: "extendCellMeta",
+    value: function extendCellMeta(cellMeta) {
+      var _this$metaSyncMemo$ge;
+
+      var physicalRow = cellMeta.row,
+          physicalColumn = cellMeta.col;
+
+      if ((_this$metaSyncMemo$ge = this.metaSyncMemo.get(physicalRow)) !== null && _this$metaSyncMemo$ge !== void 0 && _this$metaSyncMemo$ge.has(physicalColumn)) {
+        return;
+      }
+
+      var visualRow = cellMeta.visualRow,
+          visualCol = cellMeta.visualCol;
+      var hot = this.metaManager.hot;
+      var prop = hot.colToProp(visualCol);
+      cellMeta.prop = prop;
+      hot.runHooks('beforeGetCellMeta', visualRow, visualCol, cellMeta); // extend a `type` value, added or changed in the `beforeGetCellMeta` hook
+
+      var cellType = hasOwnProperty(cellMeta, 'type') ? cellMeta.type : null;
+      var cellSettings = isFunction(cellMeta.cells) ? cellMeta.cells(physicalRow, physicalColumn, prop) : null;
+
+      if (cellType) {
+        if (cellSettings) {
+          var _cellSettings$type;
+
+          cellSettings.type = (_cellSettings$type = cellSettings.type) !== null && _cellSettings$type !== void 0 ? _cellSettings$type : cellType;
+        } else {
+          cellSettings = {
+            type: cellType
+          };
+        }
+      }
+
+      if (cellSettings) {
+        this.metaManager.updateCellMeta(physicalRow, physicalColumn, cellSettings);
+      }
+
+      hot.runHooks('afterGetCellMeta', visualRow, visualCol, cellMeta);
+
+      if (!this.metaSyncMemo.has(physicalRow)) {
+        this.metaSyncMemo.set(physicalRow, new Set());
+      }
+
+      this.metaSyncMemo.get(physicalRow).add(physicalColumn);
+    }
+  }]);
+
+  return DynamicCellMetaMod;
+}();

package/dataMap/metaManager/utils.js

@@ -1,11 +1,11 @@
 "use strict";
 
 exports.__esModule = true;
-exports.expandMetaType = expandMetaType;
-exports.columnFactory = columnFactory;
-exports.isUnsignedNumber = isUnsignedNumber;
 exports.assert = assert;
+exports.columnFactory = columnFactory;
+exports.expandMetaType = expandMetaType;
 exports.isNullish = isNullish;
+exports.isUnsignedNumber = isUnsignedNumber;
 
 require("core-js/modules/es.number.is-integer.js");
 

package/dataSource.js

@@ -7,6 +7,8 @@ require("core-js/modules/es.number.is-integer.js");
 
 require("core-js/modules/es.number.constructor.js");
 
+require("core-js/modules/es.object.to-string.js");
+
 require("core-js/modules/web.dom-collections.for-each.js");
 
 var _object = require("./helpers/object");

package/dataSource.mjs

@@ -1,5 +1,6 @@
 import "core-js/modules/es.number.is-integer.js";
 import "core-js/modules/es.number.constructor.js";
+import "core-js/modules/es.object.to-string.js";
 import "core-js/modules/web.dom-collections.for-each.js";
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }