fun breaksData()

in plot-builder/src/commonMain/kotlin/org/jetbrains/letsPlot/core/plot/builder/PolarAxisUtil.kt [44:116]
63 lines of code
3 McCabe index (conditional complexity)

        fun breaksData(): PolarBreaksData {
            check(scaleBreaks.transformedValues.size == scaleBreaks.labels.size) {
                "Breaks and labels must have the same size"
            }

            val majorBreaks = breaksToClient(scaleBreaks.transformedValues)
                .mapIndexed { i, clientTick ->
                    IndexedValue(i, Triple(scaleBreaks.labels[i], scaleBreaks.transformedValues[i], clientTick))
                }
                .let {
                    if (it.size < 2) return@let it

                    val firstBr = it.first()
                    val lastBr = it.last()

                    if (firstBr.coord.subtract(lastBr.coord).length() > 3.0) return@let it

                    val newFirstBr = IndexedValue(
                        index = firstBr.index,
                        value = Triple(
                            "${lastBr.label}/${firstBr.label}", // Merge first and last label
                            firstBr.domValue,
                            firstBr.coord
                        )
                    )
                    val newLastBr = IndexedValue(
                        index = lastBr.index,
                        value = Triple(
                            "", // Empty label to not duplicate the merged label
                            lastBr.domValue,
                            lastBr.coord
                        )
                    )

                    val cleaned = it.toMutableList()
                    cleaned[newFirstBr.index] = newFirstBr
                    cleaned[newLastBr.index] = newLastBr
                    cleaned
                }

            val majorBreaksData = majorBreaks.mapNotNull { (_, br) ->
                val (label, domainTick, clientTick) = br
                val clientLine = buildGridLine(domainTick) ?: return@mapNotNull null
                Triple(label, clientTick, clientLine)
            }

            val minorBreaks = minorDomainBreaks(majorBreaks.map { it.value.second })
                .let { minorDomainBreaks ->
                    breaksToClient(minorDomainBreaks)
                        .mapIndexed { i, clientBreak -> Pair(minorDomainBreaks[i], clientBreak) }
                }

            val minorBreaksData = minorBreaks.mapNotNull { (domainTick, clientTick) ->
                val clientLine = buildGridLine(domainTick) ?: return@mapNotNull null
                Pair(clientTick, clientLine)
            }

            val axisLine = when (!orientation.isHorizontal) {
                true -> listOf(gridDomain.xRange().upperEnd).mapNotNull(::buildAngleGridLine).single()
                false -> listOf(gridDomain.yRange().upperEnd).mapNotNull(::buildRadiusGridLine).single()
            }

            return PolarBreaksData(
                majorBreaks = majorBreaksData.map { (_, tick, _) -> tick },
                majorGrid = majorBreaksData.map { (_, _, gridLine) -> gridLine },
                majorLabels = majorBreaksData.map { (label, _, _) -> label },
                minorBreaks = minorBreaksData.map { (tick, _) -> tick },
                minorGrid = minorBreaksData.map { (_, gridLine) -> gridLine },
                axisLine = axisLine,
                center = center,
                startAngle = coord.startAngle,
            )
        }