JS TextEncoder: encodeInto method

Signed-off-by: Didier Wenzek <[email protected]>

Author: didier-wenzek

crates/extensions/tedge_flows/src/js_lib/text_encoder.rs

@@ -1,7 +1,9 @@
 use rquickjs::class::Trace;
 use rquickjs::Class;
 use rquickjs::Ctx;
+use rquickjs::Exception;
 use rquickjs::JsLifetime;
+use rquickjs::Object;
 use rquickjs::Result;
 use rquickjs::TypedArray;
 use rquickjs::Value;
@@ -28,17 +30,62 @@ impl<'js> TextEncoder {
     }
 
     pub fn encode(&self, ctx: Ctx<'js>, text: Value<'js>) -> Result<TypedArray<'js, u8>> {
-        let string = match text.as_string() {
-            None => {
-                if let Some(object) = text.as_object() {
-                    if let Some(bytes) = object.as_typed_array::<u8>() {
-                        return Ok(bytes.clone());
-                    }
-                }
-                "".to_string()
+        let string = Self::string_from(text)?;
+        TypedArray::new(ctx.clone(), string.as_bytes())
+    }
+
+    #[qjs(rename = "encodeInto")]
+    pub fn encode_into(
+        &self,
+        ctx: Ctx<'js>,
+        text: Value<'js>,
+        array: TypedArray<'js, u8>,
+    ) -> Result<Object<'js>> {
+        let string = Self::string_from(text)?;
+        let offset: usize = array.get("byteOffset").unwrap_or_default();
+        let buffer = array
+            .arraybuffer()?
+            .as_raw()
+            .ok_or(Exception::throw_message(&ctx, "ArrayBuffer is detached"))?;
+
+        let mut read = 0;
+        let mut written = 0;
+        let max_len = buffer.len - offset;
+        for char in string.chars() {
+            let len = char.len_utf8();
+            if written + len > max_len {
+                break;
             }
+            read += char.len_utf16();
+            written += len;
+        }
+
+        let bytes = &string.as_bytes()[..written];
+        unsafe {
+            let buffer_ptr =
+                std::slice::from_raw_parts_mut(buffer.ptr.as_ptr().add(offset), written);
+            buffer_ptr.copy_from_slice(bytes);
+        }
+
+        let obj = Object::new(ctx)?;
+        obj.set("read", read)?;
+        obj.set("written", written)?;
+        Ok(obj)
+    }
+}
+
+impl TextEncoder {
+    pub fn string_from(text: Value<'_>) -> Result<String> {
+        let string = match text.as_string() {
+            None => text
+                .as_object()
+                .and_then(|object| object.as_typed_array::<u8>())
+                .and_then(|array| array.as_bytes())
+                .and_then(|bytes| std::str::from_utf8(bytes).ok())
+                .map(|s| s.to_string())
+                .unwrap_or_default(),
             Some(js_string) => js_string.to_string()?,
         };
-        TypedArray::new(ctx.clone(), string.as_bytes())
+        Ok(string)
     }
 }

crates/extensions/tedge_flows/src/js_script.rs

@@ -420,6 +420,31 @@ export async function onMessage(message, config) {
         );
     }
 
+    #[tokio::test]
+    async fn using_text_encoder_into() {
+        let js = r#"
+export async function onMessage(message, config) {
+    const utf8encoder = new TextEncoder();
+    const u8array = new Uint8Array(8);
+    const result = utf8encoder.encodeInto(message.payload, u8array);
+    console.log(result);
+    utf8encoder.encodeInto(message.payload, u8array.subarray(4));
+    return [{topic:"encoded", payload: u8array}];
+}
+        "#;
+        let (runtime, script) = runtime_with(js).await;
+
+        let input = Message::new("decoded", "💖");
+        let output = Message::new_binary("encoded", [240, 159, 146, 150, 240, 159, 146, 150]);
+        assert_eq!(
+            script
+                .on_message(&runtime, &DateTime::now(), &input)
+                .await
+                .unwrap(),
+            vec![output]
+        );
+    }
+
     #[tokio::test]
     async fn using_standard_built_in_objects() {
         let js = r#"