squircle-view 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 rit3zh
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,83 @@
-# Temporary Holding Version
+# SquircleView
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+![squircle-view](.github/banner.png)
+
+A drop-in React Native `View` with smooth, continuous corners.
+
+```tsx
+<SquircleView style={{ borderRadius: 24, borderSmoothing: 1 }}>…</SquircleView>
+```
+
+## Installation
+
+```sh
+npm install squircle-view
+cd ios && pod install
+```
+
+Requires the New Architecture. On Expo, use a development build.
+
+## Usage
+
+```tsx
+import { SquircleView } from 'squircle-view';
+
+export function Card({ children }) {
+  return (
+    <SquircleView
+      style={{
+        padding: 20,
+        borderRadius: 24,
+        borderSmoothing: 1,
+        backgroundColor: '#fff',
+      }}
+    >
+      {children}
+    </SquircleView>
+  );
+}
+```
+
+It's a real `View`, so you can swap the import and keep your JSX:
+
+```tsx
+import { SquircleView as View } from 'squircle-view';
+```
+
+### Typed styles
+
+`StyleSheet.create` rejects unknown keys. Use the prop, or type the style as `SquircleViewStyle`:
+
+```tsx
+import type { SquircleViewStyle } from 'squircle-view';
+
+const smooth: SquircleViewStyle = { borderSmoothing: 1 };
+
+<SquircleView borderSmoothing={0.6} style={styles.card} />
+<SquircleView style={[styles.card, smooth]} />
+```
+
+## API
+
+| `borderSmoothing` | Result                              |
+| ----------------- | ----------------------------------- |
+| `0` (default)     | Standard React Native corners       |
+| `0.6`             | Close to Apple's continuous corners |
+| `1`               | Fully smoothed                      |
+
+Set it in `style` or as a prop (`style` wins). Values are clamped to `0…1`.
+
+Everything else a `View` supports works as usual: per-corner radii, per-edge borders, `borderStyle`, `overflow: 'hidden'` clipping, shadows, `elevation`, accessibility, and `Animated` (including animated `borderSmoothing`).
+
+**Platforms:** iOS (Fabric) · Android · Web falls back to a plain `View`.
+
+## Example
+
+```sh
+bun install
+bun run example ios   # or android
+```
+
+## License
+
+MIT

package/SquircleView.podspec

@@ -0,0 +1,22 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "SquircleView"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/rit3zh/squircle-view.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}", "common/cpp/**/*.{h,cpp}"
+  s.exclude_files = "common/cpp/__tests__/**/*"
+  s.private_header_files = "ios/**/*.h", "common/cpp/**/*.h"
+  s.pod_target_xcconfig = { "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/common/cpp\"" }
+
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.13)
+project(squircleview LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(COMMON_CPP_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../common/cpp)
+
+add_library(
+  squircleview
+  SHARED
+  ${COMMON_CPP_DIR}/SquircleGeometry.cpp
+  src/main/cpp/SquircleGeometryJni.cpp
+)
+
+target_include_directories(squircleview PRIVATE ${COMMON_CPP_DIR})
+target_compile_options(squircleview PRIVATE -O2 -Wall -Wextra -Werror)

package/android/build.gradle

@@ -0,0 +1,78 @@
+buildscript {
+  ext.SquircleView = [
+    kotlinVersion: "2.1.20",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36,
+    ndkVersion: "27.1.12297006"
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return SquircleView[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.findProperty("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+
+if (project.extensions.findByName("kotlin") == null) {
+  apply plugin: "kotlin-android"
+}
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.squircleview"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+  ndkVersion getExtOrDefault("ndkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        arguments "-DANDROID_STL=c++_static"
+        abiFilters(*reactNativeArchitectures())
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  buildFeatures {
+    buildConfig false
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/SquircleGeometryJni.cpp

@@ -0,0 +1,52 @@
+#include <jni.h>
+
+#include <vector>
+
+#include "SquircleGeometry.h"
+
+namespace {
+
+squircle::CornerRadii cornerRadiiFromArray(const jfloat *values) {
+  return {
+      {values[0], values[1]},
+      {values[2], values[3]},
+      {values[4], values[5]},
+      {values[6], values[7]}};
+}
+
+}
+
+extern "C" JNIEXPORT jfloatArray JNICALL Java_com_squircleview_geometry_SquircleGeometry_nativeBuildPath(
+    JNIEnv *env,
+    jclass,
+    jfloat width,
+    jfloat height,
+    jfloatArray radii,
+    jfloatArray insets,
+    jfloat smoothing) {
+  jfloat radiiValues[8];
+  jfloat insetValues[4];
+  env->GetFloatArrayRegion(radii, 0, 8, radiiValues);
+  env->GetFloatArrayRegion(insets, 0, 4, insetValues);
+
+  const squircle::Insets inset{insetValues[0], insetValues[1], insetValues[2], insetValues[3]};
+  const auto path = squircle::buildPath(
+      squircle::insetRect({0, 0, width, height}, inset),
+      squircle::insetRadii(cornerRadiiFromArray(radiiValues), inset),
+      smoothing);
+
+  std::vector<jfloat> data;
+  data.reserve(path.size() * 7);
+  for (const auto &element : path) {
+    data.push_back(static_cast<jfloat>(element.verb));
+    const int count = element.verb == squircle::Verb::Cubic ? 3 : element.verb == squircle::Verb::Close ? 0 : 1;
+    for (int index = 0; index < count; ++index) {
+      data.push_back(static_cast<jfloat>(element.points[index].x));
+      data.push_back(static_cast<jfloat>(element.points[index].y));
+    }
+  }
+
+  jfloatArray result = env->NewFloatArray(static_cast<jsize>(data.size()));
+  env->SetFloatArrayRegion(result, 0, static_cast<jsize>(data.size()), data.data());
+  return result;
+}

package/android/src/main/java/com/squircleview/SquircleViewManager.kt

@@ -0,0 +1,72 @@
+package com.squircleview
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.LengthPercentage
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.style.BorderRadiusProp
+import com.facebook.react.uimanager.style.BorderStyle
+import com.facebook.react.uimanager.style.LogicalEdge
+import com.facebook.react.views.view.ReactViewGroup
+import com.facebook.react.views.view.ReactViewManager
+import com.squircleview.views.SquircleView
+
+@ReactModule(name = SquircleViewManager.NAME)
+public class SquircleViewManager : ReactViewManager() {
+  override fun getName(): String = NAME
+
+  override fun createViewInstance(context: ThemedReactContext): ReactViewGroup = SquircleView(context)
+
+  override fun prepareToRecycleView(reactContext: ThemedReactContext, view: ReactViewGroup): ReactViewGroup? {
+    val prepared = super.prepareToRecycleView(reactContext, view)
+    (prepared as? SquircleView)?.resetSquircle()
+    return prepared
+  }
+
+  @ReactProp(name = "borderSmoothing", defaultFloat = 0f)
+  public fun setBorderSmoothing(view: ReactViewGroup, borderSmoothing: Float) {
+    (view as SquircleView).setBorderSmoothing(borderSmoothing)
+  }
+
+  override fun setBorderRadius(view: ReactViewGroup, index: Int, rawBorderRadius: Dynamic) {
+    (view as SquircleView).setSquircleBorderRadius(
+        BorderRadiusProp.entries[index],
+        LengthPercentage.setFromDynamic(rawBorderRadius),
+    )
+  }
+
+  override fun setBorderWidth(view: ReactViewGroup, index: Int, width: Float) {
+    (view as SquircleView).setSquircleBorderWidth(LogicalEdge.entries[index], width.takeUnless { it.isNaN() })
+  }
+
+  override fun setBorderColor(view: ReactViewGroup, index: Int, color: Int?) {
+    (view as SquircleView).setSquircleBorderColor(BORDER_COLOR_EDGES[index], color)
+  }
+
+  override fun setBorderStyle(view: ReactViewGroup, borderStyle: String?) {
+    (view as SquircleView).setSquircleBorderStyle(borderStyle?.let(BorderStyle::fromString))
+  }
+
+  override fun setBackgroundColor(view: ReactViewGroup, backgroundColor: Int) {
+    (view as SquircleView).setSquircleBackgroundColor(backgroundColor)
+  }
+
+  public companion object {
+    public const val NAME: String = "SquircleView"
+
+    private val BORDER_COLOR_EDGES =
+        arrayOf(
+            LogicalEdge.ALL,
+            LogicalEdge.LEFT,
+            LogicalEdge.RIGHT,
+            LogicalEdge.TOP,
+            LogicalEdge.BOTTOM,
+            LogicalEdge.START,
+            LogicalEdge.END,
+            LogicalEdge.BLOCK,
+            LogicalEdge.BLOCK_END,
+            LogicalEdge.BLOCK_START,
+        )
+  }
+}

package/android/src/main/java/com/squircleview/SquircleViewPackage.kt

@@ -0,0 +1,16 @@
+package com.squircleview
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+public class SquircleViewPackage : BaseReactPackage() {
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+      listOf(SquircleViewManager())
+
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { emptyMap() }
+}

package/android/src/main/java/com/squircleview/geometry/SquircleGeometry.kt

@@ -0,0 +1,58 @@
+package com.squircleview.geometry
+
+import android.graphics.Path
+import com.facebook.soloader.SoLoader
+
+internal object SquircleGeometry {
+  private const val VERB_MOVE = 0
+  private const val VERB_LINE = 1
+  private const val VERB_CUBIC = 2
+  private const val VERB_CLOSE = 3
+
+  init {
+    SoLoader.loadLibrary("squircleview")
+  }
+
+  fun clampSmoothing(smoothing: Float): Float =
+      if (smoothing > 0f) smoothing.coerceAtMost(1f) else 0f
+
+  fun appendPath(
+      path: Path,
+      width: Float,
+      height: Float,
+      radii: FloatArray,
+      insets: FloatArray,
+      smoothing: Float,
+  ) {
+    val data = nativeBuildPath(width, height, radii, insets, smoothing)
+    var index = 0
+    while (index < data.size) {
+      when (data[index].toInt()) {
+        VERB_MOVE -> path.moveTo(data[index + 1], data[index + 2]).also { index += 3 }
+        VERB_LINE -> path.lineTo(data[index + 1], data[index + 2]).also { index += 3 }
+        VERB_CUBIC -> {
+          path.cubicTo(
+              data[index + 1],
+              data[index + 2],
+              data[index + 3],
+              data[index + 4],
+              data[index + 5],
+              data[index + 6],
+          )
+          index += 7
+        }
+        VERB_CLOSE -> path.close().also { index += 1 }
+        else -> return
+      }
+    }
+  }
+
+  @JvmStatic
+  private external fun nativeBuildPath(
+      width: Float,
+      height: Float,
+      radii: FloatArray,
+      insets: FloatArray,
+      smoothing: Float,
+  ): FloatArray
+}

package/android/src/main/java/com/squircleview/style/SquircleStyle.kt

@@ -0,0 +1,142 @@
+package com.squircleview.style
+
+import android.graphics.Color
+import androidx.annotation.ColorInt
+import com.facebook.react.uimanager.LengthPercentage
+import com.facebook.react.uimanager.LengthPercentageType
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.uimanager.style.BorderRadiusProp
+import com.facebook.react.uimanager.style.BorderStyle
+import com.facebook.react.uimanager.style.LogicalEdge
+
+internal class SquircleStyle {
+  val radii: Array<LengthPercentage?> = arrayOfNulls(BorderRadiusProp.entries.size)
+  val borderWidths: Array<Float?> = arrayOfNulls(LogicalEdge.entries.size)
+  val borderColors: Array<Int?> = arrayOfNulls(LogicalEdge.entries.size)
+  @ColorInt var backgroundColor: Int = Color.TRANSPARENT
+  var borderStyle: BorderStyle? = null
+
+  fun hasRadius(): Boolean = radii.any { it != null && it.resolve(1f) > 0f }
+
+  fun reset() {
+    radii.fill(null)
+    borderWidths.fill(null)
+    borderColors.fill(null)
+    backgroundColor = Color.TRANSPARENT
+    borderStyle = null
+  }
+
+  fun resolveRadii(isRtl: Boolean, swapLeftAndRight: Boolean, width: Float, height: Float, out: FloatArray) {
+    val topLeft: LengthPercentage?
+    val topRight: LengthPercentage?
+    val bottomLeft: LengthPercentage?
+    val bottomRight: LengthPercentage?
+    val uniform = radius(BorderRadiusProp.BORDER_RADIUS)
+
+    when {
+      !isRtl -> {
+        topLeft = radius(BorderRadiusProp.BORDER_START_START_RADIUS, BorderRadiusProp.BORDER_TOP_START_RADIUS, BorderRadiusProp.BORDER_TOP_LEFT_RADIUS)
+        topRight = radius(BorderRadiusProp.BORDER_END_START_RADIUS, BorderRadiusProp.BORDER_TOP_END_RADIUS, BorderRadiusProp.BORDER_TOP_RIGHT_RADIUS)
+        bottomLeft = radius(BorderRadiusProp.BORDER_START_END_RADIUS, BorderRadiusProp.BORDER_BOTTOM_START_RADIUS, BorderRadiusProp.BORDER_BOTTOM_LEFT_RADIUS)
+        bottomRight = radius(BorderRadiusProp.BORDER_END_END_RADIUS, BorderRadiusProp.BORDER_BOTTOM_END_RADIUS, BorderRadiusProp.BORDER_BOTTOM_RIGHT_RADIUS)
+      }
+      swapLeftAndRight -> {
+        topLeft = radius(BorderRadiusProp.BORDER_END_START_RADIUS, BorderRadiusProp.BORDER_TOP_END_RADIUS, BorderRadiusProp.BORDER_TOP_RIGHT_RADIUS)
+        topRight = radius(BorderRadiusProp.BORDER_START_START_RADIUS, BorderRadiusProp.BORDER_TOP_START_RADIUS, BorderRadiusProp.BORDER_TOP_LEFT_RADIUS)
+        bottomLeft = radius(BorderRadiusProp.BORDER_END_END_RADIUS, BorderRadiusProp.BORDER_BOTTOM_END_RADIUS, BorderRadiusProp.BORDER_BOTTOM_RIGHT_RADIUS)
+        bottomRight = radius(BorderRadiusProp.BORDER_START_END_RADIUS, BorderRadiusProp.BORDER_BOTTOM_START_RADIUS, BorderRadiusProp.BORDER_BOTTOM_LEFT_RADIUS)
+      }
+      else -> {
+        topLeft = radius(BorderRadiusProp.BORDER_END_START_RADIUS, BorderRadiusProp.BORDER_TOP_END_RADIUS, BorderRadiusProp.BORDER_TOP_LEFT_RADIUS)
+        topRight = radius(BorderRadiusProp.BORDER_START_START_RADIUS, BorderRadiusProp.BORDER_TOP_START_RADIUS, BorderRadiusProp.BORDER_TOP_RIGHT_RADIUS)
+        bottomLeft = radius(BorderRadiusProp.BORDER_END_END_RADIUS, BorderRadiusProp.BORDER_BOTTOM_START_RADIUS, BorderRadiusProp.BORDER_BOTTOM_LEFT_RADIUS)
+        bottomRight = radius(BorderRadiusProp.BORDER_START_END_RADIUS, BorderRadiusProp.BORDER_BOTTOM_END_RADIUS, BorderRadiusProp.BORDER_BOTTOM_RIGHT_RADIUS)
+      }
+    }
+
+    writeCorner(out, 0, topLeft ?: uniform, width, height)
+    writeCorner(out, 2, topRight ?: uniform, width, height)
+    writeCorner(out, 4, bottomRight ?: uniform, width, height)
+    writeCorner(out, 6, bottomLeft ?: uniform, width, height)
+    ensureNoOverlap(out, width, height)
+  }
+
+  fun resolveBorderWidths(isRtl: Boolean, swapLeftAndRight: Boolean, out: FloatArray) {
+    resolveEdges(borderWidths, isRtl, swapLeftAndRight) { top, right, bottom, left ->
+      out[0] = PixelUtil.toPixelFromDIP(top ?: 0f)
+      out[1] = PixelUtil.toPixelFromDIP(right ?: 0f)
+      out[2] = PixelUtil.toPixelFromDIP(bottom ?: 0f)
+      out[3] = PixelUtil.toPixelFromDIP(left ?: 0f)
+    }
+  }
+
+  fun resolveBorderColors(isRtl: Boolean, swapLeftAndRight: Boolean, out: IntArray) {
+    resolveEdges(borderColors, isRtl, swapLeftAndRight) { top, right, bottom, left ->
+      out[0] = top ?: Color.BLACK
+      out[1] = right ?: Color.BLACK
+      out[2] = bottom ?: Color.BLACK
+      out[3] = left ?: Color.BLACK
+    }
+  }
+
+  private fun radius(prop: BorderRadiusProp): LengthPercentage? = radii[prop.ordinal]
+
+  private fun radius(
+      logical: BorderRadiusProp,
+      side: BorderRadiusProp,
+      physical: BorderRadiusProp,
+  ): LengthPercentage? = radii[logical.ordinal] ?: radii[side.ordinal] ?: radii[physical.ordinal]
+
+  private inline fun <T> resolveEdges(
+      values: Array<T?>,
+      isRtl: Boolean,
+      swapLeftAndRight: Boolean,
+      block: (top: T?, right: T?, bottom: T?, left: T?) -> Unit,
+  ) {
+    val leftLogical = if (isRtl) LogicalEdge.END else LogicalEdge.START
+    val rightLogical = if (isRtl) LogicalEdge.START else LogicalEdge.END
+    val swap = isRtl && swapLeftAndRight
+    val leftPhysical = if (swap) LogicalEdge.RIGHT else LogicalEdge.LEFT
+    val rightPhysical = if (swap) LogicalEdge.LEFT else LogicalEdge.RIGHT
+    val all = values[LogicalEdge.ALL.ordinal]
+    val horizontal = values[LogicalEdge.HORIZONTAL.ordinal] ?: all
+    val vertical = values[LogicalEdge.BLOCK.ordinal] ?: values[LogicalEdge.VERTICAL.ordinal] ?: all
+
+    block(
+        values[LogicalEdge.BLOCK_START.ordinal] ?: values[LogicalEdge.TOP.ordinal] ?: vertical,
+        values[rightLogical.ordinal] ?: values[rightPhysical.ordinal] ?: horizontal,
+        values[LogicalEdge.BLOCK_END.ordinal] ?: values[LogicalEdge.BOTTOM.ordinal] ?: vertical,
+        values[leftLogical.ordinal] ?: values[leftPhysical.ordinal] ?: horizontal,
+    )
+  }
+
+  private fun writeCorner(out: FloatArray, offset: Int, radius: LengthPercentage?, width: Float, height: Float) {
+    out[offset] = toPixels(radius, width)
+    out[offset + 1] = toPixels(radius, height)
+  }
+
+  private fun toPixels(radius: LengthPercentage?, reference: Float): Float =
+      when (radius?.type) {
+        null -> 0f
+        LengthPercentageType.POINT -> PixelUtil.toPixelFromDIP(radius.resolve(0f))
+        LengthPercentageType.PERCENT -> radius.resolve(reference)
+      }
+
+  private fun ensureNoOverlap(radii: FloatArray, width: Float, height: Float) {
+    fun scale(sum: Float, side: Float): Float = if (sum > 0f) minOf(side / sum, 1f) else 0f
+
+    val top = scale(radii[0] + radii[2], width)
+    val right = scale(radii[3] + radii[5], height)
+    val bottom = scale(radii[6] + radii[4], width)
+    val left = scale(radii[1] + radii[7], height)
+    scaleCorner(radii, 0, minOf(top, left))
+    scaleCorner(radii, 2, minOf(right, top))
+    scaleCorner(radii, 4, minOf(bottom, right))
+    scaleCorner(radii, 6, minOf(left, bottom))
+  }
+
+  private fun scaleCorner(radii: FloatArray, offset: Int, factor: Float) {
+    radii[offset] *= factor
+    radii[offset + 1] *= factor
+  }
+}