[Compose] Composable function that provides a linear gradient background with an auto content size measurement and a gradient offset as a size ratio.

SizeRatioLinearGradient.kt

@Immutable
class SizeRatioLinearGradient internal constructor(
    private val colors: List<Color>,
    private val stops: List<Float>? = null,
    private val start: Offset,
    private val end: Offset,
    private val tileMode: TileMode = TileMode.Clamp
) : ShaderBrush() {

    constructor(
        vararg colorStops: Pair<Float, Color>,
        start: Offset = Offset(0f, 0f),
        end: Offset = Offset(1f, 1f)
    ) : this(
        colors = List(colorStops.size) { i -> colorStops[i].second },
        stops = List(colorStops.size) { i -> colorStops[i].first },
        start = start,
        end = end,
    )

    override val intrinsicSize: Size
        get() =
            Size(
                if (start.x.isFinite() && end.x.isFinite()) abs(start.x - end.x) else Float.NaN,
                if (start.y.isFinite() && end.y.isFinite()) abs(start.y - end.y) else Float.NaN
            )

    override fun createShader(size: Size): Shader {
        val startX = start.x * size.width
        val startY = start.y * size.height
        val endX = end.x * size.width
        val endY = end.y * size.height
        return LinearGradientShader(
            colors = colors,
            colorStops = stops,
            from = Offset(startX, startY),
            to = Offset(endX, endY),
            tileMode = tileMode
        )
    }

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is SizeRatioLinearGradient) return false

        if (colors != other.colors) return false
        if (stops != other.stops) return false
        if (start != other.start) return false
        if (end != other.end) return false
        if (tileMode != other.tileMode) return false

        return true
    }

    override fun hashCode(): Int {
        var result = colors.hashCode()
        result = 31 * result + (stops?.hashCode() ?: 0)
        result = 31 * result + start.hashCode()
        result = 31 * result + end.hashCode()
        result = 31 * result + tileMode.hashCode()
        return result
    }

    override fun toString(): String {
        val startValue = if (start.isFinite) "start=$start, " else ""
        val endValue = if (end.isFinite) "end=$end, " else ""
        return "SizeRatioLinearGradient(colors=$colors, " +
                "stops=$stops, " +
                startValue +
                endValue +
                "tileMode=$tileMode)"
    }
}

Example

// Example.kt
Spacer(
    modifier = Modifier
        .size(100.dp)
        .background(
            brush = SizeRatioLinearGradient(
                colorStops = arrayOf(
                    0f to Color.Red,
                    1f to Color.Yellow,
                ),
                start = Offset(
                    x = 0.6f,
                    y = -0.2f,
                ),
                end = Offset(
                    x = 1f,
                    y = 1f,
                ),
            ),
            shape = RoundedCornerShape(8.dp),
        ),
)