refactor: rename coerce function in state

Author: levinzonr

.gitignore

@@ -8,6 +8,9 @@
 /.idea/workspace.xml
 /.idea/navEditor.xml
 /.idea/assetWizardSettings.xml
+/.idea/misc.xml
+/.idea/deploymentTargetDropDown.xml
+/.idea/deploymentTargetSelector.xml
 .DS_Store
 /build
 /captures

.idea/deploymentTargetSelector.xml

@@ -37,10 +37,10 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
-import io.monstarlab.mosaic.slider.distribution.FragmentedLinearDistribution
 import io.monstarlab.mosaic.slider.Slider
 import io.monstarlab.mosaic.slider.SliderColors
 import io.monstarlab.mosaic.slider.distribution.SliderValueDistribution
+import io.monstarlab.mosaic.slider.distribution.CheckPointsValueDistribution
 import kotlin.math.roundToInt
 import androidx.compose.material3.Slider as MaterialSlider
 
@@ -84,11 +84,14 @@ fun MosaicSliderDemo() {
         }
 
         val fragmentedDistribution: SliderValueDistribution = remember {
-            FragmentedLinearDistribution.Builder()
-                .sliceAt(0.2f,0f)
-                .sliceAt(2f,0.3f)
-                .sliceAt(0.2f,0.7f)
-                .build()
+            CheckPointsValueDistribution(
+                listOf(
+                    0f to 0f,
+                    0.2f to 500f,
+                    0.4f to 800f,
+                    1f to 1000f,
+                ),
+            )
         }
 
         Slider(

.idea/misc.xml

@@ -46,7 +46,7 @@ internal fun Modifier.sliderSemantics(state: SliderState, enabled: Boolean): Mod
         if (!enabled) disabled()
         setProgress(
             action = { targetValue ->
-                val coercedValue = state.coerceValue(targetValue)
+                val coercedValue = state.coerceUserValue(targetValue)
                 // This is to keep it consistent with AbsSeekbar.java: return false if no
                 // change from current.
                 if (coercedValue == state.value) {

demo/src/main/java/io/monstarlab/mosaic/features/SliderDemo.kt

@@ -57,7 +57,7 @@ public class SliderState(
     public var value: Float
         get() = valueState
         set(value) {
-            valueState = coerceValue(value)
+            valueState = coerceUserValue(value)
         }
 
     /**
@@ -116,21 +116,21 @@ public class SliderState(
      * Scales offset in to the value that user should see
      */
     private fun scaleToUserValue(offset: Float): Float {
-
-        val value = valueDistribution.interpolate(offset / totalWidth)
+        val coercedValue = (offset / totalWidth).coerceIn(0f..1f)
+        val value = valueDistribution.interpolate(coercedValue)
             .fractionToValue(range)
-        return coerceValue(value)
+        return coerceUserValue(value)
     }
 
     /**
      * Converts value of the user into the raw offset on the track
      */
     private fun scaleToOffset(value: Float): Float {
-        val valueAsFraction = coerceValue(value).valueToFraction(range)
+        val valueAsFraction = coerceUserValue(value).valueToFraction(range)
         return valueDistribution.inverse(valueAsFraction).fractionToValue(0f, totalWidth)
     }
 
-    internal fun coerceValue(value: Float): Float {
+    internal fun coerceUserValue(value: Float): Float {
         return value
             .coerceIn(range)
             .coerceIntoDisabledRange()

slider/src/main/java/io/monstarlab/mosaic/slider/Modifiers.kt

@@ -2,13 +2,18 @@ package io.monstarlab.mosaic.slider.distribution
 
 import io.monstarlab.mosaic.slider.valueToFraction
 
-public class ValueCheckPointDistribution(valuesMap: List<Pair<Float, Float>>) :
+public class CheckPointsValueDistribution(
+    valuesMap: List<Pair<Float, Float>>
+) :
     SliderValueDistribution {
 
     private var equations: List<RangedLinearEquation>
 
     init {
-        require(valuesMap.isNotEmpty()) { "values map can't be empty" }
+        require(valuesMap.isNotEmpty()) {
+            "Values map can't be empty"
+        }
+
         val offsetRange = valuesMap.minOf { it.first }..valuesMap.maxOf { it.first }
         val valueRange = valuesMap.minOf { it.second }..valuesMap.maxOf { it.second }
         val zipped = valuesMap.sortedBy { it.first }
@@ -23,7 +28,7 @@ public class ValueCheckPointDistribution(valuesMap: List<Pair<Float, Float>>) :
             val x2Fraction = it.second.first.valueToFraction(offsetRange)
             val y1Fraction = it.first.second.valueToFraction(valueRange)
             val y2Fraction = it.second.second.valueToFraction(valueRange)
-            val equation = LinearEquation.fromTowPoints(
+            val equation = LinearEquation.fromTwoPoints(
                 x1 = x1Fraction,
                 x2 = x2Fraction,
                 y1 = y1Fraction,
@@ -33,22 +38,27 @@ public class ValueCheckPointDistribution(valuesMap: List<Pair<Float, Float>>) :
                 equation = equation,
                 offsetRange = x1Fraction..x2Fraction,
                 valueRange = y1Fraction..y2Fraction,
-
-                )
+            )
         }
     }
 
 
-    override fun interpolate(value: Float): Float =
-        equations.first { it.offsetRange.contains(value) }.equation.valueFromOffset(value)
+    override fun interpolate(value: Float): Float {
+        val equation = equations.firstOrNull { it.offsetRange.contains(value) }?.equation
+        checkNotNull(equation) { "No equation found for value $value during interpolate" }
+        return equation.valueFromOffset(value)
+    }
 
 
-    override fun inverse(value: Float): Float =
-        equations.first { it.valueRange.contains(value) }.equation.offsetFromValue(value)
+    override fun inverse(value: Float): Float {
+        val equation = equations.firstOrNull { it.valueRange.contains(value) }?.equation
+        checkNotNull(equation) { "No equation found for value $value during inverse" }
+        return equation.offsetFromValue(value)
+    }
 
 
     public class DecreasingValueException(progressValuePair: Pair<Float, Float>) :
-        Exception(
+        IllegalStateException(
             "Values must be always increasing with increasing progress," +
                     " item at progress ${progressValuePair.first}  with value " +
                     "${progressValuePair.second} is breaking this rule "

slider/src/main/java/io/monstarlab/mosaic/slider/SliderState.kt

@@ -8,12 +8,15 @@ public data class LinearEquation(
 
     public fun offsetFromValue(value: Float): Float = (value - c) / m
 
-   public companion object{
-       public fun fromTowPoints(x1:Float,y1:Float,x2:Float,y2:Float): LinearEquation {
-           require(x2!=x1){"can't calc equation from points with similar x value"}
-           val slope = (y2-y1)/(x2-x1)
-           val c = y2 - slope*x2
-           return  LinearEquation(slope,c)
-       }
-   }
+    public companion object {
+        public fun fromTwoPoints(
+            x1: Float, y1: Float,
+            x2: Float, y2: Float
+        ): LinearEquation {
+            require(x2 != x1) { "can't calc equation from points with similar x value" }
+            val slope = (y2 - y1) / (x2 - x1)
+            val c = y2 - slope * x2
+            return LinearEquation(slope, c)
+        }
+    }
 }

slider/src/main/java/io/monstarlab/mosaic/slider/distribution/ValueCheckPointDistribution.kt renamed to slider/src/main/java/io/monstarlab/mosaic/slider/distribution/CheckPointsValueDistribution.kt

@@ -1,21 +1,21 @@
 package io.monstarlab.mosaic.slider
 
-import io.monstarlab.mosaic.slider.distribution.ValueCheckPointDistribution
+import io.monstarlab.mosaic.slider.distribution.CheckPointsValueDistribution
 import org.junit.Assert.*
 
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
 
-class ValueCheckPointDistributionTest {
+class CheckPointsValueDistributionTest {
 
-    private  lateinit var valueCheckPointDistribution : ValueCheckPointDistribution
+    private  lateinit var checkPointsValueDistribution : CheckPointsValueDistribution
     private val accuracy = 0.0001f
 
     @Before
     fun setUp() {
 
-        valueCheckPointDistribution =  ValueCheckPointDistribution(
+        checkPointsValueDistribution =  CheckPointsValueDistribution(
             listOf(
                 0f to 0f,
                 25f to 25f,
@@ -31,8 +31,8 @@ class ValueCheckPointDistributionTest {
 
     @Test
     fun `test create from pairs with decreasing value`() {
-        assertThrows(ValueCheckPointDistribution.DecreasingValueException::class.java) {
-            ValueCheckPointDistribution(
+        assertThrows(CheckPointsValueDistribution.DecreasingValueException::class.java) {
+            CheckPointsValueDistribution(
                 listOf(
                     0f to 0f,
                     5f to 10f,
@@ -56,7 +56,7 @@ class ValueCheckPointDistributionTest {
             0.75f to 0.875f,
         )
         points.forEach {
-            assertEquals(it.second, valueCheckPointDistribution.interpolate(it.first), accuracy)
+            assertEquals(it.second, checkPointsValueDistribution.interpolate(it.first), accuracy)
         }
 
     }
@@ -73,7 +73,7 @@ class ValueCheckPointDistributionTest {
             0.75f to 0.875f,
         )
         points.forEach {
-            assertEquals(it.first, valueCheckPointDistribution.inverse(it.second), accuracy)
+            assertEquals(it.first, checkPointsValueDistribution.inverse(it.second), accuracy)
         }
 
     }