react-native-lingua 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 hej
+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/Lingua.podspec

@@ -0,0 +1,21 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "Lingua"
+  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 }
+  s.source       = { :git => "https://github.com/Hkmu/react-native-lingua/.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}", "cpp/**/*.{hpp,cpp,c,h}"
+  s.private_header_files = "ios/**/*.h"
+  s.vendored_frameworks = "ios/*.xcframework"
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,254 @@
+# react-native-lingua
+
+An accurate natural language detection library for React Native, powered by [lingua-rs](https://github.com/pemistahl/lingua-rs).
+
+## Features
+
+- 🎯 **Highly Accurate**: Uses advanced n-gram models (1-5) for superior detection accuracy
+- 📦 **75 Languages**: Supports detection of 75 languages
+- ⚡ **Fast**: Built with Rust and JSI for optimal performance
+- 🔒 **Type-Safe**: Full TypeScript support
+- 📱 **Cross-Platform**: Works on iOS and Android
+- 🌐 **Offline**: No internet connection required
+
+## Installation
+
+### Prerequisites
+
+The native libraries are built automatically during installation. You'll need:
+
+1. **Rust toolchain**:
+```sh
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+2. **cargo-ndk** (for Android):
+```sh
+cargo install cargo-ndk
+```
+
+3. **Android NDK** (for Android):
+   - Recommended version: 26.1.10909125
+   - Set environment variables:
+   ```sh
+   export ANDROID_SDK_ROOT=$HOME/Library/Android/sdk
+   export ANDROID_HOME=$HOME/Library/Android/sdk
+   export ANDROID_NDK_HOME=$ANDROID_HOME/ndk/26.1.10909125
+   ```
+
+4. **Xcode** (for iOS on macOS)
+
+### Install the Package
+
+```sh
+pnpm add react-native-lingua
+# or
+npm install react-native-lingua
+# or
+yarn add react-native-lingua
+```
+
+The native libraries will be built automatically during `postinstall`.
+
+### iOS Setup
+
+```sh
+cd ios && pod install
+```
+
+### Android Setup
+
+No additional steps required.
+
+## Manual Build (Optional)
+
+If you need to rebuild the native libraries manually:
+
+```sh
+cd node_modules/react-native-lingua
+npm run build:rust
+```
+
+## Usage
+
+### Basic Language Detection
+
+```typescript
+import {
+  createDetectorForAllLanguages,
+  createDetectorForLanguages,
+  detectLanguage,
+} from 'react-native-lingua';
+
+// Create a detector for all supported languages
+const detector = createDetectorForAllLanguages();
+
+// Detect language
+const language = detectLanguage(detector, 'Hello, how are you?');
+console.log(language); // 'en'
+
+// Or create a detector for specific languages (faster and more accurate)
+const specificDetector = createDetectorForLanguages(['en', 'fr', 'de', 'es']);
+const lang = detectLanguage(specificDetector, 'Bonjour le monde');
+console.log(lang); // 'fr'
+```
+
+### Language Confidence
+
+Get confidence scores to understand how certain the detection is:
+
+```typescript
+import {
+  createDetectorForLanguages,
+  computeLanguageConfidence,
+  computeLanguageConfidenceValues,
+} from 'react-native-lingua';
+
+const detector = createDetectorForLanguages(['en', 'fr', 'de', 'es']);
+
+// Get confidence for a specific language
+const confidence = computeLanguageConfidence(detector, 'Hello world', 'en');
+console.log(confidence); // 0.95
+
+// Get confidence values for all languages
+const confidences = computeLanguageConfidenceValues(detector, 'Hello world');
+
+console.log(confidences);
+// [
+//   { language: 'en', confidence: 0.95 },
+//   { language: 'fr', confidence: 0.03 },
+//   { language: 'de', confidence: 0.01 },
+//   { language: 'es', confidence: 0.01 }
+// ]
+```
+
+### Supported Languages
+
+The library supports 75 languages using ISO 639-1 codes. Some examples:
+
+```typescript
+const commonLanguages = [
+  'en', // English
+  'es', // Spanish
+  'fr', // French
+  'de', // German
+  'it', // Italian
+  'pt', // Portuguese
+  'ru', // Russian
+  'ja', // Japanese
+  'zh', // Chinese
+  'ko', // Korean
+  'ar', // Arabic
+  'hi', // Hindi
+  // ... and 63 more
+];
+```
+
+For a complete list of supported languages, see the [lingua-rs documentation](https://docs.rs/lingua/latest/lingua/enum.Language.html).
+
+## API Reference
+
+### `createDetectorForAllLanguages()`
+
+Creates a language detector that can detect any of the 75 supported languages.
+
+**Returns:** `LanguageDetector`
+
+**Note:** Loading all languages consumes significant memory (~1 GB). Consider using `createDetectorForLanguages()` if you know which languages to expect.
+
+### `createDetectorForLanguages(languages: string[])`
+
+Creates a language detector for specific languages.
+
+**Parameters:**
+
+- `languages: string[]` - Array of ISO 639-1 language codes
+
+**Returns:** `LanguageDetector`
+
+**Example:**
+
+```typescript
+const detector = createDetectorForLanguages(['en', 'fr', 'de']);
+```
+
+### `detectLanguage(detector: LanguageDetector, text: string)`
+
+Detects the language of the given text.
+
+**Parameters:**
+
+- `detector: LanguageDetector` - Language detector instance
+- `text: string` - Text to analyze
+
+**Returns:** `string | null` - ISO 639-1 language code or null if detection failed
+
+**Example:**
+
+```typescript
+const lang = detectLanguage(detector, 'Hello world'); // 'en'
+```
+
+### `computeLanguageConfidence(detector: LanguageDetector, text: string, languageCode: string)`
+
+Computes the confidence value for a specific language.
+
+**Parameters:**
+
+- `detector: LanguageDetector` - Language detector instance
+- `text: string` - Text to analyze
+- `languageCode: string` - ISO 639-1 language code
+
+**Returns:** `number` - Confidence value between 0.0 and 1.0
+
+**Example:**
+
+```typescript
+const confidence = computeLanguageConfidence(detector, 'Hello world', 'en'); // 0.95
+```
+
+### `computeLanguageConfidenceValues(detector: LanguageDetector, text: string)`
+
+Computes confidence values for all languages in the detector.
+
+**Parameters:**
+
+- `detector: LanguageDetector` - Language detector instance
+- `text: string` - Text to analyze
+
+**Returns:** `LanguageConfidence[]` - Array of `{ language: string, confidence: number }` sorted by confidence (descending)
+
+**Example:**
+
+```typescript
+const confidences = computeLanguageConfidenceValues(detector, 'Hello');
+// [{ language: 'en', confidence: 0.95 }, ...]
+```
+
+## Performance Tips
+
+1. **Use specific languages**: Create detectors with only the languages you need for better performance and accuracy
+2. **Reuse detectors**: Create detector instances once and reuse them
+3. **Memory usage**: The detector with all languages uses ~1 GB of memory. Use specific language sets to reduce memory footprint
+
+## How It Works
+
+This library wraps the Rust [lingua-rs](https://github.com/pemistahl/lingua-rs) library using:
+
+1. **Rust FFI**: C-compatible FFI bindings for the lingua library
+2. **C++ JSI**: JavaScript Interface for direct communication with JavaScript
+3. **React Native TurboModule**: Modern architecture for optimal performance
+
+The detection uses both rule-based and statistical Naive Bayes methods with n-grams of sizes 1-5, providing high accuracy even for short text snippets.
+
+## Contributing
+
+See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/CMakeLists.txt

@@ -0,0 +1,55 @@
+cmake_minimum_required(VERSION 3.9.0)
+project(lingua)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Find all C++ files
+file(GLOB_RECURSE cpp_files RELATIVE ${CMAKE_SOURCE_DIR}
+  "../cpp/**.cpp"
+  "../cpp/**.h"
+)
+
+add_library(${CMAKE_PROJECT_NAME} SHARED
+  ${cpp_files}
+  cpp-adapter.cpp
+)
+
+# Specifies a path to native header files
+include_directories(
+  ../cpp
+  ../rust/generated/include
+)
+
+# Link the lingua_native static library
+cmake_path(SET LINGUA_LIB_PATH ${CMAKE_CURRENT_SOURCE_DIR}/jniLibs/${ANDROID_ABI}/liblingua_native.a NORMALIZE)
+add_library(lingua_native STATIC IMPORTED)
+set_target_properties(lingua_native PROPERTIES IMPORTED_LOCATION ${LINGUA_LIB_PATH})
+
+target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src/main/jni/include)
+
+find_library(LOG_LIB log)
+find_package(ReactAndroid REQUIRED CONFIG)
+find_package(fbjni REQUIRED CONFIG)
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+  target_link_libraries(
+    ${CMAKE_PROJECT_NAME}
+    lingua_native
+    ${LOG_LIB}
+    ReactAndroid::reactnative
+    ReactAndroid::jsi
+    fbjni::fbjni
+  )
+else()
+  target_link_libraries(
+    ${CMAKE_PROJECT_NAME}
+    ${LOG_LIB}
+    lingua_native
+    fbjni::fbjni
+    ReactAndroid::jsi
+    ReactAndroid::turbomodulejsijni
+    ReactAndroid::react_nativemodule_core
+    android
+  )
+endif()

package/android/build.gradle

@@ -0,0 +1,94 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Lingua_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Lingua_" + name]).toInteger()
+}
+
+android {
+  namespace "com.lingua"
+
+  ndkVersion = "26.1.10909125"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-O2 -frtti -fexceptions -Wall -Wno-unused-variable -fstack-protector-all"
+        abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
+        arguments '-DANDROID_STL=c++_shared'
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  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 {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}

package/android/cpp-adapter.cpp

@@ -0,0 +1,36 @@
+#include "lingua.h"
+#include <ReactCommon/CallInvokerHolder.h>
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <jsi/jsi.h>
+#include <typeinfo>
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+namespace jni = facebook::jni;
+
+// This file uses fbjni for cleaner JNI bindings
+struct LinguaModule : jni::JavaClass<LinguaModule> {
+  static constexpr auto kJavaDescriptor = "Lcom/lingua/LinguaModule;";
+
+  static void registerNatives() {
+    javaClassStatic()->registerNatives({
+        makeNativeMethod("installNativeJsi", LinguaModule::installNativeJsi),
+    });
+  }
+
+private:
+  static void
+  installNativeJsi(jni::alias_ref<jni::JObject> thiz, jlong jsiRuntimePtr,
+                   jni::alias_ref<react::CallInvokerHolder::javaobject>
+                       jsCallInvokerHolder) {
+    auto jsiRuntime = reinterpret_cast<jsi::Runtime *>(jsiRuntimePtr);
+    auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
+
+    lingua::install(*jsiRuntime, jsCallInvoker);
+  }
+};
+
+JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *) {
+  return jni::initialize(vm, [] { LinguaModule::registerNatives(); });
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+Lingua_kotlinVersion=2.0.21
+Lingua_minSdkVersion=24
+Lingua_targetSdkVersion=34
+Lingua_compileSdkVersion=35
+Lingua_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/java/com/lingua/JNIOnLoad.kt

@@ -0,0 +1,20 @@
+package com.lingua
+
+import android.util.Log
+
+object JNIOnLoad {
+  private const val TAG = "Lingua"
+  private var isInitialized = false
+
+  @Synchronized
+  fun initializeNative() {
+    if (isInitialized) return
+    try {
+      System.loadLibrary("lingua")
+      isInitialized = true
+    } catch (e: Throwable) {
+      Log.e(TAG, "Failed to load lingua native library.", e)
+      throw e
+    }
+  }
+}

package/android/src/main/java/com/lingua/LinguaModule.kt

@@ -0,0 +1,51 @@
+package com.lingua
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+
+@DoNotStrip
+@Keep
+@OptIn(FrameworkAPI::class)
+@Suppress("KotlinJniMissingFunction")
+@ReactModule(name = LinguaModule.NAME)
+class LinguaModule(reactContext: ReactApplicationContext) :
+  NativeLinguaSpec(reactContext) {
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun install(): String? {
+    try {
+      // Get jsi::Runtime pointer
+      val jsContext = reactApplicationContext.javaScriptContextHolder
+        ?: return "ReactApplicationContext.javaScriptContextHolder is null!"
+
+      // Get CallInvokerHolder
+      val callInvokerHolder = reactApplicationContext.jsCallInvokerHolder as? CallInvokerHolderImpl
+        ?: return "ReactApplicationContext.jsCallInvokerHolder is null!"
+
+      installNativeJsi(jsContext.get(), callInvokerHolder)
+
+      return null
+    } catch (e: Throwable) {
+      return e.message
+    }
+  }
+
+  private external fun installNativeJsi(jsRuntimePointer: Long, callInvokerHolder: CallInvokerHolderImpl)
+
+  companion object {
+    const val NAME = "Lingua"
+
+    init {
+      JNIOnLoad.initializeNative()
+    }
+  }
+}

package/android/src/main/java/com/lingua/LinguaPackage.kt

@@ -0,0 +1,33 @@
+package com.lingua
+
+import com.facebook.react.BaseReactPackage
+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
+import java.util.HashMap
+
+class LinguaPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == LinguaModule.NAME) {
+      LinguaModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[LinguaModule.NAME] = ReactModuleInfo(
+        LinguaModule.NAME,
+        LinguaModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/jni/include/liblingua.h

@@ -0,0 +1,65 @@
+#ifndef lingua_h
+#define lingua_h
+
+/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
+
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+namespace lingua {
+
+struct LinguaDetector;
+
+/// Result structure for confidence values
+struct ConfidenceValue {
+  char *language_code;
+  double confidence;
+};
+
+extern "C" {
+
+void set_error(const char **err, const str *error_message);
+
+const char *get_error();
+
+/// Creates a language detector with all languages
+LinguaDetector *lingua_detector_create_all();
+
+/// Creates a language detector with specific languages
+/// languages: comma-separated ISO 639-1 codes (e.g., "en,fr,de,es")
+LinguaDetector *lingua_detector_create_from_languages(const char *languages, const char **error);
+
+/// Detects the language of the given text
+/// Returns the ISO 639-1 code (e.g., "en") or null if detection failed
+char *lingua_detect_language(const LinguaDetector *detector, const char *text, const char **error);
+
+/// Computes the confidence value for a specific language
+double lingua_compute_language_confidence(const LinguaDetector *detector,
+                                          const char *text,
+                                          const char *language_code,
+                                          const char **error);
+
+/// Computes confidence values for all languages
+/// Returns an array of ConfidenceValue structs and sets the count
+ConfidenceValue *lingua_compute_language_confidence_values(const LinguaDetector *detector,
+                                                           const char *text,
+                                                           int *count,
+                                                           const char **error);
+
+/// Frees a string allocated by lingua
+void lingua_free_string(char *s);
+
+/// Frees the confidence values array
+void lingua_free_confidence_values(ConfidenceValue *values, int count);
+
+/// Destroys the detector and frees memory
+void lingua_detector_destroy(LinguaDetector *detector);
+
+} // extern "C"
+
+} // namespace lingua
+
+#endif // lingua_h