min: greaterThen ? Number()

in src/sampleSlicer.ts [748:885]
104 lines of code
13 McCabe index (conditional complexity)

                    min: greaterThen ? Number(greaterThen.value) : null,
                    max: lessThen ? Number(lessThen.value) : null
                };

                this.behavior.scalableRange.setValue(range);
            }
        }
    }

    private onRangeInputTextboxChange(
        inputString: string,
        rangeValueType: RangeValueType,
        supressFilter: boolean = false
    ): void {
        // parse input
        let inputValue: number;
        if (!inputString) {
            inputValue = null;
        } else {
            inputValue = parseFloat(inputString);
            if (isNaN(inputValue)) {
                inputValue = null;
            }
        }
        // update range selection model if changed
        let range: ValueRange<number> = this.behavior.scalableRange.getValue();
        if (rangeValueType === RangeValueType.Start) {
            if (range.min === inputValue) {
                return;
            }
            range.min = inputValue;
        }
        else if (rangeValueType === RangeValueType.End) {
            if (range.max === inputValue) {
                return;
            }
            range.max = inputValue;
        }

        if (!supressFilter) {
            this.behavior.scalableRange.setValue(range);
            
            // trigger range change processing
            this.behavior.updateOnRangeSelectonChange();
            this.updateInternal(false);
        }
    }

    private enterSelection(cellSelection: Selection<any>): void {
        let settings: Settings = this.settings;
        
        let ulItemElement: Selection<any> = cellSelection
            .selectAll('ul')
            .data((dataPoint: SampleSlicerDataPoint) => {
                return [dataPoint];
            });

        ulItemElement 
            .exit()
            .remove();

        let ulItemElementEnter = ulItemElement
            .enter()
            .append('ul');
        
        ulItemElement = ulItemElement.merge(ulItemElementEnter)

        let listItemElement: Selection<any> = ulItemElement
            .selectAll(SampleSlicer.ItemContainerSelector.selectorName)
            .data((dataPoint: SampleSlicerDataPoint) => {
                return [dataPoint];
            });
        
        listItemElement.exit().remove();

        let listItemElementEnter = listItemElement
            .enter()
            .append('li');
        
        listItemElement = listItemElement.merge(listItemElementEnter);
        
        listItemElement
            .classed(SampleSlicer.ItemContainerSelector.className, true)
            .style('margin-left', PixelConverter.toString(settings.slicerItemContainer.marginLeft));

        let slicerTextWrapperSelection: Selection<any> = listItemElement
            .selectAll(SampleSlicer.SlicerTextWrapperSelector.selectorName)
            .data((dataPoint: SampleSlicerDataPoint) => {
                return [dataPoint];
            });
        
        slicerTextWrapperSelection.exit().remove();

        let slicerTextWrapperSelectionEnter = slicerTextWrapperSelection
            .enter()
            .append('div')
            .classed(SampleSlicer.SlicerTextWrapperSelector.className, true);
        
        slicerTextWrapperSelection = slicerTextWrapperSelection.merge(slicerTextWrapperSelectionEnter);

        let labelTextSelection: Selection<any> = slicerTextWrapperSelection
            .selectAll(SampleSlicer.LabelTextSelector.selectorName)
            .data((dataPoint: SampleSlicerDataPoint) => {
                return [dataPoint];
            });

        labelTextSelection.exit().remove();
        
        let labelTextSelectionEnter = labelTextSelection
            .enter()
            .append('span')
            .classed(SampleSlicer.LabelTextSelector.className, true);
        
        labelTextSelection = labelTextSelection.merge(labelTextSelectionEnter);

        labelTextSelection
          .style('font-size', PixelConverter.fromPoint(settings.slicerText.textSize));

    }

    private updateSelection(cellSelection: Selection<any>): void {
        let settings: Settings = this.settings,
            data: SampleSlicerData = this.slicerData;

        if (data && settings) {
            //update of rangeSlicer
            this.updateHeader();

            const slicerText: Selection<any> = cellSelection.selectAll(SampleSlicer.LabelTextSelector.selectorName),
                textProperties: TextProperties = SampleSlicer.getSampleTextProperties(settings.slicerText.textSize),
                formatString: string = data.formatString;

            slicerText.text((d: SampleSlicerDataPoint) => {
                let maxWidth: number = 0;

                textProperties.text = valueFormatter.format(d.category, formatString);

                if (this.settings.slicerText.width === 0) {