railwaysystem/RuoYi-Vue/ruoyi-ui/node_modules2/handsontable/plugins/nestedHeaders/stateManager/headersTree.js

"use strict";

exports.__esModule = true;
require("core-js/modules/es.error.cause.js");
var _array = require("../../../helpers/array");
var _tree = _interopRequireDefault(require("../../../utils/dataStructures/tree"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
/* eslint-disable jsdoc/require-description-complete-sentence */
/**
 * @private
 * @class HeadersTree
 *
 * The header tree class keeps nested header settings in the tree
 * structure for easier node manipulation (e.q collapse or expand column).
 * That trees represent the current state of the nested headers. From the
 * trees, the matrix is generated for nested header renderers.
 *
 * The second role of the module is validation. While building the tree,
 * there is check whether the configuration contains overlapping
 * headers. If true, then the exception is thrown.
 *
 * The tree is static; it means that its column indexing never changes
 * even when a collapsing header is performed. The structure is based
 * on visual column indexes.
 *
 * For example, for that header configuration:
 *   +----+----+----+----+----+
 *   │ A1                │ A2 │
 *   +----+----+----+----+----+
 *   │ B1           │ B2 │ B3 │
 *   +----+----+----+----+----+
 *   │ C1      │ C2 │ C3 │ C4 │
 *   +----+----+----+----+----+
 *
 * The tree structures look like:
 *                (0)                      (4)           // a visual column index
 *                 │                        │
 *        .------(A1)------.              (A2)--.
 *   .--(B1)--.           (B2)--.              (B3)--.
 *  (C1)     (C2)              (C3)                 (C4)
 *
 */
/* eslint-enable jsdoc/require-description-complete-sentence */
var _rootNodes = /*#__PURE__*/new WeakMap();
var _rootsIndex = /*#__PURE__*/new WeakMap();
var _sourceSettings = /*#__PURE__*/new WeakMap();
class HeadersTree {
  constructor(sourceSettings) {
    /**
     * The collection of nested headers settings structured into trees. The root trees are stored
     * under the visual column index.
     *
     * @private
     * @type {Map<number, TreeNode>}
     */
    _classPrivateFieldInitSpec(this, _rootNodes, {
      writable: true,
      value: new Map()
    });
    /**
     * A map that translates the visual column indexes that intersect the range
     * defined by the header colspan width to the root index.
     *
     * @private
     * @type {Map<number, number>}
     */
    _classPrivateFieldInitSpec(this, _rootsIndex, {
      writable: true,
      value: new Map()
    });
    /**
     * The instance of the SourceSettings class.
     *
     * @private
     * @type {SourceSettings}
     */
    _classPrivateFieldInitSpec(this, _sourceSettings, {
      writable: true,
      value: null
    });
    _classPrivateFieldSet(this, _sourceSettings, sourceSettings);
  }

  /**
   * Gets an array of the all root nodes.
   *
   * @returns {TreeNode[]}
   */
  getRoots() {
    return Array.from(_classPrivateFieldGet(this, _rootNodes).values());
  }

  /**
   * Gets a root node by specified visual column index.
   *
   * @param {number} columnIndex A visual column index.
   * @returns {TreeNode|undefined}
   */
  getRootByColumn(columnIndex) {
    let node;
    if (_classPrivateFieldGet(this, _rootsIndex).has(columnIndex)) {
      node = _classPrivateFieldGet(this, _rootNodes).get(_classPrivateFieldGet(this, _rootsIndex).get(columnIndex));
    }
    return node;
  }

  /**
   * Gets a tree node by its position in the grid settings.
   *
   * @param {number} headerLevel Header level index (there is support only for positive values).
   * @param {number} columnIndex A visual column index.
   * @returns {TreeNode|undefined}
   */
  getNode(headerLevel, columnIndex) {
    const rootNode = this.getRootByColumn(columnIndex);
    if (!rootNode) {
      return;
    }

    // Normalize the visual column index to a 0-based system for a specific "box" defined
    // by root node colspan width.
    const normColumnIndex = columnIndex - _classPrivateFieldGet(this, _rootsIndex).get(columnIndex);
    let columnCursor = 0;
    let treeNode;

    // Collect all parent nodes that depend on the collapsed node.
    rootNode.walkDown(node => {
      const {
        data: {
          origColspan,
          headerLevel: nodeHeaderLevel
        }
      } = node;
      if (headerLevel === nodeHeaderLevel) {
        if (normColumnIndex >= columnCursor && normColumnIndex <= columnCursor + origColspan - 1) {
          treeNode = node;
          treeNode.data.isRoot = columnIndex === treeNode.data.columnIndex;
          return false; // Cancel tree traversing.
        }

        columnCursor += origColspan;
      }
    });
    return treeNode;
  }

  /**
   * Builds (or rebuilds if called again) root nodes indexes.
   */
  rebuildTreeIndex() {
    let columnIndex = 0;
    _classPrivateFieldGet(this, _rootsIndex).clear();
    (0, _array.arrayEach)(_classPrivateFieldGet(this, _rootNodes), _ref => {
      let [, {
        data: {
          colspan
        }
      }] = _ref;
      // Map tree range (colspan range/width) into visual column index of the root node.
      for (let i = columnIndex; i < columnIndex + colspan; i++) {
        _classPrivateFieldGet(this, _rootsIndex).set(i, columnIndex);
      }
      columnIndex += colspan;
    });
  }

  /**
   * Builds trees based on SourceSettings class. Calling a method causes clearing the tree state built
   * from the previous call.
   */
  buildTree() {
    this.clear();
    const columnsCount = _classPrivateFieldGet(this, _sourceSettings).getColumnsCount();
    let columnIndex = 0;
    while (columnIndex < columnsCount) {
      const columnSettings = _classPrivateFieldGet(this, _sourceSettings).getHeaderSettings(0, columnIndex);
      const rootNode = new _tree.default();
      _classPrivateFieldGet(this, _rootNodes).set(columnIndex, rootNode);
      this.buildLeaves(rootNode, columnIndex, 0, columnSettings.origColspan);
      columnIndex += columnSettings.origColspan;
    }
    this.rebuildTreeIndex();
  }

  /**
   * Builds leaves for specified tree node.
   *
   * @param {TreeNode} parentNode A node to which the leaves applies.
   * @param {number} columnIndex A visual column index.
   * @param {number} headerLevel Currently processed header level.
   * @param {number} [extractionLength=1] Determines column extraction length for node children.
   */
  buildLeaves(parentNode, columnIndex, headerLevel) {
    let extractionLength = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
    const columnsSettings = _classPrivateFieldGet(this, _sourceSettings).getHeadersSettings(headerLevel, columnIndex, extractionLength);
    headerLevel += 1;
    (0, _array.arrayEach)(columnsSettings, columnSettings => {
      const nodeData = {
        ...columnSettings,
        /**
         * The header level (tree node depth level).
         *
         * @type {number}
         */
        headerLevel: headerLevel - 1,
        /**
         * A visual column index.
         *
         * @type {number}
         */
        columnIndex
      };
      let node;
      if (headerLevel === 1) {
        // fill the root node
        parentNode.data = nodeData;
        node = parentNode;
      } else {
        node = new _tree.default(nodeData);
        parentNode.addChild(node);
      }
      if (headerLevel < _classPrivateFieldGet(this, _sourceSettings).getLayersCount()) {
        this.buildLeaves(node, columnIndex, headerLevel, columnSettings.origColspan);
      }
      columnIndex += columnSettings.origColspan;
    });
  }

  /**
   * Clears the tree to the initial state.
   */
  clear() {
    _classPrivateFieldGet(this, _rootNodes).clear();
    _classPrivateFieldGet(this, _rootsIndex).clear();
  }
}
exports.default = HeadersTree;