private createColumns()

in src/grid/agr-engine.ts [85:180]
91 lines of code
31 McCabe index (conditional complexity)

  private createColumns(columnsDefinition: ColumnDef[]) {
    this.header = [];
    this.body = [];
    this.frozenHeader = [];
    this.frozenBody = [];
    const header = [];
    const body = [];
    let stack: ColumnStack[] = columnsDefinition.map((columnDef) => {
      return {
        column: new Column(columnDef, null),
        rowIndex: 0,
        collapsed: columnDef.collapsed,
        pinned: columnDef.pinned,
      };
    });
    let count = 0;
    while (stack.length > 0) {
      if (count++ > 1000) {
        return;
      }
      let current = stack[0];
      if ((header.length === 0 && current.rowIndex === 0) || header.length < current.rowIndex + 1) {
        header.push([]);
      }
      if (Array.isArray(current.column.columnDef.columns) && current.column.columnDef.columns.length > 0 && !current.visited) {
        current.visited = true;
        current.column.colSpan = 0;
        const newStack = current.column.columnDef.columns
          .filter((columnDef) => {
            const collapsed = current.collapsed || columnDef.collapsed;
            return collapsed ? this.isVisibleInCollapse(columnDef) : true;
          })
          .map((columnDef) => {
            const column = new Column(columnDef, current.column);
            current.column.columns.push(column);
            return {
              column,
              rowIndex: current.rowIndex + 1,
              collapsed: current.collapsed || columnDef.collapsed,
              pinned: current.pinned || columnDef.pinned,
            };
          });
        stack = [...newStack, ...stack];
        continue;
      }
      current = stack.shift();
      header[current.rowIndex].push(current);
      if (!Array.isArray(current.column.columns) || current.column.columns.length === 0) {
        body.push(current);
        let parent = current.column.parent;
        while (parent) {
          parent.colSpan++;
          parent = parent.parent;
        }
      }
    }
    let rowSpan = 1;
    for (let rowIndex = header.length - 2; rowIndex >= 0; rowIndex--) {
      rowSpan++;
      for (const columnStack of header[rowIndex]) {
        if (!Array.isArray(columnStack.column.columns) || columnStack.column.columns.length === 0) {
          columnStack.column.rowSpan = rowSpan;
        }
      }
    }
    if (this.options.sectionMode && header.length > 0) {
      for (const columnStack of header[0]) {
        columnStack.column.isLast = true;
        let children = columnStack.column.columns;
        while (children) {
          const lastChild = children[children.length - 1];
          lastChild.isLast = true;
          children = Array.isArray(lastChild.columns) && lastChild.columns.length > 0 ? lastChild.columns : null;
        }
      }
    }
    for (const row of header) {
      this.header.push([]);
      this.frozenHeader.push([]);
      for (const columnStack of row) {
        columnStack.pinned
          ? this.frozenHeader[columnStack.rowIndex].push(columnStack.column)
          : this.header[columnStack.rowIndex].push(columnStack.column);
      }
      const helperColumn = new Column({ title: 'r', field: 'r' });
      this.frozenHeader[this.frozenHeader.length - 1].push(helperColumn);
      // if (this.frozenHeader[this.frozenHeader.length-1].length===0){
      //   // this.frozenHeader[this.frozenHeader.length-1].push(new Column({title:'',field:''}))
      // }
    }
    for (const columnStack of body) {
      columnStack.pinned ? this.frozenBody.push(columnStack.column) : this.body.push(columnStack.column);
    }
    // console.log('frozen', this.frozenHeader);
    // console.log('header', this.header);
  }