text: /**
   * @ag-grid-community/core - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
   * @version v25.0.1
   * @link http://www.ag-grid.com/
   * @license MIT
   */
  var __extends = (this && this.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  };
  var __param = (this && this.__param) || function (paramIndex, decorator) {
      return function (target, key) { decorator(target, key, paramIndex); }
  };
  import { ColumnKeyCreator } from "./columnKeyCreator";
  import { OriginalColumnGroup } from "../entities/originalColumnGroup";
  import { Column } from "../entities/column";
  import { Autowired, Bean, Qualifier } from "../context/context";
  import { DefaultColumnTypes } from "../entities/defaultColumnTypes";
  import { BeanStub } from "../context/beanStub";
  import { Constants } from "../constants/constants";
  import { assign, iterateObject, mergeDeep } from '../utils/object';
  import { attrToNumber, attrToBoolean, find } from '../utils/generic';
  import { removeFromArray } from '../utils/array';
  // takes ColDefs and ColGroupDefs and turns them into Columns and OriginalGroups
  var ColumnFactory = /** @class */ (function (_super) {
      __extends(ColumnFactory, _super);
      function ColumnFactory() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      ColumnFactory.prototype.setBeans = function (loggerFactory) {
          this.logger = loggerFactory.create('ColumnFactory');
      };
      ColumnFactory.prototype.createColumnTree = function (defs, primaryColumns, existingColumns) {
          // column key creator dishes out unique column id's in a deterministic way,
          // so if we have two grids (that could be master/slave) with same column definitions,
          // then this ensures the two grids use identical id's.
          var columnKeyCreator = new ColumnKeyCreator();
          if (existingColumns) {
              var existingKeys = existingColumns.map(function (col) { return col.getId(); });
              columnKeyCreator.addExistingKeys(existingKeys);
          }
          // we take a copy of the columns as we are going to be removing from them
          var existingColsCopy = existingColumns ? existingColumns.slice() : null;
          // create am unbalanced tree that maps the provided definitions
          var unbalancedTree = this.recursivelyCreateColumns(defs, 0, primaryColumns, existingColsCopy, columnKeyCreator, null);
          var treeDept = this.findMaxDept(unbalancedTree, 0);
          this.logger.log('Number of levels for grouped columns is ' + treeDept);
          var columnTree = this.balanceColumnTree(unbalancedTree, 0, treeDept, columnKeyCreator);
          var deptFirstCallback = function (child, parent) {
              if (child instanceof OriginalColumnGroup) {
                  child.setupExpandable();
              }
              // we set the original parents at the end, rather than when we go along, as balancing the tree
              // adds extra levels into the tree. so we can only set parents when balancing is done.
              child.setOriginalParent(parent);
          };
          this.columnUtils.depthFirstOriginalTreeSearch(null, columnTree, deptFirstCallback);
          return {
              columnTree: columnTree,
              treeDept: treeDept
          };
      };
      ColumnFactory.prototype.createForAutoGroups = function (autoGroupCols, gridBalancedTree) {
          var _this = this;
          var autoColBalancedTree = [];
          autoGroupCols.forEach(function (col) {
              var fakeTreeItem = _this.createAutoGroupTreeItem(gridBalancedTree, col);
              autoColBalancedTree.push(fakeTreeItem);
          });
          return autoColBalancedTree;
      };
      ColumnFactory.prototype.createAutoGroupTreeItem = function (balancedColumnTree, column) {
          var dept = this.findDepth(balancedColumnTree);
          // at the end, this will be the top of the tree item.
          var nextChild = column;
          for (var i = dept - 1; i >= 0; i--) {
              var autoGroup = new OriginalColumnGroup(null, "FAKE_PATH_" + column.getId() + "}_" + i, true, i);
              this.context.createBean(autoGroup);
              autoGroup.setChildren([nextChild]);
              nextChild.setOriginalParent(autoGroup);
              nextChild = autoGroup;
          }
          // at this point, the nextChild is the top most item in the tree
          return nextChild;
      };
      ColumnFactory.prototype.findDepth = function (balancedColumnTree) {
          var dept = 0;
          var pointer = balancedColumnTree;
          while (pointer && pointer[0] && pointer[0] instanceof OriginalColumnGroup) {
              dept++;
              pointer = pointer[0].getChildren();
          }
          return dept;
      };
      ColumnFactory.prototype.balanceColumnTree = function (unbalancedTree, currentDept, columnDept, columnKeyCreator) {
          var result = [];
          // go through each child, for groups, recurse a level deeper,
          // for columns we need to pad
          for (var i = 0; i < unbalancedTree.length; i++) {
              var child = unbalancedTree[i];
              if (child instanceof OriginalColumnGroup) {
                  // child is a group, all we do is go to the next level of recursion
                  var originalGroup = child;
                  var newChildren = this.balanceColumnTree(originalGroup.getChildren(), currentDept + 1, columnDept, columnKeyCreator);
                  originalGroup.setChildren(newChildren);
                  result.push(originalGroup);
              }
              else {
                  // child is a column - so here we add in the padded column groups if needed
                  var firstPaddedGroup = void 0;
                  var currentPaddedGroup = void 0;
                  // this for loop will NOT run any loops if no padded column groups are needed
                  for (var j = columnDept - 1; j >= currentDept; j--) {
                      var newColId = columnKeyCreator.getUniqueKey(null, null);
                      var colGroupDefMerged = this.createMergedColGroupDef(null);
                      var paddedGroup = new OriginalColumnGroup(colGroupDefMerged, newColId, true, currentDept);
                      this.context.createBean(paddedGroup);
                      if (currentPaddedGroup) {
                          currentPaddedGroup.setChildren([paddedGroup]);
                      }
                      currentPaddedGroup = paddedGroup;
                      if (!firstPaddedGroup) {
                          firstPaddedGroup = currentPaddedGroup;
                      }
                  }
                  // likewise this if statement will not run if no padded groups
                  if (firstPaddedGroup) {
                      result.push(firstPaddedGroup);
                      var hasGroups = unbalancedTree.some(function (child) { return child instanceof OriginalColumnGroup; });
                      if (hasGroups) {
                          currentPaddedGroup.setChildren([child]);
                          continue;
                      }
                      else {
                          currentPaddedGroup.setChildren(unbalancedTree);
                          break;
                      }
                  }
                  result.push(child);
              }
          }
          return result;
      };
      ColumnFactory.prototype.findMaxDept = function (treeChildren, dept) {
          var maxDeptThisLevel = dept;
          for (var i = 0; i < treeChildren.length; i++) {
              var abstractColumn = treeChildren[i];
              if (abstractColumn instanceof OriginalColumnGroup) {
                  var originalGroup = abstractColumn;
                  var newDept = this.findMaxDept(originalGroup.getChildren(), dept + 1);
                  if (maxDeptThisLevel < newDept) {
                      maxDeptThisLevel = newDept;
                  }
              }
          }
          return maxDeptThisLevel;
      };
      ColumnFactory.prototype.recursivelyCreateColumns = function (defs, level, primaryColumns, existingColsCopy, columnKeyCreator, parent) {
          var _this = this;
          var result = [];
          if (!defs) {
              return result;
          }
          defs.forEach(function (def) {
              var newGroupOrColumn;
              if (_this.isColumnGroup(def)) {
                  newGroupOrColumn = _this.createColumnGroup(primaryColumns, def, level, existingColsCopy, columnKeyCreator, parent);
              }
              else {
                  newGroupOrColumn = _this.createColumn(primaryColumns, def, existingColsCopy, columnKeyCreator, parent);
              }
              result.push(newGroupOrColumn);
          });
          return result;
      };
      ColumnFactory.prototype.createColumnGroup = function (primaryColumns, colGroupDef, level, existingColumns, columnKeyCreator, parent) {
          var colGroupDefMerged = this.createMergedColGroupDef(colGroupDef);
          var groupId = columnKeyCreator.getUniqueKey(colGroupDefMerged.groupId, null);
          var originalGroup = new OriginalColumnGroup(colGroupDefMerged, groupId, false, level);
          this.context.createBean(originalGroup);
          var children = this.recursivelyCreateColumns(colGroupDefMerged.children, level + 1, primaryColumns, existingColumns, columnKeyCreator, originalGroup);
          originalGroup.setChildren(children);
          return originalGroup;
      };
      ColumnFactory.prototype.createMergedColGroupDef = function (colGroupDef) {
          var colGroupDefMerged = {};
          assign(colGroupDefMerged, this.gridOptionsWrapper.getDefaultColGroupDef());
          assign(colGroupDefMerged, colGroupDef);
          this.checkForDeprecatedItems(colGroupDefMerged);
          return colGroupDefMerged;
      };
      ColumnFactory.prototype.createColumn = function (primaryColumns, colDef, existingColsCopy, columnKeyCreator, parent) {
          var colDefMerged = this.mergeColDefs(colDef);
          this.checkForDeprecatedItems(colDefMerged);
          // see if column already exists
          var column = this.findExistingColumn(colDef, existingColsCopy);
          if (!column) {
              // no existing column, need to create one
              var colId = columnKeyCreator.getUniqueKey(colDefMerged.colId, colDefMerged.field);
              column = new Column(colDefMerged, colDef, colId, primaryColumns);
              this.context.createBean(column);
          }
          else {
              column.setColDef(colDefMerged, colDef);
              this.applyColumnState(column, colDefMerged);
          }
          return column;
      };
      ColumnFactory.prototype.applyColumnState = function (column, colDef) {
          // flex
          var flex = attrToNumber(colDef.flex);
          if (flex !== undefined) {
              column.setFlex(flex);
          }
          // width - we only set width if column is not flexing
          var noFlexThisCol = column.getFlex() <= 0;
          if (noFlexThisCol) {
              // both null and undefined means we skip, as it's not possible to 'clear' width (a column must have a width)
              var width = attrToNumber(colDef.width);
              if (width != null) {
                  column.setActualWidth(width);
              }
          }
          // sort - anything but undefined will set sort, thus null or empty string will clear the sort
          if (colDef.sort !== undefined) {
              if (colDef.sort == Constants.SORT_ASC || colDef.sort == Constants.SORT_DESC) {
                  column.setSort(colDef.sort);
              }
              else {
                  column.setSort(undefined);
              }
          }
          // sorted at - anything but undefined, thus null will clear the sortIndex
          var sortIndex = attrToNumber(colDef.sortIndex);
          if (sortIndex !== undefined) {
              column.setSortIndex(sortIndex);
          }
          // hide - anything but undefined, thus null will clear the hide
          var hide = attrToBoolean(colDef.hide);
          if (hide !== undefined) {
              column.setVisible(!hide);
          }
          // pinned - anything but undefined, thus null or empty string will remove pinned
          if (colDef.pinned !== undefined) {
              column.setPinned(colDef.pinned);
          }
      };
      ColumnFactory.prototype.findExistingColumn = function (newColDef, existingColsCopy) {
          var res = find(existingColsCopy, function (existingCol) {
              var existingColDef = existingCol.getUserProvidedColDef();
              if (!existingColDef) {
                  return false;
              }
              var newHasId = newColDef.colId != null;
              var newHasField = newColDef.field != null;
              if (newHasId) {
                  return existingCol.getId() === newColDef.colId;
              }
              if (newHasField) {
                  return existingColDef.field === newColDef.field;
              }
              // if no id or field present, then try object equivalence.
              if (existingColDef === newColDef) {
                  return true;
              }
              return false;
          });
          // make sure we remove, so if user provided duplicate id, then we don't have more than
          // one column instance for colDef with common id
          if (res) {
              removeFromArray(existingColsCopy, res);
          }
          return res;
      };
      ColumnFactory.prototype.mergeColDefs = function (colDef) {
          // start with empty merged definition
          var colDefMerged = {};
          // merge properties from default column definitions
          var defaultColDef = this.gridOptionsWrapper.getDefaultColDef();
          mergeDeep(colDefMerged, defaultColDef, true, true);
          // merge properties from column type properties
          if (colDef.type || (defaultColDef && defaultColDef.type)) {
              // if type of both colDef and defaultColDef, then colDef gets preference
              var columnType = colDef.type ? colDef.type : defaultColDef.type;
              this.assignColumnTypes(columnType, colDefMerged);
          }
          // merge properties from column definitions
          mergeDeep(colDefMerged, colDef, true, true);
          return colDefMerged;
      };
      ColumnFactory.prototype.assignColumnTypes = function (type, colDefMerged) {
          var typeKeys;
          if (type instanceof Array) {
              var invalidArray = type.some(function (a) { return typeof a !== 'string'; });
              if (invalidArray) {
                  console.warn("ag-grid: if colDef.type is supplied an array it should be of type 'string[]'");
              }
              else {
                  typeKeys = type;
              }
          }
          else if (typeof type === 'string') {
              typeKeys = type.split(',');
          }
          else {
              console.warn("ag-grid: colDef.type should be of type 'string' | 'string[]'");
              return;
          }
          // merge user defined with default column types
          var allColumnTypes = assign({}, DefaultColumnTypes);
          var userTypes = this.gridOptionsWrapper.getColumnTypes() || {};
          iterateObject(userTypes, function (key, value) {
              if (key in allColumnTypes) {
                  console.warn("ag-Grid: the column type '" + key + "' is a default column type and cannot be overridden.");
              }
              else {
                  allColumnTypes[key] = value;
              }
          });
          typeKeys.forEach(function (t) {
              var typeColDef = allColumnTypes[t.trim()];
              if (typeColDef) {
                  mergeDeep(colDefMerged, typeColDef, true, true);
              }
              else {
                  console.warn("ag-grid: colDef.type '" + t + "' does not correspond to defined gridOptions.columnTypes");
              }
          });
      };
      ColumnFactory.prototype.checkForDeprecatedItems = function (colDef) {
          if (colDef) {
              var colDefNoType = colDef; // take out the type, so we can access attributes not defined in the type
              if (colDefNoType.group !== undefined) {
                  console.warn('ag-grid: colDef.group is invalid, please check documentation on how to do grouping as it changed in version 3');
              }
              if (colDefNoType.headerGroup !== undefined) {
                  console.warn('ag-grid: colDef.headerGroup is invalid, please check documentation on how to do grouping as it changed in version 3');
              }
              if (colDefNoType.headerGroupShow !== undefined) {
                  console.warn('ag-grid: colDef.headerGroupShow is invalid, should be columnGroupShow, please check documentation on how to do grouping as it changed in version 3');
              }
              if (colDefNoType.suppressRowGroup !== undefined) {
                  console.warn('ag-grid: colDef.suppressRowGroup is deprecated, please use colDef.type instead');
              }
              if (colDefNoType.suppressAggregation !== undefined) {
                  console.warn('ag-grid: colDef.suppressAggregation is deprecated, please use colDef.type instead');
              }
              if (colDefNoType.suppressRowGroup || colDefNoType.suppressAggregation) {
                  console.warn('ag-grid: colDef.suppressAggregation and colDef.suppressRowGroup are deprecated, use allowRowGroup, allowPivot and allowValue instead');
              }
              if (colDefNoType.displayName) {
                  console.warn("ag-grid: Found displayName " + colDefNoType.displayName + ", please use headerName instead, displayName is deprecated.");
                  colDefNoType.headerName = colDefNoType.displayName;
              }
          }
      };
      // if object has children, we assume it's a group
      ColumnFactory.prototype.isColumnGroup = function (abstractColDef) {
          return abstractColDef.children !== undefined;
      };
      __decorate([
          Autowired('columnUtils')
      ], ColumnFactory.prototype, "columnUtils", void 0);
      __decorate([
          __param(0, Qualifier('loggerFactory'))
      ], ColumnFactory.prototype, "setBeans", null);
      ColumnFactory = __decorate([
          Bean('columnFactory')
      ], ColumnFactory);
      return ColumnFactory;
  }(BeanStub));
  export { ColumnFactory };
  