react-native-libyuv-resizer 0.2.0

package/android/src/main/java/com/libyuvresizer/LibyuvResizerModule.kt

@@ -0,0 +1,179 @@
+package com.libyuvresizer
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.net.Uri
+import android.os.Build
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.util.UUID
+import androidx.core.graphics.createBitmap
+
+@ReactModule(name = LibyuvResizerModule.NAME)
+class LibyuvResizerModule(reactContext: ReactApplicationContext) :
+  NativeLibyuvResizerSpec(reactContext) {
+
+  companion object {
+    const val NAME = NativeLibyuvResizerSpec.NAME
+
+    private val FILTER_MODE_MAP = mapOf("none" to 0, "linear" to 1, "bilinear" to 2, "box" to 3)
+
+    @Suppress("DEPRECATION")
+    fun formatToExtAndCompressFormat(format: String): Pair<String, Bitmap.CompressFormat> =
+      when (format) {
+        "png" -> "png" to Bitmap.CompressFormat.PNG
+        "webp" -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+          "webp" to Bitmap.CompressFormat.WEBP_LOSSY
+        } else {
+          "webp" to Bitmap.CompressFormat.WEBP
+        }
+
+        else -> "jpg" to Bitmap.CompressFormat.JPEG
+      }
+
+    init {
+      System.loadLibrary("libyuvresizer")
+    }
+  }
+
+  private external fun nativeResize(srcBitmap: Bitmap, dstBitmap: Bitmap, filterMode: Int)
+  private external fun nativeResizeAndRotate(
+    srcBitmap: Bitmap,
+    dstBitmap: Bitmap,
+    rotation: Int,
+    filterMode: Int
+  )
+
+  override fun resize(
+    filePath: String,
+    targetWidth: Double,
+    targetHeight: Double,
+    quality: Double,
+    rotation: Double,
+    mode: String,
+    outputPath: String,
+    filterMode: String,
+    keepMeta: Boolean,
+    format: String,
+    promise: Promise
+  ) {
+    try {
+      val targetW = targetWidth.toInt()
+      val targetH = targetHeight.toInt()
+      val q = quality.toInt()
+      val rot = rotation.toInt()
+
+      val params = ResizeParams(
+        filePath,
+        targetW,
+        targetH,
+        q,
+        rot,
+        mode,
+        outputPath,
+        filterMode,
+        keepMeta,
+        format
+      )
+      when (val result = ResizeValidator.validate(params)) {
+        is ValidationResult.Invalid -> {
+          promise.reject(result.code, result.message)
+          return
+        }
+
+        is ValidationResult.Valid -> Unit
+      }
+
+      val bitmapConfig = Bitmap.Config.ARGB_8888
+
+      val boundsOpts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+      BitmapFactory.decodeFile(filePath, boundsOpts)
+
+      val decodeOpts = BitmapFactory.Options().apply {
+        inSampleSize =
+          DimensionCalculator.calculateInSampleSize(
+            boundsOpts.outWidth,
+            boundsOpts.outHeight,
+            targetW,
+            targetH
+          )
+        inPreferredConfig = bitmapConfig
+      }
+      val srcBitmap = BitmapFactory.decodeFile(filePath, decodeOpts)
+        ?: run {
+          promise.reject("E_DECODE_FAILED", "Failed to decode image")
+          return
+        }
+
+      // srcBitmap must be recycled even if dstBitmap allocation throws OOM
+      try {
+        val srcW = srcBitmap.width.toDouble()
+        val srcH = srcBitmap.height.toDouble()
+
+        // cover scales to fill target on both axes — no cropping applied by design
+        val (dstW, dstH) = DimensionCalculator.computeDstDims(
+          srcW,
+          srcH,
+          targetW,
+          targetH,
+          rot,
+          mode
+        )
+
+        val dstBitmap = createBitmap(dstW, dstH, bitmapConfig)
+        try {
+          val filterModeInt = FILTER_MODE_MAP.getValue(filterMode)
+          if (rot == 0) {
+            nativeResize(srcBitmap, dstBitmap, filterModeInt)
+          } else {
+            nativeResizeAndRotate(srcBitmap, dstBitmap, rot, filterModeInt)
+          }
+
+          val (ext, compressFmt) = formatToExtAndCompressFormat(params.format)
+          val outFile = resolveOutputFile(filePath, outputPath, ext)
+          FileOutputStream(outFile).use { fos ->
+            dstBitmap.compress(compressFmt, q, fos)
+          }
+
+          if (params.keepMeta && params.format == "jpeg") {
+            try {
+              ExifCopier.copy(filePath, outFile.absolutePath)
+            } catch (e: IOException) {
+              promise.reject("E_EXIF_WRITE_FAILED", e.message ?: "Failed to write EXIF metadata")
+              return
+            }
+          }
+
+          val result = Arguments.createMap().apply {
+            putString("path", outFile.absolutePath)
+            putString("uri", Uri.fromFile(outFile).toString())
+            putDouble("size", outFile.length().toDouble())
+            putString("name", outFile.name)
+            putInt("width", dstBitmap.width)
+            putInt("height", dstBitmap.height)
+          }
+          promise.resolve(result)
+        } finally {
+          dstBitmap.recycle()
+        }
+      } finally {
+        srcBitmap.recycle()
+      }
+    } catch (e: Exception) {
+      promise.reject("E_UNKNOWN", e.message ?: "Unknown error")
+    }
+  }
+
+  private fun resolveOutputFile(inputFilePath: String, outputPath: String, ext: String): File {
+    if (outputPath.isEmpty()) {
+      return File(reactApplicationContext.cacheDir, "${UUID.randomUUID()}.$ext")
+    }
+    return File(outputPath, File(inputFilePath).name)
+  }
+
+}

package/android/src/main/java/com/libyuvresizer/LibyuvResizerPackage.kt

@@ -0,0 +1,30 @@
+package com.libyuvresizer
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class LibyuvResizerPackage : TurboReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == LibyuvResizerModule.NAME) {
+      LibyuvResizerModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      LibyuvResizerModule.NAME to ReactModuleInfo(
+        name = LibyuvResizerModule.NAME,
+        className = LibyuvResizerModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+      )
+    )
+  }
+}

package/android/src/main/java/com/libyuvresizer/ResizeValidator.kt

@@ -0,0 +1,71 @@
+package com.libyuvresizer
+
+import java.io.File
+
+data class ResizeParams(
+  val filePath: String,
+  val targetWidth: Int,
+  val targetHeight: Int,
+  val quality: Int,
+  val rotation: Int,
+  val mode: String,
+  val outputPath: String,
+  val filterMode: String,
+  val keepMeta: Boolean = false,
+  val format: String = "jpeg"
+)
+
+sealed class ValidationResult {
+  object Valid : ValidationResult()
+  data class Invalid(val code: String, val message: String) : ValidationResult()
+}
+
+object ResizeValidator {
+  private val VALID_MODES = setOf("contain", "cover", "stretch")
+  private val VALID_FILTER_MODES = setOf("none", "linear", "bilinear", "box")
+  private val VALID_ROTATIONS = setOf(0, 90, 180, 270)
+  private val VALID_FORMATS = setOf("jpeg", "png", "webp")
+
+  fun validate(params: ResizeParams): ValidationResult {
+    if (!File(params.filePath).exists())
+      return ValidationResult.Invalid("E_FILE_NOT_FOUND", "File not found: ${params.filePath}")
+    if (params.targetWidth <= 0 || params.targetHeight <= 0)
+      return ValidationResult.Invalid("E_INVALID_DIMS", "Invalid dimensions")
+    if (params.quality !in 1..100)
+      return ValidationResult.Invalid("E_INVALID_QUALITY", "Quality must be between 1 and 100")
+    if (params.rotation !in VALID_ROTATIONS)
+      return ValidationResult.Invalid(
+        "E_INVALID_ROTATION",
+        "rotation must be 0, 90, 180 or 270, got: ${params.rotation}"
+      )
+    if (params.mode !in VALID_MODES)
+      return ValidationResult.Invalid(
+        "E_INVALID_MODE",
+        "mode must be contain, cover, or stretch, got: ${params.mode}"
+      )
+    if (params.filterMode !in VALID_FILTER_MODES)
+      return ValidationResult.Invalid(
+        "E_INVALID_FILTER_MODE",
+        "filterMode must be none, linear, bilinear, or box, got: ${params.filterMode}"
+      )
+    if (params.format !in VALID_FORMATS)
+      return ValidationResult.Invalid(
+        "E_INVALID_FORMAT",
+        "format must be jpeg, png, or webp, got: ${params.format}"
+      )
+    if (params.outputPath.isNotEmpty()) {
+      val dir = File(params.outputPath)
+      if (!dir.exists())
+        return ValidationResult.Invalid(
+          "E_INVALID_OUTPUT_PATH",
+          "Output directory does not exist: ${params.outputPath}"
+        )
+      if (!dir.isDirectory)
+        return ValidationResult.Invalid(
+          "E_INVALID_OUTPUT_PATH",
+          "outputPath must be a directory, not a file: ${params.outputPath}"
+        )
+    }
+    return ValidationResult.Valid
+  }
+}

package/android/src/test/java/com/libyuvresizer/DimensionCalculatorTest.kt

@@ -0,0 +1,181 @@
+package com.libyuvresizer
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class DimensionCalculatorTest {
+
+  // --- calculateInSampleSize ---
+
+  @Test
+  fun `returns 1 when src smaller than dst`() {
+    assertEquals(1, DimensionCalculator.calculateInSampleSize(100, 100, 200, 200))
+  }
+
+  @Test
+  fun `returns 1 for equal dimensions`() {
+    assertEquals(1, DimensionCalculator.calculateInSampleSize(200, 200, 200, 200))
+  }
+
+  @Test
+  fun `returns 2 when src is double dst`() {
+    assertEquals(2, DimensionCalculator.calculateInSampleSize(400, 400, 200, 200))
+  }
+
+  @Test
+  fun `returns 4 when src is 4x dst`() {
+    assertEquals(4, DimensionCalculator.calculateInSampleSize(800, 800, 200, 200))
+  }
+
+  @Test
+  fun `returns 1 when only one axis exceeds but loop condition requires both`() {
+    // srcW=400 > dstW=200, but srcH=100 < dstH=200 — loop exits at sampleSize=1
+    assertEquals(1, DimensionCalculator.calculateInSampleSize(400, 100, 200, 200))
+  }
+
+  @Test
+  fun `returns correct sampleSize for odd source dimensions`() {
+    // srcW=401 srcH=401: halfW=halfH=200 — same as 400x400 case
+    assertEquals(2, DimensionCalculator.calculateInSampleSize(401, 401, 200, 200))
+  }
+
+  // --- scaleBy ---
+
+  @Test
+  fun `scaleBy 2x doubles dimensions`() {
+    assertEquals(Pair(200, 100), DimensionCalculator.scaleBy(2.0, 100.0, 50.0))
+  }
+
+  @Test
+  fun `scaleBy 0_5 halves dimensions`() {
+    assertEquals(Pair(50, 25), DimensionCalculator.scaleBy(0.5, 100.0, 50.0))
+  }
+
+  @Test
+  fun `scaleBy minimum output is 1`() {
+    assertEquals(Pair(1, 1), DimensionCalculator.scaleBy(0.0001, 1.0, 1.0))
+  }
+
+  @Test
+  fun `scaleBy rounds correctly`() {
+    // 100 * 0.056 = 5.6 -> 6
+    assertEquals(Pair(6, 6), DimensionCalculator.scaleBy(0.056, 100.0, 100.0))
+  }
+
+  // --- computeDstDims: stretch ---
+
+  @Test
+  fun `stretch returns exact target dims`() {
+    assertEquals(Pair(100, 50), DimensionCalculator.computeDstDims(1920.0, 1080.0, 100, 50, 0, "stretch"))
+  }
+
+  @Test
+  fun `stretch ignores src dimensions`() {
+    assertEquals(Pair(300, 200), DimensionCalculator.computeDstDims(10.0, 10.0, 300, 200, 0, "stretch"))
+  }
+
+  // --- computeDstDims: contain ---
+
+  @Test
+  fun `contain 16x9 src in square box constrains width`() {
+    // 1920x1080 contain in 100x100: scale = min(100/1920, 100/1080) = 0.052... (width-limited)
+    val (w, h) = DimensionCalculator.computeDstDims(1920.0, 1080.0, 100, 100, 0, "contain")
+    assertEquals(100, w)
+    assertEquals(56, h) // 1080 * (100/1920) ≈ 56.25 -> 56
+  }
+
+  @Test
+  fun `contain portrait src in landscape box constrains height`() {
+    // 100x200 contain in 200x100: scale = min(200/100, 100/200) = 0.5 (height-limited)
+    val (w, h) = DimensionCalculator.computeDstDims(100.0, 200.0, 200, 100, 0, "contain")
+    assertEquals(50, w) // 100 * 0.5
+    assertEquals(100, h) // 200 * 0.5
+  }
+
+  @Test
+  fun `contain output never exceeds target on either axis`() {
+    val (w, h) = DimensionCalculator.computeDstDims(1920.0, 1080.0, 100, 100, 0, "contain")
+    assertTrue("w=$w exceeds target", w <= 100)
+    assertTrue("h=$h exceeds target", h <= 100)
+  }
+
+  @Test
+  fun `contain never exceeds target for small integer dimensions`() {
+    // exhaustive check over small src and target combos — previously broken with roundToInt
+    for (sw in 1..20) for (sh in 1..20) for (tw in 1..20) for (th in 1..20) {
+      val (w, h) = DimensionCalculator.computeDstDims(sw.toDouble(), sh.toDouble(), tw, th, 0, "contain")
+      assertTrue("src=${sw}x${sh} target=${tw}x${th} → w=$w > tw=$tw", w <= tw)
+      assertTrue("src=${sw}x${sh} target=${tw}x${th} → h=$h > th=$th", h <= th)
+    }
+  }
+
+  // --- computeDstDims: cover ---
+
+  @Test
+  fun `cover 16x9 src in square box fills on both axes`() {
+    // 1920x1080 cover 100x100: scale = max(100/1920, 100/1080) = 0.0926... (height-driven)
+    val (w, h) = DimensionCalculator.computeDstDims(1920.0, 1080.0, 100, 100, 0, "cover")
+    assertEquals(100, h)
+    assertTrue("w=$w should exceed or equal target", w >= 100)
+  }
+
+  @Test
+  fun `cover output meets target on at least one axis`() {
+    val (w, h) = DimensionCalculator.computeDstDims(1920.0, 1080.0, 100, 100, 0, "cover")
+    assertTrue("neither axis meets target: w=$w h=$h", w >= 100 || h >= 100)
+  }
+
+  @Test
+  fun `cover 16x9 src in square box exact output width`() {
+    // scale = max(100/1920, 100/1080) = 100/1080 = 0.09259...
+    // w = round(1920 * 0.09259...) = round(177.77...) = 178
+    // h = round(1080 * 0.09259...) = round(100.0) = 100
+    val (w, h) = DimensionCalculator.computeDstDims(1920.0, 1080.0, 100, 100, 0, "cover")
+    assertEquals(178, w)
+    assertEquals(100, h)
+  }
+
+  // --- computeDstDims: rotation ---
+
+  @Test
+  fun `rotation 90 swaps effective dims for contain`() {
+    // src 100x200, rotation=90 → effectiveW=200, effectiveH=100
+    // contain in 100x100: scale = min(100/200, 100/100) = 0.5
+    // result: scaleBy(0.5, 200, 100) = (100, 50)
+    val (w, h) = DimensionCalculator.computeDstDims(100.0, 200.0, 100, 100, 90, "contain")
+    assertEquals(100, w)
+    assertEquals(50, h)
+  }
+
+  @Test
+  fun `rotation 270 swaps effective dims same as 90`() {
+    val result90 = DimensionCalculator.computeDstDims(100.0, 200.0, 100, 100, 90, "contain")
+    val result270 = DimensionCalculator.computeDstDims(100.0, 200.0, 100, 100, 270, "contain")
+    assertEquals(result90, result270)
+  }
+
+  @Test
+  fun `rotation 0 does not swap dims for contain`() {
+    // src 100x200, rotation=0 → effectiveW=100, effectiveH=200
+    // contain in 100x100: scale = min(100/100, 100/200) = 0.5
+    // result: scaleBy(0.5, 100, 200) = (50, 100)
+    val (w, h) = DimensionCalculator.computeDstDims(100.0, 200.0, 100, 100, 0, "contain")
+    assertEquals(50, w)
+    assertEquals(100, h)
+  }
+
+  @Test
+  fun `rotation 180 does not swap dims`() {
+    val result0 = DimensionCalculator.computeDstDims(100.0, 200.0, 100, 100, 0, "contain")
+    val result180 = DimensionCalculator.computeDstDims(100.0, 200.0, 100, 100, 180, "contain")
+    assertEquals(result0, result180)
+  }
+
+  @Test
+  fun `stretch ignores rotation`() {
+    val result0 = DimensionCalculator.computeDstDims(1920.0, 1080.0, 100, 50, 0, "stretch")
+    val result90 = DimensionCalculator.computeDstDims(1920.0, 1080.0, 100, 50, 90, "stretch")
+    assertEquals(result0, result90)
+  }
+}

package/android/src/test/java/com/libyuvresizer/ResizeValidatorTest.kt

@@ -0,0 +1,203 @@
+package com.libyuvresizer
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+class ResizeValidatorTest {
+
+  @get:Rule
+  val tmp = TemporaryFolder()
+
+  private fun validParams(filePath: String, outputPath: String = "") = ResizeParams(
+    filePath = filePath,
+    targetWidth = 100,
+    targetHeight = 100,
+    quality = 80,
+    rotation = 0,
+    mode = "contain",
+    outputPath = outputPath,
+    filterMode = "bilinear"
+  )
+
+  // --- happy path ---
+
+  @Test
+  fun `valid params with empty outputPath returns Valid`() {
+    val file = tmp.newFile("image.jpg")
+    assertEquals(ValidationResult.Valid, ResizeValidator.validate(validParams(file.absolutePath)))
+  }
+
+  @Test
+  fun `valid params with directory outputPath returns Valid`() {
+    val file = tmp.newFile("image.jpg")
+    val dir = tmp.newFolder("out")
+    assertEquals(ValidationResult.Valid, ResizeValidator.validate(validParams(file.absolutePath, dir.absolutePath)))
+  }
+
+  @Test
+  fun `all valid rotations accepted`() {
+    val file = tmp.newFile("image.jpg")
+    for (rot in listOf(0, 90, 180, 270)) {
+      val result = ResizeValidator.validate(validParams(file.absolutePath).copy(rotation = rot))
+      assertEquals("rotation $rot should be Valid", ValidationResult.Valid, result)
+    }
+  }
+
+  @Test
+  fun `all valid modes accepted`() {
+    val file = tmp.newFile("image.jpg")
+    for (mode in listOf("contain", "cover", "stretch")) {
+      val result = ResizeValidator.validate(validParams(file.absolutePath).copy(mode = mode))
+      assertEquals("mode $mode should be Valid", ValidationResult.Valid, result)
+    }
+  }
+
+  @Test
+  fun `all valid filterModes accepted`() {
+    val file = tmp.newFile("image.jpg")
+    for (fm in listOf("none", "linear", "bilinear", "box")) {
+      val result = ResizeValidator.validate(validParams(file.absolutePath).copy(filterMode = fm))
+      assertEquals("filterMode $fm should be Valid", ValidationResult.Valid, result)
+    }
+  }
+
+  @Test
+  fun `all valid formats accepted`() {
+    val file = tmp.newFile("image.jpg")
+    for (fmt in listOf("jpeg", "png", "webp")) {
+      val result = ResizeValidator.validate(validParams(file.absolutePath).copy(format = fmt))
+      assertEquals("format $fmt should be Valid", ValidationResult.Valid, result)
+    }
+  }
+
+  @Test
+  fun `quality boundary 1 accepted`() {
+    val file = tmp.newFile("image.jpg")
+    assertEquals(ValidationResult.Valid, ResizeValidator.validate(validParams(file.absolutePath).copy(quality = 1)))
+  }
+
+  @Test
+  fun `quality boundary 100 accepted`() {
+    val file = tmp.newFile("image.jpg")
+    assertEquals(ValidationResult.Valid, ResizeValidator.validate(validParams(file.absolutePath).copy(quality = 100)))
+  }
+
+  // --- error codes ---
+
+  private fun assertCode(expected: String, params: ResizeParams) {
+    val result = ResizeValidator.validate(params)
+    assertTrue("expected Invalid, got $result", result is ValidationResult.Invalid)
+    assertEquals(expected, (result as ValidationResult.Invalid).code)
+  }
+
+  @Test
+  fun `missing file returns E_FILE_NOT_FOUND`() {
+    assertCode("E_FILE_NOT_FOUND", validParams("/no/such/file.jpg"))
+  }
+
+  @Test
+  fun `zero width returns E_INVALID_DIMS`() {
+    val file = tmp.newFile("image.jpg")
+    assertCode("E_INVALID_DIMS", validParams(file.absolutePath).copy(targetWidth = 0))
+  }
+
+  @Test
+  fun `negative height returns E_INVALID_DIMS`() {
+    val file = tmp.newFile("image.jpg")
+    assertCode("E_INVALID_DIMS", validParams(file.absolutePath).copy(targetHeight = -1))
+  }
+
+  @Test
+  fun `quality 0 returns E_INVALID_QUALITY`() {
+    val file = tmp.newFile("image.jpg")
+    assertCode("E_INVALID_QUALITY", validParams(file.absolutePath).copy(quality = 0))
+  }
+
+  @Test
+  fun `quality 101 returns E_INVALID_QUALITY`() {
+    val file = tmp.newFile("image.jpg")
+    assertCode("E_INVALID_QUALITY", validParams(file.absolutePath).copy(quality = 101))
+  }
+
+  @Test
+  fun `rotation 45 returns E_INVALID_ROTATION`() {
+    val file = tmp.newFile("image.jpg")
+    assertCode("E_INVALID_ROTATION", validParams(file.absolutePath).copy(rotation = 45))
+  }
+
+  @Test
+  fun `invalid mode returns E_INVALID_MODE`() {
+    val file = tmp.newFile("image.jpg")
+    assertCode("E_INVALID_MODE", validParams(file.absolutePath).copy(mode = "fill"))
+  }
+
+  @Test
+  fun `invalid filterMode returns E_INVALID_FILTER_MODE`() {
+    val file = tmp.newFile("image.jpg")
+    assertCode("E_INVALID_FILTER_MODE", validParams(file.absolutePath).copy(filterMode = "cubic"))
+  }
+
+  @Test
+  fun `invalid format returns E_INVALID_FORMAT`() {
+    val file = tmp.newFile("image.jpg")
+    assertCode("E_INVALID_FORMAT", validParams(file.absolutePath).copy(format = "gif"))
+  }
+
+  @Test
+  fun `empty format returns E_INVALID_FORMAT`() {
+    val file = tmp.newFile("image.jpg")
+    assertCode("E_INVALID_FORMAT", validParams(file.absolutePath).copy(format = ""))
+  }
+
+  @Test
+  fun `nonexistent outputPath returns E_INVALID_OUTPUT_PATH`() {
+    val file = tmp.newFile("image.jpg")
+    assertCode("E_INVALID_OUTPUT_PATH", validParams(file.absolutePath, "/nonexistent/dir"))
+  }
+
+  @Test
+  fun `outputPath pointing to file returns E_INVALID_OUTPUT_PATH`() {
+    val file = tmp.newFile("image.jpg")
+    val notDir = tmp.newFile("output.jpg")
+    assertCode("E_INVALID_OUTPUT_PATH", validParams(file.absolutePath, notDir.absolutePath))
+  }
+
+  // --- error message content ---
+
+  @Test
+  fun `E_FILE_NOT_FOUND message includes path`() {
+    val result = ResizeValidator.validate(validParams("/bad/path.jpg")) as ValidationResult.Invalid
+    assertTrue(result.message.contains("/bad/path.jpg"))
+  }
+
+  @Test
+  fun `E_INVALID_ROTATION message includes got value`() {
+    val file = tmp.newFile("image.jpg")
+    val result = ResizeValidator.validate(validParams(file.absolutePath).copy(rotation = 45)) as ValidationResult.Invalid
+    assertTrue(result.message.contains("45"))
+  }
+
+  @Test
+  fun `E_INVALID_MODE message includes got value`() {
+    val file = tmp.newFile("image.jpg")
+    val result = ResizeValidator.validate(validParams(file.absolutePath).copy(mode = "fill")) as ValidationResult.Invalid
+    assertTrue(result.message.contains("fill"))
+  }
+
+  @Test
+  fun `E_INVALID_FILTER_MODE message includes got value`() {
+    val file = tmp.newFile("image.jpg")
+    val result = ResizeValidator.validate(validParams(file.absolutePath).copy(filterMode = "cubic")) as ValidationResult.Invalid
+    assertTrue(result.message.contains("cubic"))
+  }
+
+  @Test
+  fun `E_INVALID_FORMAT message includes got value`() {
+    val file = tmp.newFile("image.jpg")
+    val result = ResizeValidator.validate(validParams(file.absolutePath).copy(format = "gif")) as ValidationResult.Invalid
+    assertTrue(result.message.contains("gif"))
+  }
+}

package/ios/LibyuvResizer.h

@@ -0,0 +1,6 @@
+#import <React/RCTBridgeModule.h>
+#import <LibyuvResizerSpec/LibyuvResizerSpec.h>
+
+@interface LibyuvResizer : NSObject <NativeLibyuvResizerSpec, RCTBridgeModule>
+
+@end