public static CONVERTER()

in src/chordChart.ts [269:534]
230 lines of code
41 McCabe index (conditional complexity)

  public static CONVERTER(
    dataView: DataView,
    host: IVisualHost,
    colors: IColorPalette,
    localizationManager: ILocalizationManager
  ): ChordChartData {
    const settings: Settings = Settings.PARSE_SETTINGS(dataView, colors);
    const columns: ChordChartColumns<ChordChartCategoricalColumns> =
      ChordChartColumns.GET_CATEGORICAL_COLUMNS(dataView);
    const sources: ChordChartColumns<DataViewMetadataColumn> =
      ChordChartColumns.GET_COLUMN_SOURCES(dataView);
    const categoricalValues: ChordChartColumns<any> =
      ChordChartColumns.GET_CATEGORICAL_VALUES(dataView);
    const prevAxisVisible = settings.axis.show;

    if (!categoricalValues || lodashIsempty(categoricalValues.Category)) {
      return null;
    }

    if (!categoricalValues.Y) {
      categoricalValues.Y = [];
      for (let i: number = 0; i < categoricalValues.Category.length; i++) {
        categoricalValues.Series.push(sources.Series.displayName + i);
        categoricalValues.Y.push(ChordChart.defaultValue1);
      }
    }

    categoricalValues.Series =
      categoricalValues.Series || ChordChartColumns.GET_SERIES_VALUES(dataView);
    let grouped: DataViewValueColumnGroup[] = null;
    if (columns.Series) {
      grouped = columns.Series.grouped();
    }

    let dataMatrix: number[][] = [];
    let renderingDataMatrix: number[][] = [];
    let toolTipData: ChordTooltipData[][] = [];
    let sliceTooltipData: ChordTooltipData[] = [];
    let max: number = ChordChart.MaxValue;
    let seriesIndex: ChordChartCategoricalDict = this.convertCategoricalToArray(
      categoricalValues.Series
    ); // series index array
    let catIndex: ChordChartCategoricalDict = this.convertCategoricalToArray(
      categoricalValues.Category
    ); // index array for category names
    let isDiffFromTo: boolean = false; // boolean variable indicates that From and To are different
    let labelData: ChordArcLabelData[] = []; // label data: !important

    const colorHelper: ColorHelper = new ColorHelper(
      colors,
      { objectName: "dataPoint", propertyName: "fill" },
      settings.dataPoint.defaultColor
    );

    let totalFields: any[] = this.union_arrays(
      categoricalValues.Category,
      categoricalValues.Series
    ).reverse();

    if (
      ChordChart.getValidArrayLength(totalFields) ===
      ChordChart.getValidArrayLength(categoricalValues.Category) +
        ChordChart.getValidArrayLength(categoricalValues.Series)
    ) {
      isDiffFromTo = true;
    }

    let categoryColumnFormatter: IValueFormatter = create({
      format:
        getFormatStringByColumn(sources.Category, true) ||
        sources.Category.format,
    });
    let seriesColumnFormatter: IValueFormatter = create({
      format:
        sources.Series &&
        (getFormatStringByColumn(sources.Series, true) ||
          sources.Series.format),
    });
    let valueColumnFormatter: IValueFormatter = create({
      format: sources.Y
        ? getFormatStringByColumn(sources.Y, true) || sources.Y.format
        : "0",
    });

    const selectionIds: ISelectionId[] = [];

    for (let i: number = 0, iLength: number = totalFields.length; i < iLength; i++) {
      let selectionId: ISelectionId = null;
      let barFillColor: string = "";
      let isCategory: boolean = false;
      let index: number;

      const label: string =
        sources.Series && i < categoricalValues.Series.length
          ? seriesColumnFormatter.format(totalFields[i])
          : categoryColumnFormatter.format(totalFields[i]);

      if ((index = catIndex[totalFields[i]]) !== undefined) {
        selectionId = host
          .createSelectionIdBuilder()
          .withCategory(columns.Category, index)
          .createSelectionId();

        isCategory = true;

        let thisCategoryObjects: DataViewObjects = columns.Category.objects
          ? columns.Category.objects[index]
          : undefined;

        barFillColor = colorHelper.getColorForSeriesValue(
          thisCategoryObjects,
          categoricalValues.Category[index]
        );
      } else if ((index = seriesIndex[totalFields[i]]) !== undefined) {
        let seriesObjects: DataViewObjects = grouped
          ? grouped[index].objects
          : null;

        let seriesData: DataViewValueColumn = columns.Y
          ? columns.Y[index]
          : {
              objects: null,
              source: {
                displayName: "Value",
                queryName: "Value",
                groupName: "Value",
              },
              values: [ChordChart.defaultValue1],
            };

        let seriesNameStr: PrimitiveValue = seriesData
          ? converterHelper.getSeriesName(seriesData.source)
          : "Value";

        selectionId = host
          .createSelectionIdBuilder()
          .withSeries(columns.Series, grouped ? grouped[index] : null)
          .withMeasure(seriesNameStr ? seriesNameStr.toString() : null)
          .createSelectionId();
        isCategory = false;

        barFillColor = colorHelper.getColorForSeriesValue(
          seriesObjects,
          seriesNameStr ? seriesNameStr : `${ChordChart.defaultValue1}`
        );
      }

      const barStrokeColor: string = colorHelper.getHighContrastColor(
        "foreground",
        barFillColor
      );

      selectionIds.push(selectionId);

      labelData.push({
        label,
        isCategory,
        barFillColor,
        barStrokeColor,
        labelColor: settings.labels.color,
        isGrouped: !!grouped,
        labelFontSize: PixelConverter.fromPointToPixel(
          settings.labels.fontSize
        ),
      });

      renderingDataMatrix.push([]);
      dataMatrix.push([]);
      toolTipData.push([]);

      for (let j: number = 0, jLength: number = totalFields.length; j < jLength; j++) {
        let elementValue: number = 0;
        let tooltipInfo: VisualTooltipDataItem[] = [];

        if (catIndex[totalFields[i]] !== undefined && seriesIndex[totalFields[j]] !== undefined) {
          let row: number = catIndex[totalFields[i]];
          let col: number = seriesIndex[totalFields[j]];

          if (columns.Y && columns.Y[col].values[row] !== null) {
            elementValue = <number>columns.Y[col].values[row];

            if (elementValue > max) {
              max = elementValue;
            }

            tooltipInfo = createTooltipInfo(
              dataView.categorical,
              label,
              valueColumnFormatter.format(elementValue),
              col,
              row,
              localizationManager
            );
          } else if (!columns.Y) {
            max = ChordChart.defaultValue1;
            elementValue = ChordChart.defaultValue1;
            tooltipInfo = createTooltipInfo(
              dataView.categorical,
              label,
              valueColumnFormatter.format(`${ChordChart.defaultValue1}`),
              col,
              row,
              localizationManager
            );
          }
        } else if (
          isDiffFromTo &&
          catIndex[totalFields[j]] !== undefined &&
          seriesIndex[totalFields[i]] !== undefined
        ) {
          let row: number = catIndex[totalFields[j]];
          let col: number = seriesIndex[totalFields[i]];

          if (columns.Y && columns.Y[col].values[row] !== null) {
            elementValue = <number>columns.Y[col].values[row];
          } else if (!columns.Y) {
            elementValue = ChordChart.defaultValue1;
          }
        }

        renderingDataMatrix[i].push(Math.max(elementValue || 0, 0));
        dataMatrix[i].push(elementValue || 0);
        toolTipData[i].push({
          tooltipInfo: tooltipInfo,
        });
      }

      let totalSum: number = sum(dataMatrix[i]);

      sliceTooltipData.push({
        tooltipInfo: [
          {
            displayName: label,
            value: valueColumnFormatter.format(totalSum),
          },
        ],
      });
    }

    let chordLayout: ChordLayout = chord();
    chordLayout.padAngle(ChordChart.ChordLayoutPadding);
    let chords: Chords = chordLayout(renderingDataMatrix);

    const groups: ChordArcDescriptor[] = ChordChart.getChordArcDescriptors(
      ChordChart.COPY_ARC_DESCRIPTORS_WITHOUT_NAN_VALUES(chords.groups),
      labelData,
      selectionIds
    );

    const unitLength: number =
      Math.round(max / ChordChart.MaxUnitSize).toString().length - 1;

    return {
      dataMatrix: dataMatrix,
      dataView: dataView,
      settings: settings,
      tooltipData: toolTipData,
      sliceTooltipData: sliceTooltipData,
      tickUnit: Math.pow(10, unitLength),
      differentFromTo: isDiffFromTo,
      prevAxisVisible:
        prevAxisVisible === undefined ? settings.axis.show : prevAxisVisible,
      groups: groups,
      chords: chords,
    };
  }