handsontable 0.0.0-next-9ec04ce-20221121

package/3rdparty/walkontable/src/utils/orderView/sharedView.js

@@ -0,0 +1,81 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.reflect.construct.js");
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.symbol.iterator.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+exports.__esModule = true;
+exports.default = void 0;
+require("core-js/modules/es.object.set-prototype-of.js");
+require("core-js/modules/es.object.get-prototype-of.js");
+var _view = _interopRequireDefault(require("./view"));
+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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+/**
+ * Executive model for TR root nodes.
+ *
+ * @class {SharedOrderView}
+ */
+var SharedOrderView = /*#__PURE__*/function (_OrderView) {
+  _inherits(SharedOrderView, _OrderView);
+  var _super = _createSuper(SharedOrderView);
+  function SharedOrderView() {
+    _classCallCheck(this, SharedOrderView);
+    return _super.apply(this, arguments);
+  }
+  _createClass(SharedOrderView, [{
+    key: "prependView",
+    value:
+    /**
+     * The method results in merging external order view into the current order. This happens only for order views which
+     * operate on the same root node.
+     *
+     * In the table, there is only one scenario when this happens. TR root element
+     * has a common root node with cells order view and row headers order view. Both classes have to share
+     * information about their order sizes to make proper diff calculations.
+     *
+     * @param {OrderView} orderView The order view to merging with. The view will be added at the beginning of the list.
+     * @returns {SharedOrderView}
+     */
+    function prependView(orderView) {
+      this.sizeSet.prepend(orderView.sizeSet);
+      orderView.sizeSet.append(this.sizeSet);
+      return this;
+    }
+
+    /**
+     * The method results in merging external order view into the current order. This happens only for order views which
+     * operate on the same root node.
+     *
+     * In the table, there is only one scenario when this happens. TR root element
+     * has a common root node with cells order view and row headers order view. Both classes have to share
+     * information about their order sizes to make proper diff calculations.
+     *
+     * @param {OrderView} orderView The order view to merging with. The view will be added at the end of the list.
+     * @returns {SharedOrderView}
+     */
+  }, {
+    key: "appendView",
+    value: function appendView(orderView) {
+      this.sizeSet.append(orderView.sizeSet);
+      orderView.sizeSet.prepend(this.sizeSet);
+      return this;
+    }
+  }]);
+  return SharedOrderView;
+}(_view.default);
+exports.default = SharedOrderView;

package/3rdparty/walkontable/src/utils/orderView/sharedView.mjs

@@ -0,0 +1,76 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+import "core-js/modules/es.object.set-prototype-of.js";
+import "core-js/modules/es.object.get-prototype-of.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.reflect.construct.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.iterator.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import OrderView from "./view.mjs";
+/**
+ * Executive model for TR root nodes.
+ *
+ * @class {SharedOrderView}
+ */
+var SharedOrderView = /*#__PURE__*/function (_OrderView) {
+  _inherits(SharedOrderView, _OrderView);
+  var _super = _createSuper(SharedOrderView);
+  function SharedOrderView() {
+    _classCallCheck(this, SharedOrderView);
+    return _super.apply(this, arguments);
+  }
+  _createClass(SharedOrderView, [{
+    key: "prependView",
+    value:
+    /**
+     * The method results in merging external order view into the current order. This happens only for order views which
+     * operate on the same root node.
+     *
+     * In the table, there is only one scenario when this happens. TR root element
+     * has a common root node with cells order view and row headers order view. Both classes have to share
+     * information about their order sizes to make proper diff calculations.
+     *
+     * @param {OrderView} orderView The order view to merging with. The view will be added at the beginning of the list.
+     * @returns {SharedOrderView}
+     */
+    function prependView(orderView) {
+      this.sizeSet.prepend(orderView.sizeSet);
+      orderView.sizeSet.append(this.sizeSet);
+      return this;
+    }
+
+    /**
+     * The method results in merging external order view into the current order. This happens only for order views which
+     * operate on the same root node.
+     *
+     * In the table, there is only one scenario when this happens. TR root element
+     * has a common root node with cells order view and row headers order view. Both classes have to share
+     * information about their order sizes to make proper diff calculations.
+     *
+     * @param {OrderView} orderView The order view to merging with. The view will be added at the end of the list.
+     * @returns {SharedOrderView}
+     */
+  }, {
+    key: "appendView",
+    value: function appendView(orderView) {
+      this.sizeSet.append(orderView.sizeSet);
+      orderView.sizeSet.prepend(this.sizeSet);
+      return this;
+    }
+  }]);
+  return SharedOrderView;
+}(OrderView);
+export { SharedOrderView as default };

package/3rdparty/walkontable/src/utils/orderView/view.js

@@ -0,0 +1,216 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _constants = require("./constants");
+var _viewSizeSet = _interopRequireDefault(require("./viewSizeSet"));
+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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+/**
+ * Executive model for each table renderer. It's responsible for injecting DOM nodes in a
+ * specified order and adjusting the number of elements in the root node.
+ *
+ * Only this class have rights to juggling DOM elements within the root node (see render method).
+ *
+ * @class {OrderView}
+ */
+var OrderView = /*#__PURE__*/function () {
+  function OrderView(rootNode, nodesPool, childNodeType) {
+    _classCallCheck(this, OrderView);
+    /**
+     * The root node to manage with.
+     *
+     * @type {HTMLElement}
+     */
+    this.rootNode = rootNode;
+    /**
+     * Factory for newly created DOM elements.
+     *
+     * @type {Function}
+     */
+    this.nodesPool = nodesPool;
+    /**
+     * Holder for sizing and positioning of the view.
+     *
+     * @type {ViewSizeSet}
+     */
+    this.sizeSet = new _viewSizeSet.default();
+    /**
+     * Node type which the order view will manage while rendering the DOM elements.
+     *
+     * @type {string}
+     */
+    this.childNodeType = childNodeType.toUpperCase();
+    /**
+     * The visual index of currently processed row.
+     *
+     * @type {number}
+     */
+    this.visualIndex = 0;
+    /**
+     * The list of DOM elements which are rendered for this render cycle.
+     *
+     * @type {HTMLElement[]}
+     */
+    this.collectedNodes = [];
+  }
+
+  /**
+   * Sets the size for rendered elements. It can be a size for rows, cells or size for row
+   * headers etc. It depends for what table renderer this instance was created.
+   *
+   * @param {number} size The size.
+   * @returns {OrderView}
+   */
+  _createClass(OrderView, [{
+    key: "setSize",
+    value: function setSize(size) {
+      this.sizeSet.setSize(size);
+      return this;
+    }
+
+    /**
+     * Sets the offset for rendered elements. The offset describes the shift between 0 and
+     * the first rendered element according to the scroll position.
+     *
+     * @param {number} offset The offset.
+     * @returns {OrderView}
+     */
+  }, {
+    key: "setOffset",
+    value: function setOffset(offset) {
+      this.sizeSet.setOffset(offset);
+      return this;
+    }
+
+    /**
+     * Checks if this instance of the view shares the root node with another instance. This happens only once when
+     * a row (TR) as a root node is managed by two OrderView instances. If this happens another DOM injection
+     * algorithm is performed to achieve consistent order.
+     *
+     * @returns {boolean}
+     */
+  }, {
+    key: "isSharedViewSet",
+    value: function isSharedViewSet() {
+      return this.sizeSet.isShared();
+    }
+
+    /**
+     * Returns rendered DOM element based on visual index.
+     *
+     * @param {number} visualIndex The visual index.
+     * @returns {HTMLElement}
+     */
+  }, {
+    key: "getNode",
+    value: function getNode(visualIndex) {
+      return visualIndex < this.collectedNodes.length ? this.collectedNodes[visualIndex] : null;
+    }
+
+    /**
+     * Returns currently processed DOM element.
+     *
+     * @returns {HTMLElement}
+     */
+  }, {
+    key: "getCurrentNode",
+    value: function getCurrentNode() {
+      var length = this.collectedNodes.length;
+      return length > 0 ? this.collectedNodes[length - 1] : null;
+    }
+
+    /**
+     * Returns rendered child count for this instance.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "getRenderedChildCount",
+    value: function getRenderedChildCount() {
+      var rootNode = this.rootNode,
+        sizeSet = this.sizeSet;
+      var childElementCount = 0;
+      if (this.isSharedViewSet()) {
+        var element = rootNode.firstElementChild;
+        while (element) {
+          if (element.tagName === this.childNodeType) {
+            childElementCount += 1;
+          } else if (sizeSet.isPlaceOn(_constants.WORKING_SPACE_TOP)) {
+            break;
+          }
+          element = element.nextElementSibling;
+        }
+      } else {
+        childElementCount = rootNode.childElementCount;
+      }
+      return childElementCount;
+    }
+
+    /**
+     * Setups and prepares all necessary properties and start the rendering process.
+     * This method has to be called only once (at the start) for the render cycle.
+     */
+  }, {
+    key: "start",
+    value: function start() {
+      this.collectedNodes.length = 0;
+      this.visualIndex = 0;
+      var rootNode = this.rootNode,
+        sizeSet = this.sizeSet;
+      var isShared = this.isSharedViewSet();
+      var _sizeSet$getViewSize = sizeSet.getViewSize(),
+        nextSize = _sizeSet$getViewSize.nextSize;
+      var childElementCount = this.getRenderedChildCount();
+      while (childElementCount < nextSize) {
+        var newNode = this.nodesPool();
+        if (!isShared || isShared && sizeSet.isPlaceOn(_constants.WORKING_SPACE_BOTTOM)) {
+          rootNode.appendChild(newNode);
+        } else {
+          rootNode.insertBefore(newNode, rootNode.firstChild);
+        }
+        childElementCount += 1;
+      }
+      var isSharedPlacedOnTop = isShared && sizeSet.isPlaceOn(_constants.WORKING_SPACE_TOP);
+      while (childElementCount > nextSize) {
+        rootNode.removeChild(isSharedPlacedOnTop ? rootNode.firstChild : rootNode.lastChild);
+        childElementCount -= 1;
+      }
+    }
+
+    /**
+     * Renders the DOM element based on visual index (which is calculated internally).
+     * This method has to be called as many times as the size count is met (to cover all previously rendered DOM elements).
+     */
+  }, {
+    key: "render",
+    value: function render() {
+      var rootNode = this.rootNode,
+        sizeSet = this.sizeSet;
+      var visualIndex = this.visualIndex;
+      if (this.isSharedViewSet() && sizeSet.isPlaceOn(_constants.WORKING_SPACE_BOTTOM)) {
+        visualIndex += sizeSet.sharedSize.nextSize;
+      }
+      var node = rootNode.childNodes[visualIndex];
+      if (node.tagName !== this.childNodeType) {
+        var newNode = this.nodesPool();
+        rootNode.replaceChild(newNode, node);
+        node = newNode;
+      }
+      this.collectedNodes.push(node);
+      this.visualIndex += 1;
+    }
+
+    /**
+     * Ends the render process.
+     * This method has to be called only once (at the end) for the render cycle.
+     */
+  }, {
+    key: "end",
+    value: function end() {}
+  }]);
+  return OrderView;
+}();
+exports.default = OrderView;

package/3rdparty/walkontable/src/utils/orderView/view.mjs

@@ -0,0 +1,211 @@
+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; }
+import { WORKING_SPACE_TOP, WORKING_SPACE_BOTTOM } from "./constants.mjs";
+import ViewSizeSet from "./viewSizeSet.mjs";
+/**
+ * Executive model for each table renderer. It's responsible for injecting DOM nodes in a
+ * specified order and adjusting the number of elements in the root node.
+ *
+ * Only this class have rights to juggling DOM elements within the root node (see render method).
+ *
+ * @class {OrderView}
+ */
+var OrderView = /*#__PURE__*/function () {
+  function OrderView(rootNode, nodesPool, childNodeType) {
+    _classCallCheck(this, OrderView);
+    /**
+     * The root node to manage with.
+     *
+     * @type {HTMLElement}
+     */
+    this.rootNode = rootNode;
+    /**
+     * Factory for newly created DOM elements.
+     *
+     * @type {Function}
+     */
+    this.nodesPool = nodesPool;
+    /**
+     * Holder for sizing and positioning of the view.
+     *
+     * @type {ViewSizeSet}
+     */
+    this.sizeSet = new ViewSizeSet();
+    /**
+     * Node type which the order view will manage while rendering the DOM elements.
+     *
+     * @type {string}
+     */
+    this.childNodeType = childNodeType.toUpperCase();
+    /**
+     * The visual index of currently processed row.
+     *
+     * @type {number}
+     */
+    this.visualIndex = 0;
+    /**
+     * The list of DOM elements which are rendered for this render cycle.
+     *
+     * @type {HTMLElement[]}
+     */
+    this.collectedNodes = [];
+  }
+
+  /**
+   * Sets the size for rendered elements. It can be a size for rows, cells or size for row
+   * headers etc. It depends for what table renderer this instance was created.
+   *
+   * @param {number} size The size.
+   * @returns {OrderView}
+   */
+  _createClass(OrderView, [{
+    key: "setSize",
+    value: function setSize(size) {
+      this.sizeSet.setSize(size);
+      return this;
+    }
+
+    /**
+     * Sets the offset for rendered elements. The offset describes the shift between 0 and
+     * the first rendered element according to the scroll position.
+     *
+     * @param {number} offset The offset.
+     * @returns {OrderView}
+     */
+  }, {
+    key: "setOffset",
+    value: function setOffset(offset) {
+      this.sizeSet.setOffset(offset);
+      return this;
+    }
+
+    /**
+     * Checks if this instance of the view shares the root node with another instance. This happens only once when
+     * a row (TR) as a root node is managed by two OrderView instances. If this happens another DOM injection
+     * algorithm is performed to achieve consistent order.
+     *
+     * @returns {boolean}
+     */
+  }, {
+    key: "isSharedViewSet",
+    value: function isSharedViewSet() {
+      return this.sizeSet.isShared();
+    }
+
+    /**
+     * Returns rendered DOM element based on visual index.
+     *
+     * @param {number} visualIndex The visual index.
+     * @returns {HTMLElement}
+     */
+  }, {
+    key: "getNode",
+    value: function getNode(visualIndex) {
+      return visualIndex < this.collectedNodes.length ? this.collectedNodes[visualIndex] : null;
+    }
+
+    /**
+     * Returns currently processed DOM element.
+     *
+     * @returns {HTMLElement}
+     */
+  }, {
+    key: "getCurrentNode",
+    value: function getCurrentNode() {
+      var length = this.collectedNodes.length;
+      return length > 0 ? this.collectedNodes[length - 1] : null;
+    }
+
+    /**
+     * Returns rendered child count for this instance.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "getRenderedChildCount",
+    value: function getRenderedChildCount() {
+      var rootNode = this.rootNode,
+        sizeSet = this.sizeSet;
+      var childElementCount = 0;
+      if (this.isSharedViewSet()) {
+        var element = rootNode.firstElementChild;
+        while (element) {
+          if (element.tagName === this.childNodeType) {
+            childElementCount += 1;
+          } else if (sizeSet.isPlaceOn(WORKING_SPACE_TOP)) {
+            break;
+          }
+          element = element.nextElementSibling;
+        }
+      } else {
+        childElementCount = rootNode.childElementCount;
+      }
+      return childElementCount;
+    }
+
+    /**
+     * Setups and prepares all necessary properties and start the rendering process.
+     * This method has to be called only once (at the start) for the render cycle.
+     */
+  }, {
+    key: "start",
+    value: function start() {
+      this.collectedNodes.length = 0;
+      this.visualIndex = 0;
+      var rootNode = this.rootNode,
+        sizeSet = this.sizeSet;
+      var isShared = this.isSharedViewSet();
+      var _sizeSet$getViewSize = sizeSet.getViewSize(),
+        nextSize = _sizeSet$getViewSize.nextSize;
+      var childElementCount = this.getRenderedChildCount();
+      while (childElementCount < nextSize) {
+        var newNode = this.nodesPool();
+        if (!isShared || isShared && sizeSet.isPlaceOn(WORKING_SPACE_BOTTOM)) {
+          rootNode.appendChild(newNode);
+        } else {
+          rootNode.insertBefore(newNode, rootNode.firstChild);
+        }
+        childElementCount += 1;
+      }
+      var isSharedPlacedOnTop = isShared && sizeSet.isPlaceOn(WORKING_SPACE_TOP);
+      while (childElementCount > nextSize) {
+        rootNode.removeChild(isSharedPlacedOnTop ? rootNode.firstChild : rootNode.lastChild);
+        childElementCount -= 1;
+      }
+    }
+
+    /**
+     * Renders the DOM element based on visual index (which is calculated internally).
+     * This method has to be called as many times as the size count is met (to cover all previously rendered DOM elements).
+     */
+  }, {
+    key: "render",
+    value: function render() {
+      var rootNode = this.rootNode,
+        sizeSet = this.sizeSet;
+      var visualIndex = this.visualIndex;
+      if (this.isSharedViewSet() && sizeSet.isPlaceOn(WORKING_SPACE_BOTTOM)) {
+        visualIndex += sizeSet.sharedSize.nextSize;
+      }
+      var node = rootNode.childNodes[visualIndex];
+      if (node.tagName !== this.childNodeType) {
+        var newNode = this.nodesPool();
+        rootNode.replaceChild(newNode, node);
+        node = newNode;
+      }
+      this.collectedNodes.push(node);
+      this.visualIndex += 1;
+    }
+
+    /**
+     * Ends the render process.
+     * This method has to be called only once (at the end) for the render cycle.
+     */
+  }, {
+    key: "end",
+    value: function end() {}
+  }]);
+  return OrderView;
+}();
+export { OrderView as default };

package/3rdparty/walkontable/src/utils/orderView/viewSize.js

@@ -0,0 +1,68 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+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; }
+/**
+ * Holder for current and next size (count of rendered and to render DOM elements) and offset.
+ *
+ * @class {ViewSize}
+ */
+var ViewSize = /*#__PURE__*/function () {
+  function ViewSize() {
+    _classCallCheck(this, ViewSize);
+    /**
+     * Current size of the rendered DOM elements.
+     *
+     * @type {number}
+     */
+    this.currentSize = 0;
+    /**
+     * Next size of the rendered DOM elements which should be fulfilled.
+     *
+     * @type {number}
+     */
+    this.nextSize = 0;
+    /**
+     * Current offset.
+     *
+     * @type {number}
+     */
+    this.currentOffset = 0;
+    /**
+     * Next ofset.
+     *
+     * @type {number}
+     */
+    this.nextOffset = 0;
+  }
+
+  /**
+   * Sets new size of the rendered DOM elements.
+   *
+   * @param {number} size The size.
+   */
+  _createClass(ViewSize, [{
+    key: "setSize",
+    value: function setSize(size) {
+      this.currentSize = this.nextSize;
+      this.nextSize = size;
+    }
+
+    /**
+     * Sets new offset.
+     *
+     * @param {number} offset The offset.
+     */
+  }, {
+    key: "setOffset",
+    value: function setOffset(offset) {
+      this.currentOffset = this.nextOffset;
+      this.nextOffset = offset;
+    }
+  }]);
+  return ViewSize;
+}();
+exports.default = ViewSize;