react-native-nitro-image-pipeline 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alejandro Paredes Alva
+
+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/NitroImagePipeline.podspec

@@ -0,0 +1,39 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroImagePipeline"
+  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, :visionos => 1.0 }
+  s.source       = { :git => "https://github.com/aparedes/react-native-nitro-image-pipeline.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  load 'nitrogen/generated/ios/NitroImagePipeline+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  s.dependency 'NitroImage'
+
+  spm_dependency(s,
+    url: 'https://github.com/kean/Nuke',
+    requirement: { kind: 'upToNextMajorVersion', minimumVersion: '13.0.0' },
+    products: ['Nuke']
+  )
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,125 @@
+# react-native-nitro-image-pipeline
+
+A high-performance image loading, caching, and processing library for React Native, built with [Nitro Modules](https://nitro.margelo.com/).
+
+[![Version](https://img.shields.io/npm/v/react-native-nitro-image-pipeline.svg)](https://www.npmjs.com/package/react-native-nitro-image-pipeline)
+[![Downloads](https://img.shields.io/npm/dm/react-native-nitro-image-pipeline.svg)](https://www.npmjs.com/package/react-native-nitro-image-pipeline)
+[![License](https://img.shields.io/npm/l/react-native-nitro-image-pipeline.svg)](https://github.com/aparedes/react-native-nitro-image-pipeline/LICENSE)
+
+## Features
+
+- Load remote images with built-in memory and disk caching
+- Prefetch single or multiple images in the background
+- Apply Gaussian blur and rounded corners at load time
+- Apply Gaussian blur to already-loaded images
+- Clear the image cache on demand
+- `useImage` hook for declarative image loading in components
+
+## Requirements
+
+- React Native v0.76.0 or higher
+- Node 18.0.0 or higher
+
+> [!IMPORTANT]
+> To support `Nitro Views` you need React Native v0.78.0 or higher.
+
+## Installation
+
+```bash
+# npm
+npm install react-native-nitro-image-pipeline react-native-nitro-modules react-native-nitro-image
+
+# pnpm
+pnpm add react-native-nitro-image-pipeline react-native-nitro-modules react-native-nitro-image
+
+# bun
+bun add react-native-nitro-image-pipeline react-native-nitro-modules react-native-nitro-image
+```
+
+## Usage
+
+### `useImage` hook
+
+The simplest way to load an image in a component:
+
+```tsx
+import { useImage } from 'react-native-nitro-image-pipeline';
+
+function MyComponent() {
+  const { image, error } = useImage({
+    url: 'https://example.com/photo.jpg',
+    blur: 4,
+    cornerRadius: 12,
+  });
+
+  if (error) return <Text>Failed to load image</Text>;
+  if (!image) return <ActivityIndicator />;
+
+  // use `image` with react-native-nitro-image
+  return <NitroImage source={image} />;
+}
+```
+
+### Direct API
+
+```ts
+import { NitroImagePipeline } from 'react-native-nitro-image-pipeline';
+
+// Load an image with options
+const image = await NitroImagePipeline.loadImage('https://example.com/photo.jpg', {
+  blur: 4,
+  cornerRadius: 12,
+  cache: 'disk',
+});
+
+// Prefetch a single image
+await NitroImagePipeline.preLoadImage('https://example.com/photo.jpg');
+
+// Prefetch multiple images
+await NitroImagePipeline.preLoadImages([
+  'https://example.com/a.jpg',
+  'https://example.com/b.jpg',
+]);
+
+// Apply Gaussian blur to an already-loaded image
+const blurred = await NitroImagePipeline.gaussianBlur(image, 10);
+
+// Clear the image cache
+NitroImagePipeline.clearCache();
+```
+
+## API Reference
+
+### `loadImage(url, options?)`
+
+Loads an image from a URL and returns a `Promise<Image>`.
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `blur` | `number` | `0` | Gaussian blur radius applied at load time |
+| `cornerRadius` | `number` | `0` | Corner radius in points |
+| `cache` | `'memory' \| 'disk' \| 'none'` | platform default | Caching strategy |
+
+### `preLoadImage(url)`
+
+Prefetches a single image into the cache. Returns `Promise<void>`.
+
+### `preLoadImages(urls)`
+
+Prefetches multiple images into the cache. Returns `Promise<void>`.
+
+### `gaussianBlur(image, radius)`
+
+Applies a Gaussian blur to an existing `Image` object. Returns `Promise<Image>`.
+
+### `clearCache()`
+
+Removes all cached images from memory and disk.
+
+## Credits
+
+Bootstrapped with [create-nitro-module](https://github.com/patrickkabwe/create-nitro-module).
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

package/android/CMakeLists.txt

@@ -0,0 +1,34 @@
+project(NitroImagePipeline)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME NitroImagePipeline)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_compile_options(-DRN_SERIALIZABLE_STATE=1)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED
+        src/main/cpp/cpp-adapter.cpp
+)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroImagePipeline+autolinking.cmake)
+
+# Set up local includes
+include_directories(
+        "src/main/cpp"
+        "../cpp"
+)
+
+find_library(LOG_LIB log)
+find_package(react-native-nitro-image REQUIRED)   # <-- for the HybridImage type
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android                                   # <-- Android core
+        react-native-nitro-image::NitroImage      # <-- NitroImage
+)

package/android/build.gradle

@@ -0,0 +1,158 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.8.0"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/NitroImagePipeline+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroImagePipeline_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroImagePipeline_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.nitroimagepipeline"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+        "META-INF",
+        "META-INF/**",
+        "**/libc++_shared.so",
+        "**/libfbjni.so",
+        "**/libjsi.so",
+        "**/libfolly_json.so",
+        "**/libfolly_runtime.so",
+        "**/libglog.so",
+        "**/libhermes.so",
+        "**/libhermes-executor-debug.so",
+        "**/libhermes_executor.so",
+        "**/libreactnative.so",
+        "**/libreactnativejni.so",
+        "**/libturbomodulejsijni.so",
+        "**/libreact_nativemodule_core.so",
+        "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+
+  // Add a dependency on NitroImage
+  implementation project(":react-native-nitro-image")
+  // Coil
+  implementation("io.coil-kt.coil3:coil:3.3.0")
+  implementation("io.coil-kt.coil3:coil-network-okhttp:3.3.0")
+  implementation("io.coil-kt.coil3:coil-gif:3.3.0")
+  // Cronet (uses Play Services provider — no APK size cost, falls back gracefully if unavailable)
+  implementation("com.google.android.gms:play-services-cronet:18.1.0")
+  implementation("com.google.net.cronet:cronet-okhttp:0.1.0")
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "NitroImagePipeline"
+    codegenJavaPackageName = "com.margelo.nitro.nitroimagepipeline"
+  }
+}

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroImagePipeline_kotlinVersion=2.1.20
+NitroImagePipeline_minSdkVersion=23
+NitroImagePipeline_targetSdkVersion=35
+NitroImagePipeline_compileSdkVersion=34
+NitroImagePipeline_ndkVersion=27.1.12297006

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/cpp-adapter.cpp

@@ -0,0 +1,9 @@
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include "NitroImagePipelineOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::nitroimagepipeline::registerAllNatives();
+  });
+}

package/android/src/main/java/com/margelo/nitro/nitroimagepipeline/HybridNitroImagePipeline.kt

@@ -0,0 +1,119 @@
+package com.margelo.nitro.nitroimagepipeline
+
+import android.content.Context
+import androidx.core.graphics.drawable.toBitmap
+import coil3.BitmapImage
+import coil3.DrawableImage
+import coil3.ImageLoader
+import coil3.disk.DiskCache
+import coil3.memory.MemoryCache
+import coil3.network.okhttp.OkHttpNetworkFetcherFactory
+import coil3.request.ErrorResult
+import coil3.request.ImageRequest
+import coil3.request.SuccessResult
+import coil3.request.allowHardware
+import coil3.request.transformations
+import coil3.size.Size
+import coil3.transform.RoundedCornersTransformation
+import com.google.net.cronet.okhttptransport.CronetInterceptor
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.image.HybridImage
+import com.margelo.nitro.image.HybridImageSpec
+import com.margelo.nitro.nitroimagepipeline.transform.BlurTransformation
+import okhttp3.OkHttpClient
+import okio.Path.Companion.toOkioPath
+import org.chromium.net.CronetEngine
+
+class HybridNitroImagePipeline : HybridNitroImagePipelineSpec() {
+  private val context
+    get() = NitroModules.applicationContext as Context
+
+  private val okHttpClient: OkHttpClient by lazy {
+    val builder = OkHttpClient.Builder()
+    try {
+      val cronetEngine = CronetEngine.Builder(context).build()
+      builder.addInterceptor(CronetInterceptor.newBuilder(cronetEngine).build())
+    } catch (_: Exception) {
+      // Cronet unavailable (no GMS or unsupported device) — use plain OkHttp
+    }
+    builder.build()
+  }
+
+  private val imageLoader: ImageLoader by lazy {
+    ImageLoader.Builder(context)
+        .components { add(OkHttpNetworkFetcherFactory(callFactory = okHttpClient)) }
+        .memoryCache { MemoryCache.Builder().maxSizePercent(context, 0.25).build() }
+        .diskCache {
+          DiskCache.Builder()
+              .directory(context.cacheDir.resolve("nitro_image_cache").toOkioPath())
+              .maxSizeBytes(256L * 1024 * 1024)
+              .build()
+        }
+        .build()
+  }
+
+  override fun loadImage(url: String, options: Options?): Promise<HybridImageSpec> =
+      Promise.async {
+        val blur = options?.blur?.toFloat() ?: 0f
+        val cornerRadius = options?.cornerRadius?.toFloat() ?: 0f
+        val transformations = buildList {
+          if (blur > 0f) add(BlurTransformation(context, blur))
+          if (cornerRadius > 0f) add(RoundedCornersTransformation(cornerRadius))
+        }
+        val memoryCacheKey = buildString {
+          append(url)
+          if (blur > 0f) append("_blur$blur")
+          if (cornerRadius > 0f) append("_corner$cornerRadius")
+        }
+        val request =
+            ImageRequest.Builder(context)
+                .data(url)
+                .allowHardware(true)
+                .memoryCacheKey(memoryCacheKey)
+                .transformations(transformations)
+                .build()
+
+        val result = imageLoader.execute(request)
+        when (result) {
+          is ErrorResult -> throw result.throwable
+          is SuccessResult -> {
+            val bitmap =
+                when (val img = result.image) {
+                  is BitmapImage -> img.bitmap
+                  is DrawableImage -> img.drawable.toBitmap()
+                  else -> throw Error("Unsupported image type: ${img.javaClass.simpleName}")
+                }
+            HybridImage(bitmap)
+          }
+        }
+      }
+
+  override fun preLoadImage(url: String): Promise<Unit> =
+      Promise.async {
+        val request = ImageRequest.Builder(context).data(url).build()
+        imageLoader.execute(request)
+      }
+
+  override fun preLoadImages(urls: Array<String>): Promise<Unit> =
+      Promise.async {
+        for (url in urls) {
+          val request = ImageRequest.Builder(context).data(url).build()
+          imageLoader.execute(request)
+        }
+      }
+
+  override fun gaussianBlur(image: HybridImageSpec, radius: Double): Promise<HybridImageSpec> =
+      Promise.async {
+        val hybridImage = image as? HybridImage ?: throw Error("Image is not a HybridImage")
+        val clampedRadius = radius.toFloat().coerceIn(0.01f, 25f)
+        val blurred =
+            BlurTransformation(context, clampedRadius).transform(hybridImage.bitmap, Size.ORIGINAL)
+        HybridImage(blurred)
+      }
+
+  override fun clearCache() {
+    imageLoader.memoryCache?.clear()
+    imageLoader.diskCache?.clear()
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitroimagepipeline/NitroImagePipelinePackage.kt

@@ -0,0 +1,19 @@
+package com.margelo.nitro.nitroimagepipeline
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+public class NitroImagePipelinePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+      ReactModuleInfoProvider { emptyMap() }
+
+  companion object {
+    init {
+      NitroImagePipelineOnLoad.initializeNative();
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitroimagepipeline/transform/BlurTransformation.kt

@@ -0,0 +1,84 @@
+@file:Suppress("DEPRECATION")
+
+package com.margelo.nitro.nitroimagepipeline.transform
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Paint
+import android.renderscript.Allocation
+import android.renderscript.Element
+import android.renderscript.RenderScript
+import android.renderscript.ScriptIntrinsicBlur
+import androidx.core.graphics.applyCanvas
+import androidx.core.graphics.scale
+import coil3.size.Size
+import coil3.transform.Transformation
+
+class BlurTransformation(
+    private val context: Context,
+    private val radius: Float = 10f,
+    private val sampling: Float = 1f,
+) : Transformation() {
+
+    init {
+        require(radius in 0.01..25.0) { "radius must be in (0, 25]." }
+        require(sampling >= 1f) { "sampling must be >= 1." }
+    }
+
+    override val cacheKey = "${BlurTransformation::class.java.name}-$radius-$sampling"
+
+    override suspend fun transform(input: Bitmap, size: Size): Bitmap {
+        val paint = Paint(Paint.ANTI_ALIAS_FLAG or Paint.FILTER_BITMAP_FLAG)
+        // Auto-scale so the blurred image is at most 512px on the longest side.
+        // Blur is a low-pass filter so blurring at lower resolution is identical in quality.
+        val autoSampling = (maxOf(input.width, input.height) / 512f).coerceAtLeast(sampling)
+        val scaledWidth = (input.width / autoSampling).toInt().coerceAtLeast(1)
+        val scaledHeight = (input.height / autoSampling).toInt().coerceAtLeast(1)
+        val config = input.config ?: Bitmap.Config.ARGB_8888
+
+        val output = Bitmap.createBitmap(scaledWidth, scaledHeight, config)
+        output.applyCanvas {
+            scale(1 / autoSampling, 1 / autoSampling)
+            drawBitmap(input, 0f, 0f, paint)
+        }
+
+        var script: RenderScript? = null
+        var tmpIn: Allocation? = null
+        var tmpOut: Allocation? = null
+        var blur: ScriptIntrinsicBlur? = null
+        try {
+            script = RenderScript.create(context)
+            tmpIn = Allocation.createFromBitmap(script, output, Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT)
+            tmpOut = Allocation.createTyped(script, tmpIn.type)
+            blur = ScriptIntrinsicBlur.create(script, Element.U8_4(script))
+            blur.setRadius(radius)
+            blur.setInput(tmpIn)
+            blur.forEach(tmpOut)
+            tmpOut.copyTo(output)
+        } finally {
+            script?.destroy()
+            tmpIn?.destroy()
+            tmpOut?.destroy()
+            blur?.destroy()
+        }
+
+        return output.scale(input.width, input.height)
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        return other is BlurTransformation &&
+            context == other.context &&
+            radius == other.radius &&
+            sampling == other.sampling
+    }
+
+    override fun hashCode(): Int {
+        var result = context.hashCode()
+        result = 31 * result + radius.hashCode()
+        result = 31 * result + sampling.hashCode()
+        return result
+    }
+
+    override fun toString() = "BlurTransformation(radius=$radius, sampling=$sampling)"
+}

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  nitro-image-toolkit
+//
+//  Created by Alejandro Paredes Alva on 3/31/2026
+//
+
+#pragma once