react-native-lingua 0.1.0 → 0.1.2

package/Lingua.podspec

@@ -17,5 +17,48 @@ Pod::Spec.new do |s|
   s.private_header_files = "ios/**/*.h"
   s.vendored_frameworks = "ios/*.xcframework"
 
+  # Build Rust library from source during pod install
+  s.prepare_command = <<-CMD
+    set -e
+
+    # Check if Rust is installed
+    if ! command -v cargo &> /dev/null; then
+      echo "❌ Error: Rust is not installed."
+      echo "Please install Rust: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh"
+      exit 1
+    fi
+
+    # Check if iOS targets are installed
+    if ! rustup target list --installed | grep -q "aarch64-apple-ios"; then
+      echo "❌ Error: iOS Rust targets not installed."
+      echo "Please run: rustup target add aarch64-apple-ios aarch64-apple-ios-sim"
+      exit 1
+    fi
+
+    # Build the xcframework
+    cd rust
+    make header
+
+    # Build for iOS targets
+    echo "Building Rust library for iOS..."
+    cargo build --release --target aarch64-apple-ios
+    cargo build --release --target aarch64-apple-ios-sim
+
+    # Create xcframework
+    mkdir -p generated/include
+    xcodebuild -create-xcframework \
+      -library target/aarch64-apple-ios/release/liblingua_native.a \
+      -headers generated/include \
+      -library target/aarch64-apple-ios-sim/release/liblingua_native.a \
+      -headers generated/include \
+      -output generated/liblingua_native.xcframework
+
+    # Copy to ios directory
+    cp -rf generated/*.xcframework ../ios/
+    cp -f generated/include/liblingua.h ../cpp/
+
+    echo "✅ Rust library built successfully"
+  CMD
+
   install_modules_dependencies(s)
 end

package/android/build.gradle

@@ -86,6 +86,30 @@ repositories {
   google()
 }
 
+// Build Rust library before native build
+task buildRustHeader(type: Exec) {
+  workingDir file("${projectDir}/../rust")
+  commandLine 'make', 'header'
+
+  // Always run to ensure header is up to date
+}
+
+task buildRust(type: Exec) {
+  workingDir file("${projectDir}/../rust")
+  commandLine 'make', 'android'
+
+  // Only run if jniLibs don't exist
+  onlyIf {
+    !file("${projectDir}/jniLibs/arm64-v8a/liblingua_native.a").exists()
+  }
+
+  dependsOn buildRustHeader
+}
+
+tasks.matching { it.name.startsWith('externalNativeBuild') }.configureEach {
+  dependsOn buildRust
+}
+
 def kotlin_version = getExtOrDefault("kotlinVersion")
 
 dependencies {

package/cpp/lingua.cpp

@@ -1,6 +1,6 @@
 #include "lingua.h"
+#include "liblingua.h"
 #include "macros.h"
-#include <liblingua.h>
 #include <string>
 #include <vector>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-lingua",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A lingua-rs wrapper for React Native",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -16,8 +16,13 @@
     "src",
     "lib",
     "android",
-    "ios",
+    "ios/*.{h,mm}",
     "cpp",
+    "rust/src",
+    "rust/Cargo.toml",
+    "rust/build.rs",
+    "rust/Makefile",
+    "rust/rust-toolchain.toml",
     "*.podspec",
     "react-native.config.js",
     "!ios/build",
@@ -26,10 +31,13 @@
     "!android/gradlew",
     "!android/gradlew.bat",
     "!android/local.properties",
+    "!cpp/liblingua.h",
     "!**/__tests__",
     "!**/__fixtures__",
     "!**/__mocks__",
-    "!**/.*"
+    "!**/.*",
+    "README.md",
+    "LICENSE"
   ],
   "workspaces": [
     "example"
@@ -158,7 +166,6 @@
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
     "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
     "build:rust": "cd rust && make all",
-    "postinstall": "npm run build:rust || echo 'Warning: Rust build failed. Pre-built binaries may be needed.'",
     "release": "release-it --only-version"
   }
 }

package/rust/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "lingua_native"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "lingua_native"
+crate-type = ["staticlib", "cdylib"]
+
+[dependencies]
+lingua = "1.7.2"
+libc = "0.2"
+lazy_static = "1.4"
+
+[build-dependencies]
+cbindgen = "0.26.0"

package/rust/Makefile

@@ -0,0 +1,88 @@
+ARCHS_IOS = aarch64-apple-ios aarch64-apple-ios-sim
+ARCHS_ANDROID = aarch64-linux-android armv7-linux-androideabi x86_64-linux-android i686-linux-android
+LIB_FILE = liblingua_native.a
+DYLIB = liblingua_native.so
+XCFRAMEWORK = liblingua_native.xcframework
+
+all: ios android
+
+# Generate header only (fast, for development)
+header:
+	mkdir -p generated/include
+	cargo build --lib
+	cp -f generated/include/liblingua.h ../cpp/
+	@echo "✅ Header generated and copied to cpp/"
+
+ios: clean header ios-build package-xcframework copy-ios notify
+
+android: header android-build copy-android notify
+
+notify:
+	@echo "🟢 Build Completed!"
+
+lint:
+	cargo clippy --all-features --all-targets -- --no-deps -D warnings
+
+fix:
+	cargo clippy --all-targets --all-features --fix --allow-dirty --allow-staged
+	cargo fmt --all
+
+clean:
+	rm -rf generated/$(XCFRAMEWORK)
+	rm -rf ../ios/$(XCFRAMEWORK)
+
+# iOS Build
+
+.PHONY: $(ARCHS_IOS)
+$(ARCHS_IOS): %:
+	cargo build --target $@ --release
+
+package-xcframework: $(ARCHS_IOS)
+	mkdir -p generated/include
+	xcodebuild -create-xcframework \
+		-library target/aarch64-apple-ios/release/$(LIB_FILE) \
+		-headers generated/include \
+		-library target/aarch64-apple-ios-sim/release/$(LIB_FILE) \
+		-headers generated/include \
+		-output generated/$(XCFRAMEWORK)
+
+copy-ios:
+	cp -rf generated/*.xcframework ../ios
+	cp -f generated/include/liblingua.h ../cpp/
+	@echo "✅ iOS xcframework and headers copied"
+
+ios-build:
+	cargo build --release --target aarch64-apple-ios
+	cargo build --release --target aarch64-apple-ios-sim
+
+# Android Build
+
+.PHONY: $(ARCHS_ANDROID)
+$(ARCHS_ANDROID): %:
+	cargo ndk --target $@ --platform 31 build --release
+
+android-build:
+	cargo ndk --target aarch64-linux-android --platform 31 build --release
+	cargo ndk --target armv7-linux-androideabi --platform 31 build --release
+	cargo ndk --target i686-linux-android --platform 31 build --release
+	cargo ndk --target x86_64-linux-android --platform 31 build --release
+
+copy-android:
+	# Copy header
+	mkdir -p ../android/src/main/jni/include
+	cp -rf generated/include/* ../android/src/main/jni/include
+	# Copy per architecture generated .a files
+	mkdir -p ../android/jniLibs/x86
+	cp target/i686-linux-android/release/$(LIB_FILE) ../android/jniLibs/x86
+
+	mkdir -p ../android/jniLibs/x86_64
+	cp target/x86_64-linux-android/release/$(LIB_FILE) ../android/jniLibs/x86_64
+
+	mkdir -p ../android/jniLibs/armeabi-v7a
+	cp target/armv7-linux-androideabi/release/$(LIB_FILE) ../android/jniLibs/armeabi-v7a
+
+	mkdir -p ../android/jniLibs/arm64-v8a
+	cp target/aarch64-linux-android/release/$(LIB_FILE) ../android/jniLibs/arm64-v8a
+	@echo "✅ Android libraries copied"
+
+.PHONY: all ios android clean notify lint fix ios-build android-build copy-ios copy-android package-xcframework header

package/rust/build.rs

@@ -0,0 +1,31 @@
+extern crate cbindgen;
+
+use std::env;
+
+fn generate_c_headers() {
+    let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let header_path = "generated/include/liblingua.h";
+
+    cbindgen::Builder::new()
+        .with_crate(crate_dir)
+        .with_language(cbindgen::Language::Cxx)
+        .with_include_guard("lingua_h")
+        .with_autogen_warning(
+            "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */",
+        )
+        .with_namespace("lingua")
+        .with_cpp_compat(true)
+        .generate()
+        .expect("Unable to generate bindings")
+        .write_to_file(header_path);
+}
+
+fn main() {
+    // Tell Cargo that if the given file changes, to rerun this build script.
+    println!("cargo:rerun-if-changed=src/lib.rs");
+
+    if std::env::var("CARGO_CFG_CLIPPY").is_err() {
+        // Only run cbindgen if not running cargo clippy
+        generate_c_headers();
+    }
+}

package/rust/rust-toolchain.toml

@@ -0,0 +1,11 @@
+[toolchain]
+channel = "stable"
+targets = [
+  "x86_64-apple-ios",
+  "aarch64-apple-ios",
+  "aarch64-apple-ios-sim",
+  "aarch64-linux-android",
+  "armv7-linux-androideabi",
+  "x86_64-linux-android",
+  "i686-linux-android",
+]

package/rust/src/lib.rs

@@ -0,0 +1,264 @@
+use lingua::{IsoCode639_1, Language, LanguageDetector, LanguageDetectorBuilder};
+use std::ffi::{c_char, CStr, CString};
+use std::os::raw::c_int;
+use std::ptr;
+use std::str::FromStr;
+use std::sync::Mutex;
+
+lazy_static::lazy_static! {
+    static ref GLOBAL_ERROR: Mutex<Option<String>> = Mutex::new(None);
+}
+
+// Error handling
+// Helper function for internal use
+unsafe fn set_error_internal(err: *mut *const c_char, error_message: &str) {
+    let mut global_error = GLOBAL_ERROR.lock().unwrap();
+    *global_error = Some(error_message.to_string());
+
+    if !err.is_null() {
+        // Point to the stored error string in GLOBAL_ERROR
+        if let Some(ref error_str) = *global_error {
+            *err = error_str.as_ptr() as *const c_char;
+        }
+    }
+}
+
+// Exported C function (not actually used, but needed for header generation)
+#[no_mangle]
+pub unsafe extern "C" fn set_error(err: *mut *const c_char, error_message: *const c_char) {
+    if error_message.is_null() {
+        return;
+    }
+    let c_str = CStr::from_ptr(error_message);
+    if let Ok(s) = c_str.to_str() {
+        set_error_internal(err, s);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn get_error() -> *const c_char {
+    let global_error = GLOBAL_ERROR.lock().unwrap();
+    match &*global_error {
+        Some(err) => err.as_ptr() as *const c_char,
+        None => ptr::null(),
+    }
+}
+
+// LanguageDetector opaque pointer type
+pub struct LinguaDetector {
+    detector: LanguageDetector,
+}
+
+/// Creates a language detector with all languages
+#[no_mangle]
+pub extern "C" fn lingua_detector_create_all() -> *mut LinguaDetector {
+    let detector = LanguageDetectorBuilder::from_all_languages().build();
+    Box::into_raw(Box::new(LinguaDetector { detector }))
+}
+
+/// Creates a language detector with specific languages
+/// languages: comma-separated ISO 639-1 codes (e.g., "en,fr,de,es")
+#[no_mangle]
+pub unsafe extern "C" fn lingua_detector_create_from_languages(
+    languages: *const c_char,
+    error: *mut *const c_char,
+) -> *mut LinguaDetector {
+    if languages.is_null() {
+        set_error_internal(error, "languages parameter is null");
+        return ptr::null_mut();
+    }
+
+    let c_str = CStr::from_ptr(languages);
+    let lang_str = match c_str.to_str() {
+        Ok(s) => s,
+        Err(_) => {
+            set_error_internal(error, "Invalid UTF-8 in languages parameter");
+            return ptr::null_mut();
+        }
+    };
+
+    let lang_codes: Vec<&str> = lang_str.split(',').map(|s| s.trim()).collect();
+    let mut selected_iso_codes = Vec::new();
+
+    for code in lang_codes {
+        let upper_code = code.to_uppercase();
+        match IsoCode639_1::from_str(&upper_code) {
+            Ok(iso_code) => selected_iso_codes.push(iso_code),
+            Err(_) => {
+                let error_msg = format!("Invalid language code: {}", code);
+                set_error_internal(error, &error_msg);
+                return ptr::null_mut();
+            }
+        }
+    }
+
+    if selected_iso_codes.is_empty() {
+        set_error_internal(error, "No valid languages provided");
+        return ptr::null_mut();
+    }
+
+    let detector = LanguageDetectorBuilder::from_iso_codes_639_1(&selected_iso_codes).build();
+    Box::into_raw(Box::new(LinguaDetector { detector }))
+}
+
+/// Detects the language of the given text
+/// Returns the ISO 639-1 code (e.g., "en") or null if detection failed
+#[no_mangle]
+pub unsafe extern "C" fn lingua_detect_language(
+    detector: *const LinguaDetector,
+    text: *const c_char,
+    error: *mut *const c_char,
+) -> *mut c_char {
+    if detector.is_null() {
+        set_error_internal(error, "detector is null");
+        return ptr::null_mut();
+    }
+
+    if text.is_null() {
+        set_error_internal(error, "text is null");
+        return ptr::null_mut();
+    }
+
+    let detector = &(*detector).detector;
+    let c_str = CStr::from_ptr(text);
+    let text_str = match c_str.to_str() {
+        Ok(s) => s,
+        Err(_) => {
+            set_error_internal(error, "Invalid UTF-8 in text");
+            return ptr::null_mut();
+        }
+    };
+
+    match detector.detect_language_of(text_str) {
+        Some(language) => {
+            let iso_code = language.iso_code_639_1().to_string().to_lowercase();
+            match CString::new(iso_code) {
+                Ok(c_string) => c_string.into_raw(),
+                Err(_) => {
+                    set_error_internal(error, "Failed to create C string");
+                    ptr::null_mut()
+                }
+            }
+        }
+        None => ptr::null_mut(),
+    }
+}
+
+/// Computes the confidence value for a specific language
+#[no_mangle]
+pub unsafe extern "C" fn lingua_compute_language_confidence(
+    detector: *const LinguaDetector,
+    text: *const c_char,
+    language_code: *const c_char,
+    error: *mut *const c_char,
+) -> f64 {
+    if detector.is_null() || text.is_null() || language_code.is_null() {
+        set_error_internal(error, "null parameter");
+        return 0.0;
+    }
+
+    let detector = &(*detector).detector;
+    let text_str = CStr::from_ptr(text).to_str().unwrap_or("");
+    let lang_str = CStr::from_ptr(language_code).to_str().unwrap_or("");
+
+    // Convert the ISO code string to a Language enum
+    // We need to iterate through all possible languages and match
+    let all_languages = Language::all();
+    let language = all_languages
+        .into_iter()
+        .find(|lang| {
+            lang.iso_code_639_1()
+                .to_string()
+                .eq_ignore_ascii_case(lang_str)
+        })
+        .unwrap_or_else(|| {
+            set_error_internal(error, "Invalid language code");
+            Language::English // Default fallback, but we return 0.0 anyway
+        });
+
+    if language == Language::English && !lang_str.eq_ignore_ascii_case("en") {
+        return 0.0; // Error was already set
+    }
+
+    detector.compute_language_confidence(text_str, language)
+}
+
+/// Result structure for confidence values
+#[repr(C)]
+pub struct ConfidenceValue {
+    pub language_code: *mut c_char,
+    pub confidence: f64,
+}
+
+/// Computes confidence values for all languages
+/// Returns an array of ConfidenceValue structs and sets the count
+#[no_mangle]
+pub unsafe extern "C" fn lingua_compute_language_confidence_values(
+    detector: *const LinguaDetector,
+    text: *const c_char,
+    count: *mut c_int,
+    error: *mut *const c_char,
+) -> *mut ConfidenceValue {
+    if detector.is_null() || text.is_null() || count.is_null() {
+        set_error_internal(error, "null parameter");
+        return ptr::null_mut();
+    }
+
+    let detector = &(*detector).detector;
+    let text_str = match CStr::from_ptr(text).to_str() {
+        Ok(s) => s,
+        Err(_) => {
+            set_error_internal(error, "Invalid UTF-8");
+            return ptr::null_mut();
+        }
+    };
+
+    let confidence_values = detector.compute_language_confidence_values(text_str);
+    *count = confidence_values.len() as c_int;
+
+    let mut results: Vec<ConfidenceValue> = Vec::with_capacity(confidence_values.len());
+
+    for (language, confidence) in confidence_values {
+        let iso_code = language.iso_code_639_1().to_string().to_lowercase();
+        if let Ok(c_string) = CString::new(iso_code) {
+            results.push(ConfidenceValue {
+                language_code: c_string.into_raw(),
+                confidence,
+            });
+        }
+    }
+
+    let ptr = results.as_mut_ptr();
+    std::mem::forget(results);
+    ptr
+}
+
+/// Frees a string allocated by lingua
+#[no_mangle]
+pub unsafe extern "C" fn lingua_free_string(s: *mut c_char) {
+    if !s.is_null() {
+        let _ = CString::from_raw(s);
+    }
+}
+
+/// Frees the confidence values array
+#[no_mangle]
+pub unsafe extern "C" fn lingua_free_confidence_values(values: *mut ConfidenceValue, count: c_int) {
+    if !values.is_null() {
+        for i in 0..count {
+            let value = &mut *values.offset(i as isize);
+            if !value.language_code.is_null() {
+                let _ = CString::from_raw(value.language_code);
+            }
+        }
+        let _ = Vec::from_raw_parts(values, count as usize, count as usize);
+    }
+}
+
+/// Destroys the detector and frees memory
+#[no_mangle]
+pub unsafe extern "C" fn lingua_detector_destroy(detector: *mut LinguaDetector) {
+    if !detector.is_null() {
+        let _ = Box::from_raw(detector);
+    }
+}