wasm-ffi demo | whatlang-rs

Detected Language:

English

Confidence: 100.0%

Portuguese Korean German Russian Italian English

Under the hood →

The main WebAssembly export here is detect, which takes a string pointer and gives back a pointer to a DetectResult struct. This function gets called each time the textarea is updated.

wasm-ffi wraps the call to detect. It writes the input string to memory before calling the WebAssembly function and it returns an object that can access the struct fields.

	const $ = sel => document.querySelector(sel);
	const textarea = $('textarea');

	const DetectResult = new ffi.Struct({
	lang: ffi.rust.string,
	confidence: 'f64',
	is_reliable: 'bool',
	});

	const whatlang = new ffi.Wrapper({
	detect: [DetectResult, ['string']],
	});

	whatlang.fetch('whatlang.wasm').then(() => {
	function update(str) {
	const result = whatlang.detect(str);

	$('#language').innerText = result.lang.value;
	$('#reliable').className = (result.is_reliable) ? 'yes' : 'no';

	$('#confidence').innerText = (result.confidence * 100).toFixed(1) + '%';
	$('#bar').value = result.confidence * 100;
	}

	textarea.addEventListener('input', () => update(textarea.value));

	use std::cell::RefCell;
	use std::ffi::CStr;
	use std::os::raw::{c_char, c_void};

	extern crate whatlang;

	thread_local!(
	static RESULT: RefCell<Option<DetectResult>> = RefCell::new(None);
	);

	#[repr(C)]
	pub struct DetectResult {
	lang: String,
	confidence: f64,
	is_reliable: bool,
	}

	#[no_mangle]
	pub fn detect(ptr: const c_char) -> const DetectResult {
	RESULT.with(\|cell\| {
	let mut wrapper = cell.borrow_mut();

	let input = unsafe {
	assert!(!ptr.is_null());
	CStr::from_ptr(ptr).to_string_lossy()
	};

	let info_result = whatlang::detect(&input);

	if let Some(info) = info_result {
	*wrapper = Some(DetectResult {
	lang: info.lang().eng_name().to_string(),
	confidence: info.confidence(),
	is_reliable: info.is_reliable(),
	});
	} else {
	*wrapper = Some(DetectResult {
	lang: String::from("-----"),
	confidence: 0.0,
	is_reliable: false,
	});
	}

	let result = wrapper.as_ref().unwrap();
	&result as const DetectResult
	})
	}

	#[no_mangle]
	pub fn allocate(length: usize) -> *mut c_void {
	let mut v = Vec::with_capacity(length);
	let ptr = v.as_mut_ptr();
	std::mem::forget(v);
	ptr
	}

	#[no_mangle]
	pub fn deallocate(ptr: *mut c_void, length: usize) {
	unsafe {
	std::mem::drop(Vec::from_raw_parts(ptr, 0, length));
	}
	}