fix(ios): correct crop rect size, orientation, and renderer scale

Four related bugs in iOS caused Image.crop() / Image.resize() (and,
by extension, Image.rotate() slow path and ImageFactory.createBlankImage)
to produce incorrect output. They surface most visibly through the
vision-camera v5 flow Photo.toImageAsync() -> crop -> resize ->
saveToTemporaryFileAsync(), but repro from any source image.

ios/Public/NativeImage.swift:

1. crop: the targetRect used CGSize(uiImage.size.width, uiImage.size.height)
   instead of the computed (targetWidth, targetHeight). CGImage.cropping
   intersects the rect with the image bounds, so callers got "image minus
   origin offset" instead of an actual crop of the requested region.

2. crop: the pre-crop UIImage could have non-.up imageOrientation and/or
   scale != 1 (both common for the Photo.toImageAsync() bridge, which
   constructs UIImage(cgImage:, scale: 1, orientation: uiOrientation)).
   uiImage.size is display-space while cgImage is sensor-space, so the
   caller's rect landed in the wrong region of cgImage. UIImage(cgImage:)
   also defaulted the output to .up orientation, dropping the source's
   orientation and producing sensor-oriented pixels.

   Fix: if orientation != .up or scale != 1, draw through a scale=1
   UIGraphicsImageRenderer to bake both into pixels before cropping,
   then wrap the cropped CGImage with explicit scale=1 and .up so
   downstream consumers see consistent state.

3. resize + rotate (slow path): UIGraphicsImageRenderer(size:) without
   a UIGraphicsImageRendererFormat defaults to UIScreen.main.scale.
   On 2x/3x devices "resize to 2000x1500" produced 4000x3000 or
   6000x4500-pixel output, while uiImage.size still reported
   (2000, 1500) in points. JS callers saw correct Image.width/height
   but the saved JPEG was 2-3x too large in each dimension.

   Fix: set UIGraphicsImageRendererFormat().scale = 1 before constructing
   the renderer.

ios/HybridImageFactory.swift:

4. createBlankImage had the same default-scale issue; applied the same
   scale = 1 fix.

Android (HybridImage.kt) is unchanged -- its Bitmap-based path has no
point/pixel distinction and was already correct.

Verified on an iPhone 15 Pro (3x screen scale) via a vision-camera v5
photo-scanning app. Before: cropped region was wrong, orientation
dropped to landscape sensor-space, saved files 3x larger than requested.
After: crop produces the requested region in portrait orientation, and
saved files match the requested pixel dimensions.

Author: rayabelcode

packages/react-native-nitro-image/ios/HybridImageFactory.swift

@@ -14,10 +14,14 @@ class HybridImageFactory: HybridImageFactorySpec {
    * Create new blank Image
    */
   func createBlankImage(width: Double, height: Double, enableAlpha: Bool, fill: Color?) throws -> any HybridImageSpec {
-    // 1. Prepare image config
+    // 1. Prepare image config. Force scale=1 so pixel dims == (width, height);
+    //    otherwise UIGraphicsImageRendererFormat() defaults to UIScreen.main.scale
+    //    and a "create blank 100x100" call produces a 300x300-pixel bitmap on 3x
+    //    devices while uiImage.size still reads (100, 100) in points.
     let size = CGSize(width: width, height: height)
     let format = UIGraphicsImageRendererFormat()
     format.opaque = !enableAlpha
+    format.scale = 1
     // 2. Create a new UIImage
     let uiImage = UIGraphicsImageRenderer(size: size, format: format).image { canvas in
       if let fill {

packages/react-native-nitro-image/ios/Public/NativeImage.swift

@@ -62,8 +62,13 @@ public extension NativeImage {
       let rotated = UIImage(cgImage: cgImage, scale: uiImage.scale, orientation: newOrientation)
       return HybridImage(uiImage: rotated)
     } else {
-      // Slow path: we actually rotate using UIGraphicsImageRenderer
-      let renderer = UIGraphicsImageRenderer(size: uiImage.size)
+      // Slow path: we actually rotate using UIGraphicsImageRenderer.
+      // Force scale=1 so output pixel dims match uiImage.size. Without a format,
+      // UIGraphicsImageRenderer defaults to UIScreen.main.scale (2x/3x on modern
+      // iPhones), producing a pixel-inflated bitmap.
+      let format = UIGraphicsImageRendererFormat()
+      format.scale = 1
+      let renderer = UIGraphicsImageRenderer(size: uiImage.size, format: format)
       let rotatedImage = renderer.image { context in
         let width = uiImage.size.width
         let height = uiImage.size.height
@@ -97,7 +102,15 @@ public extension NativeImage {
     }
     let targetSize = CGSize(width: width, height: height)
 
-    let renderer = UIGraphicsImageRenderer(size: targetSize)
+    // Force scale=1 so output pixel dims == targetSize. Without a format,
+    // UIGraphicsImageRenderer defaults to UIScreen.main.scale, producing a
+    // bitmap of (width * scale, height * scale) pixels on 2x/3x devices while
+    // uiImage.size still reports (width, height) in points. The encoded JPEG
+    // then has the inflated pixel dimensions, which is surprising from JS
+    // where Image.width/Image.height looked correct.
+    let format = UIGraphicsImageRendererFormat()
+    format.scale = 1
+    let renderer = UIGraphicsImageRenderer(size: targetSize, format: format)
     let resizedImage = renderer.image { context in
       let targetRect = CGRect(origin: .zero, size: targetSize)
       uiImage.draw(in: targetRect)
@@ -120,16 +133,42 @@ public extension NativeImage {
     guard targetHeight > 0 else {
       throw RuntimeError.error(withMessage: "Height cannot be less than 0! (startY: \(startY) - endY: \(endY) = \(targetHeight))")
     }
-    guard let cgImage = uiImage.cgImage else {
+
+    // Normalize the UIImage before cropping. Two reasons:
+    //  1. When imageOrientation != .up (common for e.g. vision-camera's
+    //     Photo.toImageAsync() output which uses UIImage(cgImage:, orientation:)),
+    //     uiImage.size is in DISPLAY space but uiImage.cgImage is in SENSOR space.
+    //     Our (startX, startY, endX, endY) rect is in display space, so calling
+    //     cgImage.cropping(to:) directly crops the wrong region.
+    //  2. When uiImage.scale != 1, cgImage pixel dims are (size * scale), which
+    //     makes the rect mean something different from what the caller expects.
+    // Drawing through a scale=1 renderer bakes orientation into pixels and
+    // normalizes scale so cgImage and our rect agree.
+    let normalized: UIImage
+    if uiImage.imageOrientation == .up && uiImage.scale == 1 {
+      normalized = uiImage
+    } else {
+      let format = UIGraphicsImageRendererFormat()
+      format.scale = 1
+      let renderer = UIGraphicsImageRenderer(size: uiImage.size, format: format)
+      normalized = renderer.image { _ in
+        uiImage.draw(at: .zero)
+      }
+    }
+    guard let cgImage = normalized.cgImage else {
       throw RuntimeError.error(withMessage: "This image does not have an underlying .cgImage!")
     }
 
-    let targetRect = CGRect(origin: CGPoint(x: startX, y: startY),
-                            size: CGSize(width: uiImage.size.width, height: uiImage.size.height))
+    // Use the actual crop size (targetWidth, targetHeight). Previously this was
+    // CGSize(uiImage.size.width, uiImage.size.height), which made the rect the
+    // whole image and produced "image minus origin offset" instead of a real crop.
+    let targetRect = CGRect(x: startX, y: startY, width: targetWidth, height: targetHeight)
     guard let croppedCgImage = cgImage.cropping(to: targetRect) else {
       throw RuntimeError.error(withMessage: "Failed to crop CGImage to \(targetRect)!")
     }
-    let croppedUiImage = UIImage(cgImage: croppedCgImage)
+    // Wrap with explicit scale=1 and .up orientation so downstream ops see
+    // consistent state instead of inheriting UIImage defaults that drop metadata.
+    let croppedUiImage = UIImage(cgImage: croppedCgImage, scale: 1, orientation: .up)
     return HybridImage(uiImage: croppedUiImage)
   }