@nitro-mlkit/digital-ink 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gonzalo Polo
+
+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/NitroMLKitDigitalInk.podspec

@@ -0,0 +1,34 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroMLKitDigitalInk"
+  # Must match nitro.json's `ios.iosModuleName` — Nitrogen's generated bridge
+  # imports "NitroMLKitDigitalInk-Swift.h", so the compiled Swift module name has to be NitroMLKitDigitalInk.
+  s.module_name  = "NitroMLKitDigitalInk"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["repository"]["url"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+  s.source       = { :git => "https://github.com/pologonzalo/react-native-nitro-mlkit.git", :tag => s.version }
+
+  s.platforms    = { :ios => "15.5" }
+
+  s.source_files = [
+    "ios/**/*.{swift,h,m,mm,cpp}"
+  ]
+
+  s.dependency "GoogleMLKit/DigitalInkRecognition", "~> 7.0"
+
+  s.pod_target_xcconfig = {
+    "SWIFT_VERSION" => "5.9"
+  }
+
+  # Add all files generated by Nitrogen (generated sources + NitroModules dep +
+  # the C++/Swift-interop build flags — same setup as the working
+  # NitroMLKitFaceDetection podspec).
+  load 'nitrogen/generated/ios/NitroMLKitDigitalInk+autolinking.rb'
+  add_nitrogen_files(s)
+end

package/README.md

@@ -0,0 +1,67 @@
+# React Native ML Kit — Digital Ink Recognition
+
+**`@nitro-mlkit/digital-ink`** · on-device Google ML Kit via [Nitro Modules](https://github.com/mrousavy/nitro) — JSI, no bridge.
+
+> ⚠️ **Beta (`0.1.0-beta.x`).** Android verified on-device. iOS builds & links
+> but device runtime is pending — see [Platform status](#platform-status).
+
+High-performance, on-device **handwriting / digital-ink recognition** for React
+Native, built with [Nitro Modules](https://github.com/mrousavy/nitro) (JSI, no bridge).
+
+Powered by **Google ML Kit**. Feed it the **strokes** the user drew (points with
+optional timestamps) and a language tag; get back candidate transcriptions.
+300+ languages, plus autodraw/shapes and emoji. The per-language model
+**downloads at runtime** on first use. **All on-device.**
+
+## Installation
+
+```bash
+npm install @nitro-mlkit/digital-ink@beta react-native-nitro-modules
+```
+
+No config plugin (autolinked Expo module). Install and `npx expo prebuild`.
+Not available in Expo Go.
+
+## Usage
+
+```ts
+import { NitroDigitalInk, type InkStroke } from "@nitro-mlkit/digital-ink";
+
+// Collect strokes from your canvas (e.g. via PanResponder). Each stroke is the
+// list of points between pen-down and pen-up. Timestamps (t) are optional but
+// improve accuracy.
+const strokes: InkStroke[] = [
+  { points: [ { x: 10, y: 20, t: 0 }, { x: 12, y: 22, t: 16 }, /* … */ ] },
+];
+
+const candidates = await NitroDigitalInk.recognize(strokes, "en-US");
+// → [{ text: "hello", score: … }, { text: "helio", … }, …]  (best first)
+
+// Model management
+await NitroDigitalInk.downloadModel("es-ES");
+await NitroDigitalInk.isModelDownloaded("es-ES"); // boolean
+await NitroDigitalInk.deleteModel("es-ES");
+
+NitroDigitalInk.isAvailable(); // boolean
+```
+
+Language tags follow ML Kit's identifiers (e.g. `"en-US"`, `"es-ES"`, `"fr-FR"`,
+`"zh-Hani"`, `"emoji"`).
+
+## Platform status
+
+| Platform | Min | Status |
+| -------- | --- | ------ |
+| Android  | API 26+ | ✅ Verified on-device (Pixel 9, API 36) |
+| iOS      | 15.5+   | ⚠️ Swift impl written; on-device build & run pending¹ |
+| tvOS/macOS | — | 🔜 Planned |
+
+¹ ML Kit's iOS pods ship no `arm64` Simulator slice; validate on a physical device.
+
+## Part of `nitro-mlkit`
+
+The full ML Kit suite on Nitro — see the other `@nitro-mlkit/*` packages.
+
+## License
+
+MIT © Gonzalo Polo

package/android/CMakeLists.txt

@@ -0,0 +1,12 @@
+project(NitroMLKitDigitalInk)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(NitroMLKitDigitalInk SHARED
+  src/main/cpp/cpp-adapter.cpp
+)
+
+# Add all files generated by Nitrogen
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroMLKitDigitalInk+autolinking.cmake)

package/android/build.gradle

@@ -0,0 +1,77 @@
+buildscript {
+    ext.safeExtGet = { prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+}
+
+def reactNativeArchitectures() {
+    def value = rootProject.getProperties().get("reactNativeArchitectures")
+    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+android {
+    namespace "com.nitromlkit.digitalink"
+    compileSdkVersion safeExtGet("compileSdkVersion", 35)
+    ndkVersion safeExtGet("ndkVersion", "27.1.12297006")
+
+    defaultConfig {
+        minSdkVersion safeExtGet("minSdkVersion", 26)
+        targetSdkVersion safeExtGet("targetSdkVersion", 35)
+
+        externalNativeBuild {
+            cmake {
+                arguments "-DANDROID_STL=c++_shared"
+                abiFilters (*reactNativeArchitectures())
+            }
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path "CMakeLists.txt"
+        }
+    }
+
+    buildFeatures {
+        prefab true
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs += [
+                "src/main/kotlin",
+                "../nitrogen/generated/android/kotlin"
+            ]
+        }
+    }
+}
+
+dependencies {
+    // MLKit
+    implementation "com.google.mlkit:digital-ink-recognition:19.0.0"
+
+    // Nitro Modules
+    implementation project(":react-native-nitro-modules")
+
+    // Expo Modules (only used so autolinking calls our OnLoad at startup)
+    implementation project(":expo-modules-core")
+
+    // Kotlin coroutines
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.9.0"
+
+    // React Native
+    implementation "com.facebook.react:react-android"
+}

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/cpp/cpp-adapter.cpp

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

package/android/src/main/kotlin/com/margelo/nitro/nitromlkit/digitalink/HybridDigitalInkRecognizer.kt

@@ -0,0 +1,84 @@
+package com.margelo.nitro.nitromlkit.digitalink
+
+import com.google.mlkit.common.model.DownloadConditions
+import com.google.mlkit.common.model.RemoteModelManager
+import com.google.mlkit.vision.digitalink.recognition.DigitalInkRecognition
+import com.google.mlkit.vision.digitalink.recognition.DigitalInkRecognitionModel
+import com.google.mlkit.vision.digitalink.recognition.DigitalInkRecognitionModelIdentifier
+import com.google.mlkit.vision.digitalink.recognition.DigitalInkRecognizerOptions
+import com.google.mlkit.vision.digitalink.recognition.Ink
+import com.margelo.nitro.core.Promise
+import kotlinx.coroutines.tasks.await
+
+/**
+ * Native Android implementation of DigitalInkRecognizer (MLKit Digital Ink).
+ * Ink strokes (points with optional timestamps) go in; candidate
+ * transcriptions come out. The per-language model downloads on first use.
+ */
+class HybridDigitalInkRecognizer : HybridDigitalInkRecognizerSpec() {
+
+  private val modelManager by lazy { RemoteModelManager.getInstance() }
+
+  private fun modelFor(languageTag: String): DigitalInkRecognitionModel {
+    val id = DigitalInkRecognitionModelIdentifier.fromLanguageTag(languageTag)
+      ?: throw IllegalArgumentException("Unsupported language tag: $languageTag")
+    return DigitalInkRecognitionModel.builder(id).build()
+  }
+
+  private fun buildInk(strokes: Array<InkStroke>): Ink {
+    val ink = Ink.builder()
+    for (stroke in strokes) {
+      val sb = Ink.Stroke.builder()
+      for (p in stroke.points) {
+        val t = p.t
+        sb.addPoint(
+          if (t != null) Ink.Point.create(p.x.toFloat(), p.y.toFloat(), t.toLong())
+          else Ink.Point.create(p.x.toFloat(), p.y.toFloat()),
+        )
+      }
+      ink.addStroke(sb.build())
+    }
+    return ink.build()
+  }
+
+  override fun recognize(
+    strokes: Array<InkStroke>,
+    languageTag: String,
+  ): Promise<Array<RecognitionCandidate>> {
+    return Promise.async {
+      val model = modelFor(languageTag)
+      modelManager.download(model, DownloadConditions.Builder().build()).await()
+      val recognizer = DigitalInkRecognition.getClient(
+        DigitalInkRecognizerOptions.builder(model).build(),
+      )
+      try {
+        val result = recognizer.recognize(buildInk(strokes)).await()
+        result.candidates
+          .map { RecognitionCandidate(it.text, it.score?.toDouble()) }
+          .toTypedArray()
+      } finally {
+        recognizer.close()
+      }
+    }
+  }
+
+  override fun downloadModel(languageTag: String): Promise<Unit> {
+    return Promise.async {
+      modelManager.download(modelFor(languageTag), DownloadConditions.Builder().build()).await()
+      Unit
+    }
+  }
+
+  override fun isModelDownloaded(languageTag: String): Promise<Boolean> {
+    return Promise.async { modelManager.isModelDownloaded(modelFor(languageTag)).await() }
+  }
+
+  override fun deleteModel(languageTag: String): Promise<Unit> {
+    return Promise.async {
+      modelManager.deleteDownloadedModel(modelFor(languageTag)).await()
+      Unit
+    }
+  }
+
+  override fun isAvailable(): Boolean = true
+}

package/android/src/main/kotlin/com/nitromlkit/digitalink/NitroMLKitDigitalInkPackage.kt

@@ -0,0 +1,19 @@
+package com.nitromlkit.digitalink
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import com.margelo.nitro.nitromlkit.digitalink.NitroMLKitDigitalInkOnLoad
+
+/**
+ * Loads the native library and registers the DigitalInkRecognizer HybridObject at
+ * startup via Expo autolinking. Exposes no JS API of its own.
+ */
+class NitroMLKitDigitalInkPackage : Module() {
+  init {
+    NitroMLKitDigitalInkOnLoad.initializeNative()
+  }
+
+  override fun definition() = ModuleDefinition {
+    Name("NitroMLKitDigitalInk")
+  }
+}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["ios", "android"],
+  "ios": {
+    "modules": []
+  },
+  "android": {
+    "modules": ["com.nitromlkit.digitalink.NitroMLKitDigitalInkPackage"]
+  }
+}

package/ios/HybridDigitalInkRecognizer.swift

@@ -0,0 +1,156 @@
+import Foundation
+import NitroModules
+import MLKitCommon
+import MLKitDigitalInkRecognition
+
+/**
+ * Native iOS implementation of DigitalInkRecognizer (MLKit Digital Ink).
+ * Conforms to the Nitrogen-generated HybridDigitalInkRecognizerSpec protocol.
+ *
+ * Ink strokes (points with optional timestamps) go in; candidate transcriptions
+ * come out. The per-language model downloads on first use. Model downloads are
+ * notification-based on iOS (unlike the Task-based Android API), so
+ * `ModelManager.download(_:conditions:)` is bridged to async via a
+ * NotificationCenter observer wrapped in a continuation.
+ */
+class HybridDigitalInkRecognizer: HybridDigitalInkRecognizerSpec {
+
+    // MARK: - HybridObject boilerplate
+    var memorySize: Int { MemoryLayout<HybridDigitalInkRecognizer>.size }
+
+    // MARK: - Lazy MLKit model manager
+    private lazy var modelManager: ModelManager = ModelManager.modelManager()
+
+    // MARK: - Helpers
+
+    /// Resolve a BCP-47 language tag to a `DigitalInkRecognitionModel`, or throw.
+    private func model(for languageTag: String) throws -> DigitalInkRecognitionModel {
+        // `modelIdentifierForLanguageTag:` is a failable (non-throwing) init on
+        // iOS — it returns nil for an unsupported tag.
+        guard let identifier = DigitalInkRecognitionModelIdentifier(forLanguageTag: languageTag) else {
+            throw RuntimeError.error(withMessage: "Unsupported language tag: \(languageTag)")
+        }
+        return DigitalInkRecognitionModel(modelIdentifier: identifier)
+    }
+
+    /// Build a `Ink` from the Nitro InkStroke array.
+    private func buildInk(from strokes: [InkStroke]) -> Ink {
+        // On iOS these are top-level types (NS_SWIFT_NAME): StrokePoint / Stroke /
+        // Ink — NOT nested Ink.Point / Ink.Stroke (that's the Android spelling).
+        let mlStrokes: [Stroke] = strokes.map { stroke in
+            let points: [StrokePoint] = stroke.points.map { p in
+                if let t = p.t {
+                    return StrokePoint(x: Float(p.x), y: Float(p.y), t: Int(t))
+                } else {
+                    return StrokePoint(x: Float(p.x), y: Float(p.y))
+                }
+            }
+            return Stroke(points: points)
+        }
+        return Ink(strokes: mlStrokes)
+    }
+
+    /// Bridge the notification-based ML Kit model download to async/await.
+    private func awaitModelDownload(_ model: DigitalInkRecognitionModel,
+                                    conditions: ModelDownloadConditions) async throws {
+        try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+            let center = NotificationCenter.default
+            var didResume = false
+            var successObserver: NSObjectProtocol?
+            var failObserver: NSObjectProtocol?
+
+            func cleanup() {
+                if let successObserver = successObserver { center.removeObserver(successObserver) }
+                if let failObserver = failObserver { center.removeObserver(failObserver) }
+            }
+
+            func isForThisModel(_ note: Notification) -> Bool {
+                guard let downloaded = note.userInfo?[ModelDownloadUserInfoKey.remoteModel.rawValue] as? NSObject else {
+                    return false
+                }
+                return downloaded.isEqual(model)
+            }
+
+            successObserver = center.addObserver(forName: .mlkitModelDownloadDidSucceed,
+                                                 object: nil, queue: .main) { note in
+                guard !didResume, isForThisModel(note) else { return }
+                didResume = true
+                cleanup()
+                continuation.resume()
+            }
+
+            failObserver = center.addObserver(forName: .mlkitModelDownloadDidFail,
+                                              object: nil, queue: .main) { note in
+                guard !didResume, isForThisModel(note) else { return }
+                didResume = true
+                cleanup()
+                let err = note.userInfo?[ModelDownloadUserInfoKey.error.rawValue] as? Error
+                continuation.resume(throwing: err ?? RuntimeError.error(
+                    withMessage: "Failed to download digital-ink model"))
+            }
+
+            // Kicks off the download; progress is reported via the observed notifications.
+            _ = self.modelManager.download(model, conditions: conditions)
+        }
+    }
+
+    // MARK: - Protocol methods
+
+    func recognize(strokes: [InkStroke], languageTag: String) throws -> Promise<[RecognitionCandidate]> {
+        return Promise.async {
+            let model = try self.model(for: languageTag)
+            try await self.awaitModelDownload(model, conditions: ModelDownloadConditions())
+
+            let options = DigitalInkRecognizerOptions(model: model)
+            let recognizer = DigitalInkRecognizer.digitalInkRecognizer(options: options)
+            let ink = self.buildInk(from: strokes)
+
+            return try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<[RecognitionCandidate], Error>) in
+                recognizer.recognize(ink: ink) { result, error in
+                    if let error = error {
+                        continuation.resume(throwing: error)
+                    } else {
+                        let candidates = (result?.candidates ?? []).map {
+                            RecognitionCandidate(text: $0.text, score: $0.score?.doubleValue)
+                        }
+                        continuation.resume(returning: candidates)
+                    }
+                }
+            }
+        }
+    }
+
+    func downloadModel(languageTag: String) throws -> Promise<Void> {
+        return Promise.async {
+            let model = try self.model(for: languageTag)
+            try await self.awaitModelDownload(model, conditions: ModelDownloadConditions())
+        }
+    }
+
+    func isModelDownloaded(languageTag: String) throws -> Promise<Bool> {
+        return Promise.async {
+            let model = try self.model(for: languageTag)
+            // `isModelDownloaded(_:)` is synchronous on iOS.
+            return self.modelManager.isModelDownloaded(model)
+        }
+    }
+
+    func deleteModel(languageTag: String) throws -> Promise<Void> {
+        return Promise.async {
+            let model = try self.model(for: languageTag)
+            try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+                self.modelManager.deleteDownloadedModel(model) { error in
+                    if let error = error {
+                        continuation.resume(throwing: error)
+                    } else {
+                        continuation.resume()
+                    }
+                }
+            }
+        }
+    }
+
+    func isAvailable() throws -> Bool {
+        return true
+    }
+}

package/nitro.json

@@ -0,0 +1,16 @@
+{
+  "cxxNamespace": ["mlkit", "digitalink"],
+  "ios": {
+    "iosModuleName": "NitroMLKitDigitalInk"
+  },
+  "android": {
+    "androidNamespace": ["nitromlkit", "digitalink"],
+    "androidCxxLibName": "NitroMLKitDigitalInk"
+  },
+  "autolinking": {
+    "DigitalInkRecognizer": {
+      "ios": { "language": "swift", "implementationClassName": "HybridDigitalInkRecognizer" },
+      "android": { "language": "kotlin", "implementationClassName": "HybridDigitalInkRecognizer" }
+    }
+  }
+}

package/nitrogen/generated/.gitattributes

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

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

@@ -0,0 +1,81 @@
+#
+# NitroMLKitDigitalInk+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/NitroMLKitDigitalInk+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_NITROMLKITDIGITALINK_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)
+  NitroMLKitDigitalInk PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/NitroMLKitDigitalInkOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridDigitalInkRecognizerSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridDigitalInkRecognizerSpec.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(
+  NitroMLKitDigitalInk 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(
+        NitroMLKitDigitalInk
+        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(
+        NitroMLKitDigitalInk
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        NitroMLKitDigitalInk
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

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

@@ -0,0 +1,27 @@
+///
+/// NitroMLKitDigitalInk+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/NitroMLKitDigitalInk+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 NitroMLKitDigitalInk is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}