update to quickjs_runtime 0.16

Author: andrieshiemstra

Cargo.toml

@@ -47,12 +47,12 @@ cache = ["lru"]
 
 
 [dependencies]
-quickjs_runtime = { version = "0.15" }
+quickjs_runtime = { version = "0.16" }
 #quickjs_runtime = { path = '../quickjs_es_runtime', features = ["typescript", "default"]}
 #quickjs_runtime = { git = 'https://github.com/HiRoFa/quickjs_es_runtime', features = ["typescript", "default"]}
 #libquickjs-sys = {package="hirofa-quickjs-sys", path='../quickjs-sys', features=["quickjs-ng"]}
 #libquickjs-sys = {package="hirofa-quickjs-sys", git='https://github.com/HiRoFa/quickjs-sys', features=["bellard"]}
-libquickjs-sys = { package = "hirofa-quickjs-sys", version = "0.10", features = ["bellard"], default-features = false }
+libquickjs-sys = { package = "hirofa-quickjs-sys", version = "0.11", features = ["bellard"], default-features = false }
 hirofa_utils = "0.7"
 #hirofa_utils = {git = "https://github.com/HiRoFa/utils"}
 #hirofa_utils = { path = '../utils'}

src/features/js_fetch/proxies.rs

@@ -97,8 +97,8 @@ fn impl_response(realm: &QuickJsRealmAdapter) -> Result<(), JsError> {
                 return Err(JsError::new_str("getHeader expects a single String arg"));
             }
 
-            let name = args[0].to_str()?;
-            if let Some(headers) = response.headers.get(name) {
+            let name = args[0].to_string()?;
+            if let Some(headers) = response.headers.get(name.as_str()) {
                 if !headers.is_empty() {
                     return realm.create_string(headers.first().unwrap());
                 }

src/modules/db/sqlx/mod.rs

@@ -1218,9 +1218,9 @@ fn prep_query_and_args(
     args: Vec<QuickJsValueAdapter>,
     protocol: Protocol,
 ) -> Result<(String, Vec<JsValueFacade>), JsError> {
-    let query = args[0].to_str()?;
+    let query = args[0].to_string()?;
 
-    let parsed_query = parse_query(protocol, query);
+    let parsed_query = parse_query(protocol, query.as_str());
 
     // param names in correct order
 

src/modules/encoding/mod.rs

@@ -167,7 +167,7 @@ pub(crate) fn create_base64_proxy(_realm: &QuickJsRealmAdapter) -> JsProxy {
             if args.is_empty() || !args[0].is_string() {
                 Err(JsError::new_str("decode expects a single string arg"))
             } else {
-                let s = args[0].to_str()?;
+                let s = args[0].to_string()?;
                 let engine = base64::engine::general_purpose::STANDARD_NO_PAD;
                 let decoded = engine.decode(s.trim_end_matches('=')).map_err(|e| {
                     JsError::new_string(format!("could not decode base64({s}): {e}"))

src/modules/htmldom/mod.rs

@@ -846,15 +846,15 @@ fn init_node_proxy(realm: &QuickJsRealmAdapter) -> Result<QuickJsValueAdapter, J
                 return Err(JsError::new_str("getAttribute expects one string arg"));
             }
 
-            let local_name = args[0].to_str()?;
+            let local_name = args[0].to_string()?;
 
             with_node(id, |node| {
                 //
                 match node.as_element() {
                     None => Err(JsError::new_str("not an Element")),
                     Some(element) => {
                         let attrs = &mut *element.attributes.borrow_mut();
-                        match attrs.get(local_name) {
+                        match attrs.get(local_name.as_str()) {
                             None => realm.create_null(),
                             Some(attr) => realm.create_string(attr),
                         }
@@ -910,11 +910,11 @@ fn init_node_proxy(realm: &QuickJsRealmAdapter) -> Result<QuickJsValueAdapter, J
                 return Err(JsError::new_str("querySelector expects one string arg"));
             }
 
-            let selectors = args[0].to_str()?;
+            let selectors = args[0].to_string()?;
 
             let res = with_node(id, |node| {
                 //
-                let result = node.select_first(selectors);
+                let result = node.select_first(selectors.as_str());
                 match result {
                     Ok(ndr) => Some(ndr.as_node().clone()),
                     Err(_) => None,
@@ -1185,12 +1185,12 @@ fn init_node_proxy(realm: &QuickJsRealmAdapter) -> Result<QuickJsValueAdapter, J
                 ));
             }
 
-            let id_attr = args[0].to_str()?;
+            let id_attr = args[0].to_string()?;
 
             let res = with_node(id, |node| match node.as_document() {
                 None => Err(JsError::new_str("not a Document")),
                 Some(_document) => {
-                    let node_res = node.select_first(format!("#{id_attr}").as_str());
+                    let node_res = node.select_first(id_attr.as_str());
                     Ok(node_res)
                 }
             });

src/modules/jwt/mod.rs

@@ -122,7 +122,8 @@ fn create(
     } else {
         let alg_header = realm.get_object_property(&args[0], "alg")?;
         let alg = if alg_header.is_string() {
-            JwtAlgo::from_str(alg_header.to_str()?)?
+            let string = alg_header.to_string()?;
+            JwtAlgo::from_str(string.as_str())?
         } else {
             JwtAlgo::EdDSA
         };

src/modules/util/cache/mod.rs

@@ -85,13 +85,13 @@ impl CacheRegion {
     pub fn remove(&mut self, key: &str) -> Option<CacheEntry> {
         self.lru_cache.pop(key)
     }
-    pub fn put(&mut self, key: &str, val: JsValueFacade) {
+    pub fn put(&mut self, key: String, val: JsValueFacade) {
         let ce = CacheEntry {
             val,
             created: Instant::now(),
             last_used: Instant::now(),
         };
-        self.lru_cache.put(key.to_string(), ce);
+        self.lru_cache.put(key, ce);
     }
     fn invalidate_stale(&mut self) {
         let min_last_used = Instant::now().sub(self.max_idle);
@@ -238,7 +238,7 @@ impl NativeModuleLoader for CacheModuleLoader {
 
 fn cache_add(
     realm: &QuickJsRealmAdapter,
-    key: &str,
+    key: String,
     value: &QuickJsValueAdapter,
     region: &mut CacheRegion,
 ) -> Result<(), JsError> {
@@ -293,8 +293,9 @@ fn init_region_proxy(realm: &QuickJsRealmAdapter) -> Result<(), JsError> {
                             "cache_add_func",
                             move |realm, _this, args| {
                                 // cache args 0
+                                let key_clone = key.clone();
                                 with_cache_region(&instance_id, |cache_region2| {
-                                    cache_add(realm, &key, &args[0], cache_region2)
+                                    cache_add(realm, key_clone, &args[0], cache_region2)
                                 })?;
 
                                 realm.create_null()
@@ -303,7 +304,7 @@ fn init_region_proxy(realm: &QuickJsRealmAdapter) -> Result<(), JsError> {
                         )?;
                         realm.add_promise_reactions(&init_result, Some(then), None, None)?;
                     } else {
-                        cache_add(realm, &key, &init_result, cache_region)?;
+                        cache_add(realm, key, &init_result, cache_region)?;
                     }
                     Ok(init_result)
                 }
@@ -322,7 +323,7 @@ fn init_region_proxy(realm: &QuickJsRealmAdapter) -> Result<(), JsError> {
                 ));
             }
 
-            let key = args[0].to_str()?;
+            let key = args[0].to_string()?;
             let val = realm.to_js_value_facade(&args[1])?;
 
             with_cache_region(instance_id, move |cache_region| {