@momo-kits/native-kits 0.162.1-gif.2-debug → 0.162.1-gif.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.162.1-gif.2-debug",
+  "version": "0.162.1-gif.2",
   "private": false,
   "dependencies": {},
   "devDependencies": {},

package/build.gradle.kts

@@ -1,11 +0,0 @@
-plugins {
-    // this is necessary to avoid the plugins to be loaded multiple times
-    // in each subproject's classloader
-    alias(libs.plugins.android.application) apply false
-    alias(libs.plugins.android.library) apply false
-    alias(libs.plugins.compose) apply false
-    alias(libs.plugins.kotlin.compose.compiler) apply false
-    alias(libs.plugins.jetbrains.kotlin.multiplatform) apply false
-    alias(libs.plugins.jetbrains.kotlin.serialization) apply false
-    alias(libs.plugins.vanniktech.mavenPublish) apply false
-}

package/compose/build.gradle.kts

@@ -1,189 +0,0 @@
-// import com.vanniktech.maven.publish.JavadocJar
-// import com.vanniktech.maven.publish.KotlinMultiplatform
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-
-plugins {
-    alias(libs.plugins.jetbrains.kotlin.multiplatform)
-    alias(libs.plugins.android.library)
-    alias(libs.plugins.compose)
-    alias(libs.plugins.kotlin.compose.compiler)
-//         alias(libs.plugins.vanniktech.mavenPublish)
-    id(libs.plugins.jetbrains.kotlin.cocoapods.get().pluginId)
-    kotlin("plugin.serialization")
-}
-
-val gitlabName: String? = findProperty("name") as String? ?: ""
-val gitlabRepo: String? = findProperty("repo") as String? ?: ""
-val gitlabUrl: String? = findProperty("url") as String? ?: ""
-val gitlabGroup: String? = findProperty("group") as String? ?: ""
-val gitlabArtifactId: String = findProperty("artifact.id") as String? ?: ""
-val gitlabVersion: String? = findProperty("version") as String? ?: ""
-val gitlabUser: String? = findProperty("gitlab.user") as String? ?: ""
-val gitlabKey: String? = findProperty("gitlab.password") as String? ?: ""
-
-kotlin {
-    androidTarget {
-        compilerOptions {
-            jvmTarget.set(JvmTarget.JVM_17)
-        }
-        publishLibraryVariants("release")
-    }
-
-    val fwName = gitlabArtifactId
-    val iosTargets = listOf(iosArm64(), iosSimulatorArm64())
-    iosTargets.forEach {
-        it.binaries.framework {
-            baseName = fwName
-            binaryOption("bundleId", "$gitlabGroup.$fwName")
-            isStatic = true
-        }
-    }
-
-    cocoapods {
-        version = "0.162.1-gif.2-debug"
-        summary = "IOS Shared module"
-        homepage = "https://momo.vn"
-        ios.deploymentTarget = "15.0"
-
-        framework {
-            baseName = fwName
-            isStatic = true
-        }
-
-        pod("lottie-ios") {
-            moduleName = "Lottie"
-            version = "4.4.3"
-            extraOpts += listOf("-compiler-option", "-fmodules")
-        }
-    }
-
-    sourceSets {
-        commonMain.dependencies {
-            implementation(compose.runtime)
-            implementation(compose.material)
-            implementation(compose.material3)
-            implementation(compose.components.resources)
-            implementation(libs.compose.ui.backhandler)
-            implementation(libs.ktor.client.core)
-            implementation(libs.jetbrains.coroutines.core)
-            implementation(libs.navigation.multiplatform)
-            implementation(libs.coil.multiplatform.compose)
-            implementation(libs.coil.multiplatform.core)
-            implementation(libs.coil.multiplatform.network.ktor)
-            implementation(libs.jetbrains.serialization.json)
-            implementation(libs.kotlinx.datetime)
-            api(libs.native.max.api)
-            implementation(libs.compottie)
-            implementation(libs.sketch.compose)
-            implementation(libs.sketch.http.ktor3)
-            implementation(libs.sketch.animated.gif)
-        }
-        androidMain.dependencies {
-            implementation(libs.ktor.client.okhttp)
-            implementation(libs.airbnb.lottie)
-        }
-        iosMain.dependencies {
-            implementation(libs.ktor.client.darwin)
-        }
-    }
-}
-
-android {
-    namespace = "vn.momo.kits.kits"
-    compileSdk = 35
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
-    }
-    defaultConfig {
-        minSdk = 24
-    }
-}
-
-dependencies {
-}
-
-repositories {
-    google {
-        mavenContent {
-            includeGroupAndSubgroups("androidx")
-            includeGroupAndSubgroups("com.android")
-            includeGroupAndSubgroups("com.google")
-        }
-    }
-    mavenCentral()
-    maven { url = uri("https://maven.pkg.jetbrains.space/public/p/compose/dev") }
-    maven {
-        url = uri("https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven")
-        credentials {username = "download_packages"; password = "gldt-bjDqLpU_sPcHDuXau2ws" }
-    }
-    maven {
-        url = uri("https://artifacts.mservice.com.vn/repository/maven-momo-app/")
-        credentials {
-            username = "viewer"
-            password = "viewer"
-        }
-        isAllowInsecureProtocol = true
-    }
-}
-
-compose {
-    resources {
-        publicResClass = true
-        packageOfResClass = "vn.momo.uikits.resources"
-        generateResClass = always
-    }
-}
-
-// publishing {
-//     repositories {
-//         maven {
-//             name = "${gitlabRepo}Packages"
-//             credentials {
-//                 username = gitlabUser
-//                 password = gitlabKey
-//             }
-//             url = uri("$gitlabUrl")
-//         }
-//     }
-// }
-
-// mavenPublishing {
-//     configure(
-//         KotlinMultiplatform(
-//             javadocJar = JavadocJar.Empty(),
-//             sourcesJar = true,
-//             androidVariantsToPublish = listOf("release")
-//         )
-//     )
-// 
-//     repositories {
-//         maven {
-//             name = "${gitlabRepo}Packages"
-//             credentials { username = gitlabUser; password = gitlabKey }
-//             url = uri("$gitlabUrl")
-//         }
-//     }
-// 
-//     coordinates(gitlabGroup.toString(), gitlabArtifactId, gitlabVersion.toString())
-// 
-//     pom {
-//         name = "$gitlabName Klib"
-//         description = "$gitlabName"
-//         url = "https://gitlab.mservice.com.vn"
-//         licenses {
-//             license {
-//                 name = "The Apache License, Version 2.0"
-//                 url = "https://www.apache.org/licenses/LICENSE-2.0.txt"
-//                 distribution = "https://www.apache.org/licenses/LICENSE-2.0.txt"
-//             }
-//         }
-//         developers {
-//             developer {
-//                 id = "kotlin-hands-on"
-//                 name = "Kotlin Developer Advocate"
-//                 url = "https://github.com/kotlin-hands-on/"
-//             }
-//         }
-//     }
-// }

package/compose/build.gradle.kts.backup

@@ -1,189 +0,0 @@
-import com.vanniktech.maven.publish.JavadocJar
-import com.vanniktech.maven.publish.KotlinMultiplatform
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-
-plugins {
-    alias(libs.plugins.jetbrains.kotlin.multiplatform)
-    alias(libs.plugins.android.library)
-    alias(libs.plugins.compose)
-    alias(libs.plugins.kotlin.compose.compiler)
-    alias(libs.plugins.vanniktech.mavenPublish)
-    id(libs.plugins.jetbrains.kotlin.cocoapods.get().pluginId)
-    kotlin("plugin.serialization")
-}
-
-val gitlabName: String? = findProperty("name") as String? ?: ""
-val gitlabRepo: String? = findProperty("repo") as String? ?: ""
-val gitlabUrl: String? = findProperty("url") as String? ?: ""
-val gitlabGroup: String? = findProperty("group") as String? ?: ""
-val gitlabArtifactId: String = findProperty("artifact.id") as String? ?: ""
-val gitlabVersion: String? = findProperty("version") as String? ?: ""
-val gitlabUser: String? = findProperty("gitlab.user") as String? ?: ""
-val gitlabKey: String? = findProperty("gitlab.password") as String? ?: ""
-
-kotlin {
-    androidTarget {
-        compilerOptions {
-            jvmTarget.set(JvmTarget.JVM_17)
-        }
-        publishLibraryVariants("release")
-    }
-
-    val fwName = gitlabArtifactId
-    val iosTargets = listOf(iosArm64(), iosSimulatorArm64())
-    iosTargets.forEach {
-        it.binaries.framework {
-            baseName = fwName
-            binaryOption("bundleId", "$gitlabGroup.$fwName")
-            isStatic = true
-        }
-    }
-
-    cocoapods {
-        version = gitlabVersion
-        summary = "IOS Shared module"
-        homepage = "https://momo.vn"
-        ios.deploymentTarget = "15.0"
-
-        framework {
-            baseName = fwName
-            isStatic = true
-        }
-
-        pod("lottie-ios") {
-            moduleName = "Lottie"
-            version = "4.4.3"
-            extraOpts += listOf("-compiler-option", "-fmodules")
-        }
-    }
-
-    sourceSets {
-        commonMain.dependencies {
-            implementation(compose.runtime)
-            implementation(compose.material)
-            implementation(compose.material3)
-            implementation(compose.components.resources)
-            implementation(libs.compose.ui.backhandler)
-            implementation(libs.ktor.client.core)
-            implementation(libs.jetbrains.coroutines.core)
-            implementation(libs.navigation.multiplatform)
-            implementation(libs.coil.multiplatform.compose)
-            implementation(libs.coil.multiplatform.core)
-            implementation(libs.coil.multiplatform.network.ktor)
-            implementation(libs.jetbrains.serialization.json)
-            implementation(libs.kotlinx.datetime)
-            api(libs.native.max.api)
-            implementation(libs.compottie)
-            implementation(libs.sketch.compose)
-            implementation(libs.sketch.http.ktor3)
-            implementation(libs.sketch.animated.gif)
-        }
-        androidMain.dependencies {
-            implementation(libs.ktor.client.okhttp)
-            implementation(libs.airbnb.lottie)
-        }
-        iosMain.dependencies {
-            implementation(libs.ktor.client.darwin)
-        }
-    }
-}
-
-android {
-    namespace = "$gitlabGroup.$gitlabArtifactId"
-    compileSdk = libs.versions.android.compileSdk.get().toInt()
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
-    }
-    defaultConfig {
-        minSdk = libs.versions.android.minSdk.get().toInt()
-    }
-}
-
-dependencies {
-}
-
-repositories {
-    google {
-        mavenContent {
-            includeGroupAndSubgroups("androidx")
-            includeGroupAndSubgroups("com.android")
-            includeGroupAndSubgroups("com.google")
-        }
-    }
-    mavenCentral()
-    maven { url = uri("https://maven.pkg.jetbrains.space/public/p/compose/dev") }
-    maven {
-        url = uri("https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven")
-        credentials {username = "download_packages"; password = "gldt-bjDqLpU_sPcHDuXau2ws" }
-    }
-    maven {
-        url = uri("https://artifacts.mservice.com.vn/repository/maven-momo-app/")
-        credentials {
-            username = "viewer"
-            password = "viewer"
-        }
-        isAllowInsecureProtocol = true
-    }
-}
-
-compose {
-    resources {
-        publicResClass = true
-        packageOfResClass = "vn.momo.uikits.resources"
-        generateResClass = always
-    }
-}
-
-publishing {
-    repositories {
-        maven {
-            name = "${gitlabRepo}Packages"
-            credentials {
-                username = gitlabUser
-                password = gitlabKey
-            }
-            url = uri("$gitlabUrl")
-        }
-    }
-}
-
-mavenPublishing {
-    configure(
-        KotlinMultiplatform(
-            javadocJar = JavadocJar.Empty(),
-            sourcesJar = true,
-            androidVariantsToPublish = listOf("release")
-        )
-    )
-
-    repositories {
-        maven {
-            name = "${gitlabRepo}Packages"
-            credentials { username = gitlabUser; password = gitlabKey }
-            url = uri("$gitlabUrl")
-        }
-    }
-
-    coordinates(gitlabGroup.toString(), gitlabArtifactId, gitlabVersion.toString())
-
-    pom {
-        name = "$gitlabName Klib"
-        description = "$gitlabName"
-        url = "https://gitlab.mservice.com.vn"
-        licenses {
-            license {
-                name = "The Apache License, Version 2.0"
-                url = "https://www.apache.org/licenses/LICENSE-2.0.txt"
-                distribution = "https://www.apache.org/licenses/LICENSE-2.0.txt"
-            }
-        }
-        developers {
-            developer {
-                id = "kotlin-hands-on"
-                name = "Kotlin Developer Advocate"
-                url = "https://github.com/kotlin-hands-on/"
-            }
-        }
-    }
-}

package/compose/compose.podspec

@@ -1,47 +0,0 @@
-Pod::Spec.new do |spec|
-    spec.name                     = 'compose'
-    spec.version                  = '0.162.1-beta.7'
-    spec.homepage                 = 'https://momo.vn'
-    spec.source                   = { :http=> ''}
-    spec.authors                  = ''
-    spec.license                  = ''
-    spec.summary                  = 'IOS Shared module'
-    spec.vendored_frameworks      = 'build/cocoapods/framework/kits.framework'
-    spec.libraries                = 'c++'
-    spec.ios.deployment_target    = '15.0'
-    spec.dependency 'lottie-ios', '4.4.3'
-    if !Dir.exist?('build/cocoapods/framework/kits.framework') || Dir.empty?('build/cocoapods/framework/kits.framework')
-        raise "
-        Kotlin framework 'kits' doesn't exist yet, so a proper Xcode project can't be generated.
-        'pod install' should be executed after running ':generateDummyFramework' Gradle task:
-            ./gradlew :compose:generateDummyFramework
-        Alternatively, proper pod installation is performed during Gradle sync in the IDE (if Podfile location is set)"
-    end
-    spec.xcconfig = {
-        'ENABLE_USER_SCRIPT_SANDBOXING' => 'NO',
-    }
-    spec.pod_target_xcconfig = {
-        'KOTLIN_PROJECT_PATH' => ':compose',
-        'PRODUCT_MODULE_NAME' => 'kits',
-    }
-    spec.script_phases = [
-        {
-            :name => 'Build compose',
-            :execution_position => :before_compile,
-            :shell_path => '/bin/sh',
-            :script => <<-SCRIPT
-                if [ "YES" = "$OVERRIDE_KOTLIN_BUILD_IDE_SUPPORTED" ]; then
-                    echo "Skipping Gradle build task invocation due to OVERRIDE_KOTLIN_BUILD_IDE_SUPPORTED environment variable set to \"YES\""
-                    exit 0
-                fi
-                set -ev
-                REPO_ROOT="$PODS_TARGET_SRCROOT"
-                "$REPO_ROOT/../gradlew" -p "$REPO_ROOT" $KOTLIN_PROJECT_PATH:syncFramework \
-                    -Pkotlin.native.cocoapods.platform=$PLATFORM_NAME \
-                    -Pkotlin.native.cocoapods.archs="$ARCHS" \
-                    -Pkotlin.native.cocoapods.configuration="$CONFIGURATION"
-            SCRIPT
-        }
-    ]
-    spec.resources = ['build/compose/cocoapods/compose-resources']
-end

package/compose/src/androidMain/kotlin/vn/momo/kits/fpsmonitor/FPSGraphView.kt

@@ -1,250 +0,0 @@
-package vn.momo.kits.fpsmonitor
-
-import android.content.Context
-import android.graphics.Canvas
-import android.graphics.Color
-import android.graphics.Paint
-import android.graphics.Rect
-import android.graphics.RectF
-import android.view.View
-import kotlin.math.max
-import kotlin.math.min
-
-class FPSGraphView(context: Context) : View(context) {
-    private val fpsValues = mutableListOf<Float>()
-    private val cpuTimeValues = mutableListOf<Float>()
-    private val gpuTimeValues = mutableListOf<Float>()
-    private val maxPoints = 100
-
-    private var currentMetrics: FPSMetrics? = null
-    private var collapsed = false
-    private val density = resources.displayMetrics.density
-    private val scaledDensity = resources.displayMetrics.density * resources.configuration.fontScale
-
-    private val fpsColor = Color.rgb(0, 255, 0)
-    private val cpuColor = Color.rgb(255, 165, 0)
-    private val gpuColor = Color.rgb(0, 191, 255)
-    private val memColor = Color.rgb(255, 105, 180)
-    private val backgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-        color = Color.argb(153, 0, 0, 0)
-    }
-    private val textPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-        color = Color.WHITE
-        textSize = 12.sp
-    }
-    private val linePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-        strokeWidth = 1.25f.dp
-        style = Paint.Style.STROKE
-    }
-    private val gridPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-        color = Color.argb(25, 255, 255, 255)
-        strokeWidth = 0.5f.dp
-        style = Paint.Style.STROKE
-    }
-
-    init {
-        setLayerType(LAYER_TYPE_SOFTWARE, null)
-    }
-
-    fun toggleCollapse() {
-        collapsed = !collapsed
-        requestLayout()
-        invalidate()
-    }
-
-    fun updateMetrics(metrics: FPSMetrics) {
-        currentMetrics = metrics
-        append(fpsValues, metrics.fps)
-        append(cpuTimeValues, metrics.estCPUTimePerFrameMs)
-        append(gpuTimeValues, metrics.estGPUTimePerFrameMs)
-        requestLayout()
-        invalidate()
-    }
-
-    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-        if (collapsed) {
-            setMeasuredDimension(72.dp.toInt(), 44.dp.toInt())
-            return
-        }
-
-        textPaint.textSize = 12.sp
-        val metrics = currentMetrics
-        val deviceInfo = metrics?.deviceInfo
-        val lines = listOf(
-            "${deviceInfo?.deviceName ?: "Device"} [${deviceInfo?.resolution ?: "0x0"}]",
-            "${String.format("%.1f", deviceInfo?.density ?: 1f)}x ${deviceInfo?.refreshRate?.toInt() ?: 60}Hz",
-            "Pre: 99.99ms [99.99 99.99]",
-            "GPU: 99.99ms [99.99 99.99]",
-            "Mem: 999.9MB",
-            "FPS: 99.99 [99.99 99.99]",
-        )
-        val desiredWidth = max(220.dp, lines.maxOf { textPaint.measureText(it) } + 16.dp).toInt()
-        val desiredHeight = 156.dp.toInt()
-
-        setMeasuredDimension(
-            resolveSize(desiredWidth, widthMeasureSpec),
-            resolveSize(desiredHeight, heightMeasureSpec),
-        )
-    }
-
-    override fun onDraw(canvas: Canvas) {
-        super.onDraw(canvas)
-        canvas.drawRoundRect(RectF(0f, 0f, width.toFloat(), height.toFloat()), 8.dp, 8.dp, backgroundPaint)
-
-        if (collapsed) {
-            drawCollapsed(canvas)
-        } else {
-            drawExpanded(canvas)
-        }
-    }
-
-    private fun drawCollapsed(canvas: Canvas) {
-        val fpsText = String.format("%.0f", currentMetrics?.fps ?: 0f)
-        textPaint.color = Color.WHITE
-        textPaint.textSize = 18.sp
-        val bounds = Rect()
-        textPaint.getTextBounds(fpsText, 0, fpsText.length, bounds)
-        canvas.drawText(
-            fpsText,
-            (width - bounds.width()) / 2f,
-            (height + bounds.height()) / 2f,
-            textPaint,
-        )
-    }
-
-    private fun drawExpanded(canvas: Canvas) {
-        val metrics = currentMetrics
-        val margin = 8.dp
-        var y = margin + 12.sp
-
-        textPaint.textSize = 12.sp
-        textPaint.color = Color.WHITE
-
-        val deviceInfo = metrics?.deviceInfo
-        drawSplit(canvas, deviceInfo?.deviceName ?: "Device", "[${deviceInfo?.resolution ?: "0x0"}]", y, Color.WHITE)
-        y += 15.sp
-        drawSplit(
-            canvas,
-            "${String.format("%.1f", deviceInfo?.density ?: 1f)}x",
-            "${deviceInfo?.refreshRate?.toInt() ?: 60}Hz",
-            y,
-            Color.WHITE,
-        )
-        y += 18.sp
-
-        val cpuMinMax = minMax(cpuTimeValues, metrics?.estCPUTimePerFrameMs ?: 0f)
-        val gpuMinMax = minMax(gpuTimeValues, metrics?.estGPUTimePerFrameMs ?: 0f)
-        val fpsMinMax = minMax(fpsValues, metrics?.fps ?: 0f)
-
-        drawSplit(
-            canvas,
-            "Pre: ${String.format("%.2f", metrics?.estCPUTimePerFrameMs ?: 0f)}ms",
-            "[${String.format("%.2f", cpuMinMax.first)} ${String.format("%.2f", cpuMinMax.second)}]",
-            y,
-            cpuColor,
-        )
-        y += 15.sp
-
-        drawSplit(
-            canvas,
-            "GPU: ${String.format("%.2f", metrics?.estGPUTimePerFrameMs ?: 0f)}ms",
-            "[${String.format("%.2f", gpuMinMax.first)} ${String.format("%.2f", gpuMinMax.second)}]",
-            y,
-            gpuColor,
-        )
-        y += 15.sp
-
-        drawText(canvas, "Mem: ${String.format("%.1f", metrics?.appMemoryMB ?: 0f)}MB", margin, y, memColor)
-        y += 15.sp
-
-        drawSplit(
-            canvas,
-            "FPS: ${String.format("%.2f", metrics?.fps ?: 0f)}",
-            "[${String.format("%.2f", fpsMinMax.first)} ${String.format("%.2f", fpsMinMax.second)}]",
-            y,
-            fpsColor,
-        )
-        y += 17.sp
-
-        val graphHeight = height - y - margin
-        if (graphHeight > 24.dp) {
-            drawGraph(canvas, margin, y, width - margin * 2, graphHeight)
-        }
-    }
-
-    private fun drawSplit(canvas: Canvas, left: String, right: String, y: Float, color: Int) {
-        val margin = 8.dp
-        drawText(canvas, left, margin, y, color)
-        textPaint.color = color
-        canvas.drawText(right, width - margin - textPaint.measureText(right), y, textPaint)
-    }
-
-    private fun drawText(canvas: Canvas, text: String, x: Float, y: Float, color: Int) {
-        textPaint.color = color
-        canvas.drawText(text, x, y, textPaint)
-    }
-
-    private fun drawGraph(canvas: Canvas, x: Float, y: Float, graphWidth: Float, graphHeight: Float) {
-        canvas.drawRect(x, y, x + graphWidth, y + graphHeight, gridPaint)
-        for (index in 1..3) {
-            val gridY = y + index * (graphHeight / 4f)
-            canvas.drawLine(x + 2.dp, gridY, x + graphWidth - 2.dp, gridY, gridPaint)
-        }
-
-        var gridX = x + 16.dp
-        while (gridX < x + graphWidth) {
-            canvas.drawLine(gridX, y, gridX, y + graphHeight, gridPaint)
-            gridX += 16.dp
-        }
-
-        linePaint.color = fpsColor
-        drawDataLine(canvas, fpsValues, x, y, graphWidth, graphHeight, 60f)
-        linePaint.color = cpuColor
-        drawDataLine(canvas, cpuTimeValues, x, y, graphWidth, graphHeight, 50f)
-    }
-
-    private fun drawDataLine(
-        canvas: Canvas,
-        values: List<Float>,
-        x: Float,
-        y: Float,
-        graphWidth: Float,
-        graphHeight: Float,
-        maxScale: Float,
-    ) {
-        if (values.size < 2) return
-        val visibleValues = values.takeLast(max((graphWidth / 2.dp).toInt(), 2))
-        val step = (graphWidth - 4.dp) / (visibleValues.size - 1).coerceAtLeast(1)
-        var previousX = x + 2.dp
-        var previousY = y + graphHeight * (1f - visibleValues.first().coerceIn(0f, maxScale) / maxScale)
-
-        visibleValues.drop(1).forEachIndexed { index, value ->
-            val pointX = x + 2.dp + (index + 1) * step
-            val pointY = y + graphHeight * (1f - min(max(value / maxScale, 0f), 1f))
-            canvas.drawLine(previousX, previousY, pointX, pointY, linePaint)
-            previousX = pointX
-            previousY = pointY
-        }
-    }
-
-    private fun append(values: MutableList<Float>, value: Float) {
-        if (values.size >= maxPoints) values.removeAt(0)
-        values.add(value)
-    }
-
-    private fun minMax(values: List<Float>, fallback: Float): Pair<Float, Float> {
-        return Pair(values.minOrNull() ?: fallback, values.maxOrNull() ?: fallback)
-    }
-
-    private val Int.dp: Float
-        get() = toFloat().dp
-
-    private val Float.dp: Float
-        get() = this * density
-
-    private val Int.sp: Float
-        get() = toFloat().sp
-
-    private val Float.sp: Float
-        get() = this * scaledDensity
-}