handsontable 0.0.0-next-9ec04ce-20221121

package/utils/dataStructures/priorityMap.mjs

@@ -0,0 +1,99 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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.array.map.js";
+import "core-js/modules/es.array.sort.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.slice.js";
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.regexp.exec.js";
+import { isNumeric } from "../../helpers/number.mjs";
+import { isFunction } from "../../helpers/function.mjs";
+export var ASC = 'asc';
+export var DESC = 'desc';
+var ORDER_MAP = new Map([[ASC, [-1, 1]], [DESC, [1, -1]]]);
+var DEFAULT_ERROR_PRIORITY_EXISTS = function DEFAULT_ERROR_PRIORITY_EXISTS(priority) {
+  return "The priority '".concat(priority, "' is already declared in a map.");
+};
+var DEFAULT_ERROR_PRIORITY_NAN = function DEFAULT_ERROR_PRIORITY_NAN(priority) {
+  return "The priority '".concat(priority, "' is not a number.");
+};
+
+/**
+ * @typedef {object} PriorityMap
+ * @property {Function} addItem Adds items to the priority map.
+ * @property {Function} getItems Gets items from the passed map in a ASC or DESC order of priorities.
+ */
+/**
+ * Creates a new priority map.
+ *
+ * @param {object} config The config for priority map.
+ * @param {Function} config.errorPriorityExists The function to generate a custom error message if priority is already taken.
+ * @param {Function} config.errorPriorityNaN The function to generate a custom error message if priority is not a number.
+ * @returns {PriorityMap}
+ */
+export function createPriorityMap() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    errorPriorityExists = _ref.errorPriorityExists,
+    errorPriorityNaN = _ref.errorPriorityNaN;
+  var priorityMap = new Map();
+  errorPriorityExists = isFunction(errorPriorityExists) ? errorPriorityExists : DEFAULT_ERROR_PRIORITY_EXISTS;
+  errorPriorityNaN = isFunction(errorPriorityNaN) ? errorPriorityNaN : DEFAULT_ERROR_PRIORITY_NAN;
+
+  /**
+   * Adds items to priority map. Throws an error if `priority` is not a number or if is already added.
+   *
+   * @param {number} priority The priority for adding item.
+   * @param {*} item The adding item.
+   */
+  function addItem(priority, item) {
+    if (!isNumeric(priority)) {
+      throw new Error(errorPriorityNaN(priority));
+    }
+    if (priorityMap.has(priority)) {
+      throw new Error(errorPriorityExists(priority));
+    }
+    priorityMap.set(priority, item);
+  }
+
+  /**
+   * Gets items from the passed map in a ASC or DESC order of priorities.
+   *
+   * @param {string} [order] The order for getting items. ASC is an default.
+   * @returns {*}
+   */
+  function getItems() {
+    var order = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ASC;
+    var _ref2 = ORDER_MAP.get(order) || ORDER_MAP.get(ASC),
+      _ref3 = _slicedToArray(_ref2, 2),
+      left = _ref3[0],
+      right = _ref3[1];
+    return _toConsumableArray(priorityMap) // we want to be sure we sort over a priority key
+    // if we are sure we can remove custom compare function
+    // then we should replace next line with a default `.sort()`
+    .sort(function (a, b) {
+      return a[0] < b[0] ? left : right;
+    }).map(function (item) {
+      return item[1];
+    });
+  }
+  return {
+    addItem: addItem,
+    getItems: getItems
+  };
+}

package/utils/dataStructures/queue.js

@@ -0,0 +1,83 @@
+"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; }
+/**
+ * @class Queue
+ * @util
+ */
+var Queue = /*#__PURE__*/function () {
+  function Queue() {
+    var initial = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    _classCallCheck(this, Queue);
+    /**
+     * Items collection.
+     *
+     * @type {Array}
+     */
+    this.items = initial;
+  }
+
+  /**
+   * Add new item or items at the back of the queue.
+   *
+   * @param {*} items An item to add.
+   */
+  _createClass(Queue, [{
+    key: "enqueue",
+    value: function enqueue() {
+      var _this$items;
+      (_this$items = this.items).push.apply(_this$items, arguments);
+    }
+
+    /**
+     * Remove the first element from the queue and returns it.
+     *
+     * @returns {*}
+     */
+  }, {
+    key: "dequeue",
+    value: function dequeue() {
+      return this.items.shift();
+    }
+
+    /**
+     * Return the first element from the queue (without modification queue stack).
+     *
+     * @returns {*}
+     */
+  }, {
+    key: "peek",
+    value: function peek() {
+      return this.isEmpty() ? void 0 : this.items[0];
+    }
+
+    /**
+     * Check if the queue is empty.
+     *
+     * @returns {boolean}
+     */
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return !this.size();
+    }
+
+    /**
+     * Return number of elements in the queue.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "size",
+    value: function size() {
+      return this.items.length;
+    }
+  }]);
+  return Queue;
+}();
+var _default = Queue;
+exports.default = _default;

package/utils/dataStructures/queue.mjs

@@ -0,0 +1,78 @@
+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; }
+/**
+ * @class Queue
+ * @util
+ */
+var Queue = /*#__PURE__*/function () {
+  function Queue() {
+    var initial = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    _classCallCheck(this, Queue);
+    /**
+     * Items collection.
+     *
+     * @type {Array}
+     */
+    this.items = initial;
+  }
+
+  /**
+   * Add new item or items at the back of the queue.
+   *
+   * @param {*} items An item to add.
+   */
+  _createClass(Queue, [{
+    key: "enqueue",
+    value: function enqueue() {
+      var _this$items;
+      (_this$items = this.items).push.apply(_this$items, arguments);
+    }
+
+    /**
+     * Remove the first element from the queue and returns it.
+     *
+     * @returns {*}
+     */
+  }, {
+    key: "dequeue",
+    value: function dequeue() {
+      return this.items.shift();
+    }
+
+    /**
+     * Return the first element from the queue (without modification queue stack).
+     *
+     * @returns {*}
+     */
+  }, {
+    key: "peek",
+    value: function peek() {
+      return this.isEmpty() ? void 0 : this.items[0];
+    }
+
+    /**
+     * Check if the queue is empty.
+     *
+     * @returns {boolean}
+     */
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return !this.size();
+    }
+
+    /**
+     * Return number of elements in the queue.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "size",
+    value: function size() {
+      return this.items.length;
+    }
+  }]);
+  return Queue;
+}();
+export default Queue;

package/utils/dataStructures/stack.js

@@ -0,0 +1,83 @@
+"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; }
+/**
+ * @class Stack
+ * @util
+ */
+var Stack = /*#__PURE__*/function () {
+  function Stack() {
+    var initial = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    _classCallCheck(this, Stack);
+    /**
+     * Items collection.
+     *
+     * @type {Array}
+     */
+    this.items = initial;
+  }
+
+  /**
+   * Add new item or items at the back of the stack.
+   *
+   * @param {*} items An item to add.
+   */
+  _createClass(Stack, [{
+    key: "push",
+    value: function push() {
+      var _this$items;
+      (_this$items = this.items).push.apply(_this$items, arguments);
+    }
+
+    /**
+     * Remove the last element from the stack and returns it.
+     *
+     * @returns {*}
+     */
+  }, {
+    key: "pop",
+    value: function pop() {
+      return this.items.pop();
+    }
+
+    /**
+     * Return the last element from the stack (without modification stack).
+     *
+     * @returns {*}
+     */
+  }, {
+    key: "peek",
+    value: function peek() {
+      return this.isEmpty() ? void 0 : this.items[this.items.length - 1];
+    }
+
+    /**
+     * Check if the stack is empty.
+     *
+     * @returns {boolean}
+     */
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return !this.size();
+    }
+
+    /**
+     * Return number of elements in the stack.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "size",
+    value: function size() {
+      return this.items.length;
+    }
+  }]);
+  return Stack;
+}();
+var _default = Stack;
+exports.default = _default;

package/utils/dataStructures/stack.mjs

@@ -0,0 +1,78 @@
+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; }
+/**
+ * @class Stack
+ * @util
+ */
+var Stack = /*#__PURE__*/function () {
+  function Stack() {
+    var initial = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    _classCallCheck(this, Stack);
+    /**
+     * Items collection.
+     *
+     * @type {Array}
+     */
+    this.items = initial;
+  }
+
+  /**
+   * Add new item or items at the back of the stack.
+   *
+   * @param {*} items An item to add.
+   */
+  _createClass(Stack, [{
+    key: "push",
+    value: function push() {
+      var _this$items;
+      (_this$items = this.items).push.apply(_this$items, arguments);
+    }
+
+    /**
+     * Remove the last element from the stack and returns it.
+     *
+     * @returns {*}
+     */
+  }, {
+    key: "pop",
+    value: function pop() {
+      return this.items.pop();
+    }
+
+    /**
+     * Return the last element from the stack (without modification stack).
+     *
+     * @returns {*}
+     */
+  }, {
+    key: "peek",
+    value: function peek() {
+      return this.isEmpty() ? void 0 : this.items[this.items.length - 1];
+    }
+
+    /**
+     * Check if the stack is empty.
+     *
+     * @returns {boolean}
+     */
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return !this.size();
+    }
+
+    /**
+     * Return number of elements in the stack.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "size",
+    value: function size() {
+      return this.items.length;
+    }
+  }]);
+  return Stack;
+}();
+export default Stack;

package/utils/dataStructures/tree.js

@@ -0,0 +1,254 @@
+"use strict";
+
+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.from.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+exports.__esModule = true;
+exports.default = exports.TRAVERSAL_DF_PRE = exports.TRAVERSAL_DF_POST = exports.TRAVERSAL_BF = void 0;
+exports.depthFirstPreOrder = depthFirstPreOrder;
+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");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+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 _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+/**
+ * Depth-first pre-order strategy (https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR)).
+ *
+ * @type {string}
+ */
+var TRAVERSAL_DF_PRE = 'DF-pre-order';
+/**
+ * @param {Function} callback A callback which will be called on each visited node.
+ * @param {*} context A context to pass through.
+ * @returns {boolean}
+ */
+exports.TRAVERSAL_DF_PRE = TRAVERSAL_DF_PRE;
+function depthFirstPreOrder(callback, context) {
+  var continueTraverse = callback.call(context, this);
+  for (var i = 0; i < this.childs.length; i++) {
+    if (continueTraverse === false) {
+      return false;
+    }
+    continueTraverse = depthFirstPreOrder.call(this.childs[i], callback, context);
+  }
+  return continueTraverse;
+}
+
+/**
+ * Depth-first post-order strategy (https://en.wikipedia.org/wiki/Tree_traversal#Post-order_(NLR)).
+ *
+ * @type {string}
+ */
+var TRAVERSAL_DF_POST = 'DF-post-order';
+/**
+ * @param {Function} callback A callback which will be called on each visited node.
+ * @param {*} context A context to pass through.
+ * @returns {boolean}
+ */
+exports.TRAVERSAL_DF_POST = TRAVERSAL_DF_POST;
+function depthFirstPostOrder(callback, context) {
+  for (var i = 0; i < this.childs.length; i++) {
+    var continueTraverse = depthFirstPostOrder.call(this.childs[i], callback, context);
+    if (continueTraverse === false) {
+      return false;
+    }
+  }
+  return callback.call(context, this);
+}
+
+/**
+ * Breadth-first traversal strategy (https://en.wikipedia.org/wiki/Tree_traversal#Breadth-first_search_/_level_order).
+ *
+ * @type {string}
+ */
+var TRAVERSAL_BF = 'BF';
+/**
+ * @param {Function} callback A callback which will be called on each visited node.
+ * @param {*} context A context to pass through.
+ */
+exports.TRAVERSAL_BF = TRAVERSAL_BF;
+function breadthFirst(callback, context) {
+  var queue = [this];
+
+  /**
+   * Internal processor.
+   */
+  function process() {
+    if (queue.length === 0) {
+      return;
+    }
+    var node = queue.shift();
+    queue.push.apply(queue, _toConsumableArray(node.childs));
+    if (callback.call(context, node) !== false) {
+      process();
+    }
+  }
+  process();
+}
+
+/**
+ * Default strategy for tree traversal.
+ *
+ * @type {string}
+ */
+var DEFAULT_TRAVERSAL_STRATEGY = TRAVERSAL_BF;
+/**
+ * Collection of all available tree traversal strategies.
+ *
+ * @type {Map<string, Function>}
+ */
+var TRAVERSAL_STRATEGIES = new Map([[TRAVERSAL_DF_PRE, depthFirstPreOrder], [TRAVERSAL_DF_POST, depthFirstPostOrder], [TRAVERSAL_BF, breadthFirst]]);
+
+/**
+ *
+ */
+var TreeNode = /*#__PURE__*/function () {
+  /**
+   * A tree data.
+   *
+   * @type {object}
+   */
+
+  /**
+   * A parent node.
+   *
+   * @type {TreeNode}
+   */
+
+  /**
+   * A tree leaves.
+   *
+   * @type {TreeNode[]}
+   */
+
+  function TreeNode(data) {
+    _classCallCheck(this, TreeNode);
+    _defineProperty(this, "data", {});
+    _defineProperty(this, "parent", null);
+    _defineProperty(this, "childs", []);
+    this.data = data;
+  }
+
+  /**
+   * Adds a node to tree leaves. Added node is linked with the parent node through "parent" property.
+   *
+   * @param {TreeNode} node A TreeNode to add.
+   */
+  _createClass(TreeNode, [{
+    key: "addChild",
+    value: function addChild(node) {
+      node.parent = this;
+      this.childs.push(node);
+    }
+
+    /* eslint-disable jsdoc/require-description-complete-sentence */
+    /**
+     * @memberof TreeNode#
+     * @function cloneTree
+     *
+     * Clones a tree structure deeply.
+     *
+     * For example, for giving a tree structure:
+     *      .--(B1)--.
+     *   .-(C1)   .-(C2)-.----.
+     *  (D1)     (D2)   (D3) (D4)
+     *
+     * Cloning a tree starting from C2 node creates a mirrored tree structure.
+     *     .-(C2')-.-----.
+     *    (D2')   (D3') (D4')
+     *
+     * The cloned tree can be safely modified without affecting the original structure.
+     * After modification, the clone can be merged with a tree using the "replaceTreeWith" method.
+     *
+     * @param {TreeNode} [nodeTree=this] A TreeNode to clone.
+     * @returns {TreeNode}
+     */
+    /* eslint-enable jsdoc/require-description-complete-sentence */
+  }, {
+    key: "cloneTree",
+    value: function cloneTree() {
+      var nodeTree = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this;
+      var clonedNode = new TreeNode(_objectSpread({}, nodeTree.data));
+      for (var i = 0; i < nodeTree.childs.length; i++) {
+        clonedNode.addChild(this.cloneTree(nodeTree.childs[i]));
+      }
+      return clonedNode;
+    }
+
+    /**
+     * Replaces the current node with a passed tree structure.
+     *
+     * @param {TreeNode} nodeTree A TreeNode to replace with.
+     */
+  }, {
+    key: "replaceTreeWith",
+    value: function replaceTreeWith(nodeTree) {
+      this.data = _objectSpread({}, nodeTree.data);
+      this.childs = [];
+      for (var i = 0; i < nodeTree.childs.length; i++) {
+        this.addChild(nodeTree.childs[i]);
+      }
+    }
+
+    /**
+     * Traverses the tree structure through node childs. The walk down traversing supports
+     * a three different strategies.
+     *  - Depth-first pre-order strategy (https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR));
+     *  - Depth-first post-order strategy (https://en.wikipedia.org/wiki/Tree_traversal#Post-order_(NLR));
+     *  - Breadth-first traversal strategy (https://en.wikipedia.org/wiki/Tree_traversal#Breadth-first_search_/_level_order).
+     *
+     * @param {Function} callback The callback function which will be called for each node.
+     * @param {string} [traversalStrategy=DEFAULT_TRAVERSAL_STRATEGY] Traversing strategy.
+     */
+  }, {
+    key: "walkDown",
+    value: function walkDown(callback) {
+      var traversalStrategy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_TRAVERSAL_STRATEGY;
+      if (!TRAVERSAL_STRATEGIES.has(traversalStrategy)) {
+        throw new Error("Traversal strategy \"".concat(traversalStrategy, "\" does not exist"));
+      }
+      TRAVERSAL_STRATEGIES.get(traversalStrategy).call(this, callback, this);
+    }
+
+    /**
+     * Traverses the tree structure through node parents.
+     *
+     * @param {Function} callback The callback function which will be called for each node.
+     */
+  }, {
+    key: "walkUp",
+    value: function walkUp(callback) {
+      var context = this;
+      var process = function process(node) {
+        var continueTraverse = callback.call(context, node);
+        if (continueTraverse !== false && node.parent !== null) {
+          process(node.parent);
+        }
+      };
+      process(this);
+    }
+  }]);
+  return TreeNode;
+}();
+exports.default = TreeNode;