react-native-nitro-image-pipeline 0.1.1

package/ios/HybridNitroImagePipeline.swift

@@ -0,0 +1,114 @@
+//
+//  HybridNitroImagePipeline.swift
+//  Pods
+//
+//  Created by Alejandro Paredes Alva on 3/31/2026.
+//
+
+import Foundation
+import NitroModules
+import NitroImage
+import Nuke
+
+import UIKit
+import CoreImage
+
+private class HybridImage: HybridImageSpec, NativeImage {
+    let uiImage: UIImage
+
+    init(uiImage: UIImage) {
+        self.uiImage = uiImage
+        super.init()
+    }
+
+    var width: Double {
+        return Double(uiImage.size.width)
+    }
+
+    var height: Double {
+        return Double(uiImage.size.height)
+    }
+
+    func toArrayBuffer() throws -> ArrayBuffer {
+        guard let data = uiImage.pngData() else {
+            throw RuntimeError.error(withMessage: "Failed to encode image to PNG")
+        }
+        return try ArrayBuffer.copy(data: data)
+    }
+
+    func toBase64() throws -> String {
+        guard let data = uiImage.pngData() else {
+            throw RuntimeError.error(withMessage: "Failed to encode image")
+        }
+
+        return data.base64EncodedString()
+    }
+
+    var description: String {
+        return "HybridImage(\(width)x\(height))"
+    }
+}
+
+class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
+    private let prefetcher = ImagePrefetcher()
+
+    override init() {
+        ImagePipeline.shared = ImagePipeline(configuration: .withDataCache)
+    }
+
+    func loadImage(url: String, options: Options?) throws -> Promise<any HybridImageSpec> {
+        return Promise.async {
+            let imgRequest = ImageRequest(url: URL(string: url), processors: [
+                .gaussianBlur(radius: Int(options?.blur ?? 0)),
+                .roundedCorners(radius: options?.cornerRadius ?? 0)
+
+            ])
+            let image = try await ImagePipeline.shared.image(for: imgRequest)
+            return HybridImage(uiImage: image)
+        }
+    }
+
+    func preLoadImage(url: String) throws -> Promise<Void> {
+        return Promise.async {
+            guard let imageUrl = URL(string: url) else {
+                throw RuntimeError.error(withMessage: "Invalid URL: \(url)")
+            }
+
+            self.prefetcher.startPrefetching(with: [imageUrl])
+        }
+    }
+
+    func preLoadImages(urls: [String]) throws -> Promise<Void> {
+        return Promise.async {
+            let imageUrls = urls.compactMap { URL(string: $0) }
+            self.prefetcher.startPrefetching(with: imageUrls)
+        }
+    }
+
+    func clearCache() throws {
+        ImagePipeline.shared.cache.removeAll()
+    }
+
+    func gaussianBlur(image: any HybridImageSpec, radius: Double) throws -> Promise<any HybridImageSpec> {
+        return Promise.async {
+            guard let nativeImage = image as? NativeImage else {
+                throw RuntimeError.error(withMessage: "Unsupported image type")
+            }
+
+            let uiImage = nativeImage.uiImage
+
+            let ciImage = CIImage(image: uiImage)
+
+            let filter = CIFilter(name: "CIGaussianBlur")!
+            filter.setValue(ciImage, forKey: kCIInputImageKey)
+            filter.setValue(radius, forKey: kCIInputRadiusKey)
+
+            let context = CIContext()
+            let output = filter.outputImage
+            let cgImage = context.createCGImage(output!, from: ciImage!.extent)
+
+            return HybridImage(uiImage: UIImage(cgImage: cgImage!))
+        }
+    }
+
+}

package/lib/commonjs/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NitroImagePipeline = void 0;
+exports.useImage = useImage;
+var _react = require("react");
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+const NitroImagePipeline = exports.NitroImagePipeline = _reactNativeNitroModules.NitroModules.createHybridObject('NitroImagePipeline');
+/**
+ * A hook to asynchronously load an image from the
+ * given {@linkcode AsyncImageSource} into memory.
+ * @example
+ * ```ts
+ * const { image, error } = useImage({ filePath: '/tmp/image.jpg' })
+ * ```
+ */
+function useImage({
+  url,
+  blur = 0,
+  cornerRadius = 0
+}) {
+  const [image, setImage] = (0, _react.useState)({
+    image: undefined,
+    error: undefined
+  });
+  (0, _react.useEffect)(() => {
+    (async () => {
+      try {
+        const result = await NitroImagePipeline.loadImage(url, {
+          blur,
+          cornerRadius
+        });
+        setImage({
+          image: result,
+          error: undefined
+        });
+      } catch (e) {
+        const error = e instanceof Error ? e : new Error(`${e}`);
+        setImage({
+          image: undefined,
+          error: error
+        });
+      }
+    })();
+  }, [url, blur]);
+  return image;
+}
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_reactNativeNitroModules","NitroImagePipeline","exports","NitroModules","createHybridObject","useImage","url","blur","cornerRadius","image","setImage","useState","undefined","error","useEffect","result","loadImage","e","Error"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,wBAAA,GAAAD,OAAA;AAIO,MAAME,kBAAkB,GAAAC,OAAA,CAAAD,kBAAA,GAC7BE,qCAAY,CAACC,kBAAkB,CAAyB,oBAAoB,CAAC;AAmB/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,QAAQA,CAAC;EACvBC,GAAG;EACHC,IAAI,GAAG,CAAC;EACRC,YAAY,GAAG;AAKjB,CAAC,EAAU;EACT,MAAM,CAACC,KAAK,EAAEC,QAAQ,CAAC,GAAG,IAAAC,eAAQ,EAAS;IACzCF,KAAK,EAAEG,SAAS;IAChBC,KAAK,EAAED;EACT,CAAC,CAAC;EAEF,IAAAE,gBAAS,EAAC,MAAM;IACd,CAAC,YAAY;MACX,IAAI;QACF,MAAMC,MAAM,GAAG,MAAMd,kBAAkB,CAACe,SAAS,CAACV,GAAG,EAAE;UACrDC,IAAI;UACJC;QACF,CAAC,CAAC;QAEFE,QAAQ,CAAC;UAAED,KAAK,EAAEM,MAAM;UAAEF,KAAK,EAAED;QAAU,CAAC,CAAC;MAC/C,CAAC,CAAC,OAAOK,CAAC,EAAE;QACV,MAAMJ,KAAK,GAAGI,CAAC,YAAYC,KAAK,GAAGD,CAAC,GAAG,IAAIC,KAAK,CAAC,GAAGD,CAAC,EAAE,CAAC;QACxDP,QAAQ,CAAC;UAAED,KAAK,EAAEG,SAAS;UAAEC,KAAK,EAAEA;QAAM,CAAC,CAAC;MAC9C;IACF,CAAC,EAAE,CAAC;EACN,CAAC,EAAE,CAACP,GAAG,EAAEC,IAAI,CAAC,CAAC;EAEf,OAAOE,KAAK;AACd","ignoreList":[]}

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/commonjs/specs/nitro-image-toolkit.nitro.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=nitro-image-toolkit.nitro.js.map

package/lib/commonjs/specs/nitro-image-toolkit.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/nitro-image-toolkit.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,45 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { NitroModules } from 'react-native-nitro-modules';
+export const NitroImagePipeline = NitroModules.createHybridObject('NitroImagePipeline');
+/**
+ * A hook to asynchronously load an image from the
+ * given {@linkcode AsyncImageSource} into memory.
+ * @example
+ * ```ts
+ * const { image, error } = useImage({ filePath: '/tmp/image.jpg' })
+ * ```
+ */
+export function useImage({
+  url,
+  blur = 0,
+  cornerRadius = 0
+}) {
+  const [image, setImage] = useState({
+    image: undefined,
+    error: undefined
+  });
+  useEffect(() => {
+    (async () => {
+      try {
+        const result = await NitroImagePipeline.loadImage(url, {
+          blur,
+          cornerRadius
+        });
+        setImage({
+          image: result,
+          error: undefined
+        });
+      } catch (e) {
+        const error = e instanceof Error ? e : new Error(`${e}`);
+        setImage({
+          image: undefined,
+          error: error
+        });
+      }
+    })();
+  }, [url, blur]);
+  return image;
+}
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useState","NitroModules","NitroImagePipeline","createHybridObject","useImage","url","blur","cornerRadius","image","setImage","undefined","error","result","loadImage","e","Error"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,OAAO;AAE3C,SAASC,YAAY,QAAQ,4BAA4B;AAIzD,OAAO,MAAMC,kBAAkB,GAC7BD,YAAY,CAACE,kBAAkB,CAAyB,oBAAoB,CAAC;AAmB/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,QAAQA,CAAC;EACvBC,GAAG;EACHC,IAAI,GAAG,CAAC;EACRC,YAAY,GAAG;AAKjB,CAAC,EAAU;EACT,MAAM,CAACC,KAAK,EAAEC,QAAQ,CAAC,GAAGT,QAAQ,CAAS;IACzCQ,KAAK,EAAEE,SAAS;IAChBC,KAAK,EAAED;EACT,CAAC,CAAC;EAEFX,SAAS,CAAC,MAAM;IACd,CAAC,YAAY;MACX,IAAI;QACF,MAAMa,MAAM,GAAG,MAAMV,kBAAkB,CAACW,SAAS,CAACR,GAAG,EAAE;UACrDC,IAAI;UACJC;QACF,CAAC,CAAC;QAEFE,QAAQ,CAAC;UAAED,KAAK,EAAEI,MAAM;UAAED,KAAK,EAAED;QAAU,CAAC,CAAC;MAC/C,CAAC,CAAC,OAAOI,CAAC,EAAE;QACV,MAAMH,KAAK,GAAGG,CAAC,YAAYC,KAAK,GAAGD,CAAC,GAAG,IAAIC,KAAK,CAAC,GAAGD,CAAC,EAAE,CAAC;QACxDL,QAAQ,CAAC;UAAED,KAAK,EAAEE,SAAS;UAAEC,KAAK,EAAEA;QAAM,CAAC,CAAC;MAC9C;IACF,CAAC,EAAE,CAAC;EACN,CAAC,EAAE,CAACN,GAAG,EAAEC,IAAI,CAAC,CAAC;EAEf,OAAOE,KAAK;AACd","ignoreList":[]}

package/lib/module/specs/nitro-image-toolkit.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=nitro-image-toolkit.nitro.js.map

package/lib/module/specs/nitro-image-toolkit.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/nitro-image-toolkit.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,28 @@
+import type { Image } from 'react-native-nitro-image';
+import type { NitroImagePipeline as NitroImagePipelineSpec } from './specs/nitro-image-toolkit.nitro';
+export declare const NitroImagePipeline: NitroImagePipelineSpec;
+type Result = {
+    image: undefined;
+    error: undefined;
+} | {
+    image: Image;
+    error: undefined;
+} | {
+    image: undefined;
+    error: Error;
+};
+/**
+ * A hook to asynchronously load an image from the
+ * given {@linkcode AsyncImageSource} into memory.
+ * @example
+ * ```ts
+ * const { image, error } = useImage({ filePath: '/tmp/image.jpg' })
+ * ```
+ */
+export declare function useImage({ url, blur, cornerRadius, }: {
+    url: string;
+    blur?: number;
+    cornerRadius?: number;
+}): Result;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAGtD,OAAO,KAAK,EAAE,kBAAkB,IAAI,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAEtG,eAAO,MAAM,kBAAkB,wBACgD,CAAC;AAEhF,KAAK,MAAM,GAEP;IACE,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,SAAS,CAAC;CAClB,GAED;IACE,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;CAClB,GAED;IACE,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEN;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,EACvB,GAAG,EACH,IAAQ,EACR,YAAgB,GACjB,EAAE;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,MAAM,CAuBT"}

package/lib/typescript/src/specs/nitro-image-toolkit.nitro.d.ts

@@ -0,0 +1,20 @@
+import type { Image } from 'react-native-nitro-image';
+import type { HybridObject } from 'react-native-nitro-modules';
+type CacheOption = 'memory' | 'disk' | 'none';
+type Options = {
+    blur?: number;
+    cache?: CacheOption;
+    cornerRadius?: number;
+};
+export interface NitroImagePipeline extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    loadImage(url: string, options?: Options): Promise<Image>;
+    preLoadImage(url: string): Promise<void>;
+    preLoadImages(urls: string[]): Promise<void>;
+    gaussianBlur(image: Image, radius: number): Promise<Image>;
+    clearCache(): void;
+}
+export {};
+//# sourceMappingURL=nitro-image-toolkit.nitro.d.ts.map

package/lib/typescript/src/specs/nitro-image-toolkit.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nitro-image-toolkit.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/nitro-image-toolkit.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,KAAK,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AAC9C,KAAK,OAAO,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7E,MAAM,WAAW,kBACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC1D,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAG3D,UAAU,IAAI,IAAI,CAAC;CACpB"}

package/nitro.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": ["nitroimagepipeline"],
+  "ios": {
+    "iosModuleName": "NitroImagePipeline"
+  },
+  "android": {
+    "androidNamespace": ["nitroimagepipeline"],
+    "androidCxxLibName": "NitroImagePipeline"
+  },
+  "autolinking": {
+    "NitroImagePipeline": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridNitroImagePipeline"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridNitroImagePipeline"
+      }
+    }
+  },
+  "ignorePaths": ["**/node_modules"]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/nitrogen/generated/android/NitroImagePipeline+autolinking.cmake

@@ -0,0 +1,81 @@
+#
+# NitroImagePipeline+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroImagePipeline+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_NITROIMAGEPIPELINE_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  NitroImagePipeline PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/NitroImagePipelineOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridNitroImagePipelineSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridNitroImagePipelineSpec.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  NitroImagePipeline PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        NitroImagePipeline
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        NitroImagePipeline
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        NitroImagePipeline
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/NitroImagePipeline+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// NitroImagePipeline+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/NitroImagePipeline+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 NitroImagePipeline is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/NitroImagePipelineOnLoad.cpp

@@ -0,0 +1,54 @@
+///
+/// NitroImagePipelineOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_NITROIMAGEPIPELINE_WITH_GENERATED_CMAKE_PROJECT
+#error NitroImagePipelineOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "NitroImagePipelineOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridNitroImagePipelineSpec.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::nitroimagepipeline {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::nitroimagepipeline::registerAllNatives();
+  });
+}
+
+struct JHybridNitroImagePipelineSpecImpl: public jni::JavaClass<JHybridNitroImagePipelineSpecImpl, JHybridNitroImagePipelineSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroimagepipeline/HybridNitroImagePipeline;";
+  static std::shared_ptr<JHybridNitroImagePipelineSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridNitroImagePipelineSpecImpl::javaobject()>();
+    jni::local_ref<JHybridNitroImagePipelineSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridNitroImagePipelineSpec();
+  }
+};
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::nitroimagepipeline;
+
+  // Register native JNI methods
+  margelo::nitro::nitroimagepipeline::JHybridNitroImagePipelineSpec::CxxPart::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NitroImagePipeline",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridNitroImagePipelineSpecImpl::create();
+    }
+  );
+}
+
+} // namespace margelo::nitro::nitroimagepipeline

package/nitrogen/generated/android/NitroImagePipelineOnLoad.hpp

@@ -0,0 +1,34 @@
+///
+/// NitroImagePipelineOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <functional>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::nitroimagepipeline {
+
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
+  /**
+   * Register the native (C++) part of NitroImagePipeline, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all NitroImagePipeline HybridObjects
+   *     margelo::nitro::nitroimagepipeline::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
+   * }
+   * ```
+   */
+  void registerAllNatives();
+
+} // namespace margelo::nitro::nitroimagepipeline

package/nitrogen/generated/android/c++/JCacheOption.hpp

@@ -0,0 +1,61 @@
+///
+/// JCacheOption.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "CacheOption.hpp"
+
+namespace margelo::nitro::nitroimagepipeline {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "CacheOption" and the the Kotlin enum "CacheOption".
+   */
+  struct JCacheOption final: public jni::JavaClass<JCacheOption> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroimagepipeline/CacheOption;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum CacheOption.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CacheOption toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<CacheOption>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JCacheOption> fromCpp(CacheOption value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case CacheOption::MEMORY:
+          static const auto fieldMEMORY = clazz->getStaticField<JCacheOption>("MEMORY");
+          return clazz->getStaticFieldValue(fieldMEMORY);
+        case CacheOption::DISK:
+          static const auto fieldDISK = clazz->getStaticField<JCacheOption>("DISK");
+          return clazz->getStaticFieldValue(fieldDISK);
+        case CacheOption::NONE:
+          static const auto fieldNONE = clazz->getStaticField<JCacheOption>("NONE");
+          return clazz->getStaticFieldValue(fieldNONE);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitroimagepipeline