chore(y-octo): migrate away depracated JsExternal API (#12130)

<!-- This is an auto-generated comment: release notes by coderabbit.ai -->

## Summary by CodeRabbit

- **Refactor**
  - Updated usage of JavaScript interop types to newer API versions for improved compatibility and consistency.
  - Changed method and type signatures to use updated types in several areas.
  - Removed an unused constructor from one component.
  - Adjusted a method to use a different JavaScript array buffer type for update callbacks.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

packages/common/y-octo/node/src/array.rs

@@ -1,4 +1,7 @@
-use napi::{bindgen_prelude::Array as JsArray, Env, JsUnknown, ValueType};
+use napi::{
+  bindgen_prelude::{Array as JsArray, Env, Unknown},
+  ValueType,
+};
 use y_octo::{Any, Array, Value};
 
 use super::*;
@@ -104,7 +107,7 @@ impl YArray {
             Ok((object, length)) => {
               for i in 0..length {
                 if let Ok(any) = object
-                  .get_element::<JsUnknown>(i)
+                  .get_element::<Unknown>(i)
                   .and_then(get_any_from_js_unknown)
                 {
                   self

packages/common/y-octo/node/src/doc.rs

@@ -1,5 +1,5 @@
 use napi::{
-  bindgen_prelude::{Buffer, Uint8Array},
+  bindgen_prelude::Uint8Array,
   threadsafe_function::{ThreadsafeFunction, ThreadsafeFunctionCallMode},
 };
 use y_octo::{CrdtRead, Doc as YDoc, History, RawDecoder, StateVector};
@@ -120,7 +120,7 @@ impl Doc {
   }
 
   #[napi(ts_args_type = "callback: (result: Uint8Array) => void")]
-  pub fn on_update(&mut self, callback: ThreadsafeFunction<Buffer>) -> Result<()> {
+  pub fn on_update(&mut self, callback: ThreadsafeFunction<Uint8Array>) -> Result<()> {
     let callback = move |update: &[u8], _h: &[History]| {
       callback.call(
         Ok(update.to_vec().into()),

packages/common/y-octo/node/src/map.rs

@@ -1,4 +1,4 @@
-use napi::{Env, JsObject, ValueType};
+use napi::bindgen_prelude::{Env, Object, ValueType};
 use y_octo::{Any, Map, Value};
 
 use super::*;
@@ -10,12 +10,6 @@ pub struct YMap {
 
 #[napi]
 impl YMap {
-  #[allow(clippy::new_without_default)]
-  #[napi(constructor)]
-  pub fn new() -> Self {
-    unimplemented!()
-  }
-
   pub(crate) fn inner_new(map: Map) -> Self {
     Self { map }
   }
@@ -111,7 +105,7 @@ impl YMap {
   }
 
   #[napi]
-  pub fn to_json(&self, env: Env) -> Result<JsObject> {
+  pub fn to_json(&self, env: Env) -> Result<Object> {
     let mut js_object = env.create_object()?;
     for (key, value) in self.map.iter() {
       js_object.set(key, get_js_unknown_from_value(env, value))?;

packages/common/y-octo/node/src/utils.rs

@@ -1,12 +1,17 @@
-use napi::{bindgen_prelude::Either4, Env, Error, JsObject, JsUnknown, Result, Status, ValueType};
+use napi::{
+  bindgen_prelude::{
+    Either4, Env, Error, External, Object, Result, Status, ToNapiValue, Unknown, ValueType,
+  },
+  NapiValue,
+};
 use y_octo::{AHashMap, Any, HashMapExt, Value};
 
 use super::*;
 
-pub type MixedYType = Either4<YArray, YMap, YText, JsUnknown>;
+pub type MixedYType = Either4<YArray, YMap, YText, Unknown>;
-pub type MixedRefYType<'a> = Either4<&'a YArray, &'a YMap, &'a YText, JsUnknown>;
+pub type MixedRefYType<'a> = Either4<&'a YArray, &'a YMap, &'a YText, Unknown>;
 
-pub fn get_js_unknown_from_any(env: Env, any: Any) -> Result<JsUnknown> {
+pub fn get_js_unknown_from_any(env: Env, any: Any) -> Result<Unknown> {
   match any {
     Any::Null | Any::Undefined => env.get_null().map(|v| v.into_unknown()),
     Any::True => env.get_boolean(true).map(|v| v.into_unknown()),
@@ -27,29 +32,36 @@ pub fn get_js_unknown_from_any(env: Env, any: Any) -> Result<JsUnknown> {
   }
 }
 
-#[allow(deprecated)]
+pub fn get_js_unknown_from_value(env: Env, value: Value) -> Result<Unknown> {
-// Wait for NAPI-RS External::into_unknown to be stabilized
-pub fn get_js_unknown_from_value(env: Env, value: Value) -> Result<JsUnknown> {
   match value {
     Value::Any(any) => get_js_unknown_from_any(env, any),
-    Value::Array(array) => env
+    Value::Array(array) => {
-      .create_external(YArray::inner_new(array), None)
+      let external = External::new(YArray::inner_new(array));
-      .map(|o| o.into_unknown()),
+      Ok(unsafe {
-    Value::Map(map) => env
+        Unknown::from_raw_unchecked(env.raw(), ToNapiValue::to_napi_value(env.raw(), external)?)
-      .create_external(YMap::inner_new(map), None)
+      })
-      .map(|o| o.into_unknown()),
+    }
-    Value::Text(text) => env
+    Value::Map(map) => {
-      .create_external(YText::inner_new(text), None)
+      let external = External::new(YMap::inner_new(map));
-      .map(|o| o.into_unknown()),
+      Ok(unsafe {
+        Unknown::from_raw_unchecked(env.raw(), ToNapiValue::to_napi_value(env.raw(), external)?)
+      })
+    }
+    Value::Text(text) => {
+      let external = External::new(YText::inner_new(text));
+      Ok(unsafe {
+        Unknown::from_raw_unchecked(env.raw(), ToNapiValue::to_napi_value(env.raw(), external)?)
+      })
+    }
     _ => env.get_null().map(|v| v.into_unknown()),
   }
 }
 
-pub fn get_any_from_js_object(object: JsObject) -> Result<Any> {
+pub fn get_any_from_js_object(object: Object) -> Result<Any> {
   if let Ok(length) = object.get_array_length() {
     let mut array = Vec::with_capacity(length as usize);
     for i in 0..length {
-      if let Ok(value) = object.get_element::<JsUnknown>(i) {
+      if let Ok(value) = object.get_element::<Unknown>(i) {
         array.push(get_any_from_js_unknown(value)?);
       }
     }
@@ -59,14 +71,14 @@ pub fn get_any_from_js_object(object: JsObject) -> Result<Any> {
     let keys = object.get_property_names()?;
     if let Ok(length) = keys.get_array_length() {
       for i in 0..length {
-        if let Ok((obj, key)) = keys.get_element::<JsUnknown>(i).and_then(|o| {
+        if let Ok((obj, key)) = keys.get_element::<Unknown>(i).and_then(|o| {
           o.coerce_to_string().and_then(|obj| {
             obj
               .into_utf8()
               .and_then(|s| s.as_str().map(|s| (obj, s.to_string())))
           })
         }) {
-          if let Ok(value) = object.get_property::<_, JsUnknown>(obj) {
+          if let Ok(value) = object.get_property::<_, Unknown>(obj) {
             println!("key: {}", key);
             map.insert(key, get_any_from_js_unknown(value)?);
           }
@@ -77,7 +89,7 @@ pub fn get_any_from_js_object(object: JsObject) -> Result<Any> {
   }
 }
 
-pub fn get_any_from_js_unknown(js_unknown: JsUnknown) -> Result<Any> {
+pub fn get_any_from_js_unknown(js_unknown: Unknown) -> Result<Any> {
   match js_unknown.get_type()? {
     ValueType::Undefined | ValueType::Null => Ok(Any::Null),
     ValueType::Boolean => Ok(