protected createCategoricalDataViewBuilder()

in src/dataViewBuilder/testDataViewBuilder.ts [239:309]
59 lines of code
12 McCabe index (conditional complexity)

    protected createCategoricalDataViewBuilder(
        categoriesColumns: (TestDataViewBuilderCategoryColumnOptions | TestDataViewBuilderCategoryColumnOptions[])[],
        valuesColumns: (DataViewBuilderValuesColumnOptions | DataViewBuilderValuesColumnOptions[])[],
        columnNames: string[],
        customizeColumns?: CustomizeColumnFn): IDataViewBuilderCategorical {

        let builder = createCategoricalDataViewBuilder();

        let originalOptions = TestDataViewBuilder.createDataViewBuilderColumnOptions(
            categoriesColumns,
            valuesColumns,
            columnNames && (options => includes(columnNames, options.source.displayName)),
            customizeColumns);

        let options = TestDataViewBuilder.setUpDataViewBuilderColumnOptions(originalOptions, this.aggregateFunction);

        if (!isEmpty(options.categories)) {
            let identityFrom = TestDataViewBuilder.getDataViewBuilderColumnIdentitySources(options.categories);

            builder.withCategories(options.categories.map((category, i) => <DataViewCategoryColumn>{
                source: category.source,
                values: category.values,
                objects: category.objects,
                identity: identityFrom[i].identities,
                identityFields: identityFrom[i].fields
            }));
        }

        if (!isEmpty(options.grouped)) {
            let groupedCategory = options.grouped[0]; // Finished only for one category.

            let categoryValues = originalOptions.categories
                && originalOptions.categories[0]
                && originalOptions.categories[0].values
                || [];

            let uniqueCategoryValues = uniq(categoryValues) || [undefined],
                uniqueGroupedValues = uniq(groupedCategory.values);

            builder.withGroupedValues({
                groupColumn: {
                    source: groupedCategory.source,
                    values: uniqueGroupedValues,
                    identityFrom: TestDataViewBuilder.getDataViewBuilderColumnIdentitySources(groupedCategory)[0]
                } as DataViewBuilderCategoryColumnOptions,
                valueColumns: options.values.map(x => <TestDataViewBuilderColumnOptions>{ source: x.source }),
                data: uniqueGroupedValues.map(groupedValue => options.values.map((column, columnIndex) =>
                    <DataViewBuilderSeriesData>{
                        values: column.values && uniqueCategoryValues
                            .map(categoryValue => {
                                let index = findIndex(range(categoryValues.length),
                                    i => categoryValues[i] === categoryValue && groupedCategory.values[i] === groupedValue);
                                return column.values[index] === undefined ? null : column.values[index];
                            }),
                        highlights: column.highlights,
                        minLocal: column.minLocal,
                        maxLocal: column.maxLocal
                    }))
            });
        } else if (!isEmpty(options.values)) {
            builder.withValues({ columns: options.values });
        }

        let builderBuild = builder.build.bind(builder);

        builder.build = () => {
            return TestDataViewBuilder.setUpDataView(builderBuild(), options);
        };

        return builder;
    }