public buildGridTableHeader()

in frontend/apps/quantgrid/src/app/context/ViewportContext/GridBuilder.ts [185:379]
173 lines of code
28 McCabe index (conditional complexity)

  public buildGridTableHeader(tableData: TableData, zIndex: number): GridData {
    const { table, diff } = tableData;
    const { tableName } = table;
    const isTableHorizontal = table.getIsTableDirectionHorizontal();
    const isTableHeaderHidden = table.getIsTableHeaderHidden();
    const isFieldsHeaderHidden = table.getIsTableFieldsHidden();
    const totalSize = table.getTotalSize();

    const tableDimensions = this.getTableDimensions(
      tableName,
      isTableHorizontal
    );
    const { startCol, startRow, endCol } = tableDimensions;

    const data: GridData = {};

    // Add table header (first table row with tableName)
    if (!isTableHeaderHidden) {
      for (let col = startCol; col <= endCol; col++) {
        GridBuilder.setSafeDataCell(data, startRow, col, {
          table: {
            ...tableDimensions,
            tableName,
            isTableNameHeaderHidden: isTableHeaderHidden,
            isTableFieldsHeaderHidden: isFieldsHeaderHidden,
            hasKeys: table.hasKeys(),
            isTableHorizontal,
            totalSize,
            isManual: table.isManual(),
            isNewAdded: !!diff?.table,
          },
          value: tableName,
          row: startRow,
          col,
          startCol: tableDimensions.startCol,
          endCol: tableDimensions.endCol,
          zIndex: col === startCol ? zIndex + 1 : zIndex,
          isFieldHeader: false,
          isTableHeader: true,
        });
      }
    }

    // Add table fields headers (second table row with names of the fields)
    const fieldRow = startRow + table.getTableNameHeaderHeight();
    let directionIndex = isTableHorizontal ? fieldRow : startCol;

    for (const field of table.fields) {
      const columnName = field.key.fieldName;
      const fieldSize = !isTableHorizontal ? field.getSize() : 1;

      // dynamic fields are drawing separately
      if (columnName === dynamicFieldName) {
        continue;
      }

      const isNested = tableData.nestedColumnNames.has(columnName);
      const type = tableData.types[columnName];
      const isPeriodSeries = type === ColumnDataType.PERIOD_SERIES;
      const expression = field.expressionMetadata?.text || '';
      const viewportErrorMessage = tableData?.fieldErrors[columnName];
      const fieldErrorMessage = getFieldErrors(
        this.viewGridData.getParsingErrors(),
        this.viewGridData.getCompilationErrors(),
        viewportErrorMessage,
        tableName,
        columnName
      );

      const note = field.note?.text || '';
      const { sort, isFiltered, numericFilter, isFieldUsedInSort } =
        this.getApplyBlockGridParams(tableData, table, columnName);

      // This iterations needed for case when table is NOT horizontal and fields sizes not 1
      for (
        let innerFieldIndex = 0;
        innerFieldIndex < fieldSize;
        innerFieldIndex++
      ) {
        const directionOffset = directionIndex + innerFieldIndex;
        const cellCol = isTableHorizontal
          ? startCol
          : directionIndex + innerFieldIndex;
        const cellRow = isTableHorizontal ? directionOffset : fieldRow;
        const isMainFieldCell = innerFieldIndex === 0;
        const fieldStartCol = isTableHorizontal ? startCol : directionIndex;
        const fieldEndCol = isTableHorizontal
          ? startCol
          : directionIndex + fieldSize - 1;
        const targetColumnName = field.isDynamic
          ? dynamicFieldName
          : columnName;
        const totalFieldTypes =
          table.total?.getFieldTotalTypes(targetColumnName);

        const cellTable: GridTable = {
          ...tableDimensions,
          tableName,
          isTableNameHeaderHidden: isTableHeaderHidden,
          isTableFieldsHeaderHidden: isFieldsHeaderHidden,
          hasKeys: table.hasKeys(),
          isTableHorizontal,
          totalSize,
          isManual: table.isManual(),
          isNewAdded: !!diff?.table,
        };

        const cellField: GridField = {
          fieldName: columnName,
          note,
          expression,
          isPeriodSeries,
          isDynamic: field.isDynamic,
          isNested,
          isKey: field.isKey,
          isDim: field.isDim,
          hasError: !!fieldErrorMessage,
          errorMessage: fieldErrorMessage,
          isFiltered,
          numericFilter,
          totalFieldTypes,
          sort,
          isFieldUsedInSort,
          type,
          isChanged: !!diff?.fields.includes(columnName),
        };

        if (!isFieldsHeaderHidden) {
          GridBuilder.setSafeDataCell(data, cellRow, cellCol, {
            table: cellTable,
            value: isMainFieldCell ? columnName : '',
            field: cellField,
            row: cellRow,
            col: cellCol,
            startCol: fieldStartCol,
            endCol: fieldEndCol,
            zIndex,
            isFieldHeader: true,
            isTableHeader: false,
          });
        }

        // Add total rows
        for (let i = 1; i <= totalSize; i++) {
          const offset = isFieldsHeaderHidden ? 1 : 0;
          const col = isTableHorizontal ? cellCol + i - offset : cellCol;
          const row = isTableHorizontal ? cellRow : cellRow + i - offset;

          const targetColumnName = field.isDynamic
            ? dynamicFieldName
            : columnName;
          const totalExpression = table.total?.getFieldTotalByIndex(
            targetColumnName,
            i
          );
          const totalValue = tableData.total[targetColumnName]?.[i];
          const value = totalValue && totalExpression ? totalValue : '';
          const totalErrorMessage = getTotalErrors(
            this.viewGridData.getParsingErrors(),
            this.viewGridData.getCompilationErrors(),
            tableName,
            columnName,
            i
          );
          const isRightAligned = this.isValueRightAligned(
            cellField.isNested,
            cellField.type
          );

          GridBuilder.setSafeDataCell(data, row, col, {
            table: cellTable,
            field: cellField,
            totalExpression: totalExpression?.expression || '',
            totalIndex: i,
            totalType: totalExpression?.type,
            hasError: !!totalErrorMessage,
            errorMessage: totalErrorMessage,
            value,
            row,
            col,
            startCol: isTableHorizontal ? col : fieldStartCol,
            endCol: isTableHorizontal ? col : fieldEndCol,
            zIndex,
            isRightAligned,
            isFieldHeader: false,
            isTableHeader: false,
          });
        }
      }

      directionIndex += fieldSize;
    }

    return data;
  }