slint-ui 1.9.0-nightly.2024100103 → 1.9.0-nightly.2024100207

package/Cargo.toml

@@ -41,10 +41,10 @@ accessibility = ["slint-interpreter/accessibility"]
 [dependencies]
 napi = { version = "2.14.0", default-features = false, features = ["napi8"] }
 napi-derive = "2.14.0"
-i-slint-compiler = { features = ["default"] , git = "https://github.com/slint-ui/slint", rev = "f041075e76b61b95df3cff8c430776cb032e20fb", version = "=1.9.0", default-features = false }
-i-slint-core = { features = ["default"] , git = "https://github.com/slint-ui/slint", rev = "f041075e76b61b95df3cff8c430776cb032e20fb", version = "=1.9.0", default-features = false }
-i-slint-backend-selector = { git = "https://github.com/slint-ui/slint", rev = "f041075e76b61b95df3cff8c430776cb032e20fb", version = "=1.9.0", default-features = false }
-slint-interpreter = { default-features = false , features = ["display-diagnostics", "internal", "compat-1-2"] , git = "https://github.com/slint-ui/slint", rev = "f041075e76b61b95df3cff8c430776cb032e20fb", version = "=1.9.0"}
+i-slint-compiler = { features = ["default"] , git = "https://github.com/slint-ui/slint", rev = "34fc24e4e0df464056cd79972dcfaa24b2dbb9f4", version = "=1.9.0", default-features = false }
+i-slint-core = { features = ["default"] , git = "https://github.com/slint-ui/slint", rev = "34fc24e4e0df464056cd79972dcfaa24b2dbb9f4", version = "=1.9.0", default-features = false }
+i-slint-backend-selector = { git = "https://github.com/slint-ui/slint", rev = "34fc24e4e0df464056cd79972dcfaa24b2dbb9f4", version = "=1.9.0", default-features = false }
+slint-interpreter = { default-features = false , features = ["display-diagnostics", "internal", "compat-1-2"] , git = "https://github.com/slint-ui/slint", rev = "34fc24e4e0df464056cd79972dcfaa24b2dbb9f4", version = "=1.9.0"}
 spin_on = { version = "0.1" }
 css-color-parser2 = { version = "1.0.1" }
 itertools = { version = "0.13" }

package/README.md

@@ -193,6 +193,7 @@ The types used for properties in .slint design markup each translate to specific
 | `angle` | `Number` | The angle in degrees |
 | structure | `Object` | Structures are mapped to JavaScript objects where each structure field is a property. |
 | array | `Array` or any implementation of Model | |
+| enumeration | `String` | The value of an enum |
 
 ### Arrays and Models
 

package/biome.json

@@ -2,10 +2,10 @@
     "$schema": "https://biomejs.dev/schemas/1.8.3/schema.json",
     "extends": ["../../biome.json"],
     "formatter": {
-        "ignore": ["*/rust-module.d.ts"]
+        "ignore": ["rust-module.d.ts", "rust-module.cjs", "dist/"]
     },
     "linter": {
-        "ignore": ["rust-module.d.ts", "rust-module.cjs"],
+        "ignore": ["rust-module.d.ts", "rust-module.cjs", "dist/"],
         "rules": {
             "complexity": {
                 "useArrowFunction": "off",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slint-ui",
-  "version": "1.9.0-nightly.2024100103",
+  "version": "1.9.0-nightly.2024100207",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "homepage": "https://github.com/slint-ui/slint",
@@ -22,9 +22,11 @@
   "devDependencies": {
     "@ava/typescript": "^4.1.0",
     "@biomejs/biome": "1.8.3",
+    "@types/capture-console": "^1.0.5",
     "@types/node": "^20.8.6",
     "@types/node-fetch": "^2.6.7",
     "ava": "^5.3.0",
+    "capture-console": "^1.0.2",
     "jimp": "^0.22.8",
     "ts-node": "^10.9.1",
     "typedoc": "^0.25.2",
@@ -65,10 +67,10 @@
     "@napi-rs/cli": "^2.16.5"
   },
   "optionalDependencies": {
-    "@slint-ui/slint-ui-binary-linux-x64-gnu": "1.9.0-nightly.2024100103",
-    "@slint-ui/slint-ui-binary-darwin-x64": "1.9.0-nightly.2024100103",
-    "@slint-ui/slint-ui-binary-darwin-arm64": "1.9.0-nightly.2024100103",
-    "@slint-ui/slint-ui-binary-win32-x64-msvc": "1.9.0-nightly.2024100103",
-    "@slint-ui/slint-ui-binary-win32-ia32-msvc": "1.9.0-nightly.2024100103"
+    "@slint-ui/slint-ui-binary-linux-x64-gnu": "1.9.0-nightly.2024100207",
+    "@slint-ui/slint-ui-binary-darwin-x64": "1.9.0-nightly.2024100207",
+    "@slint-ui/slint-ui-binary-darwin-arm64": "1.9.0-nightly.2024100207",
+    "@slint-ui/slint-ui-binary-win32-x64-msvc": "1.9.0-nightly.2024100207",
+    "@slint-ui/slint-ui-binary-win32-ia32-msvc": "1.9.0-nightly.2024100207"
   }
 }

package/rust/interpreter/component_instance.rs

@@ -137,21 +137,39 @@ impl JsComponentInstance {
             self.inner
                 .set_callback(callback_name.as_str(), {
                     let return_type = return_type.clone();
+                    let callback_name = callback_name.clone();
 
                     move |args| {
-                        let callback: JsFunction = function_ref.get().unwrap();
-                        let result = callback
+                        let Ok(callback) = function_ref.get::<JsFunction>() else {
+                            eprintln!("Node.js: cannot get reference of callback {} because it has the wrong type", callback_name);
+                            return Value::Void;
+                        };
+
+                        let result = match callback
                             .call(
                                 None,
                                 args.iter()
                                     .map(|v| super::value::to_js_unknown(&env, v).unwrap())
                                     .collect::<Vec<JsUnknown>>()
-                                    .as_ref(),
-                            )
-                            .unwrap();
+                                    .as_ref()
+                            ) {
+                            Ok(result) => result,
+                            Err(err) => {
+                                crate::console_err!(env, "Node.js: Invoking callback '{callback_name}' failed: {err}");
+                                return Value::Void;
+                            }
+                        };
 
                         if let Some(return_type) = &return_type {
-                            super::to_value(&env, result, return_type).unwrap()
+                            if let Ok(value) = super::to_value(&env, result, return_type) {
+                                return value;
+                            } else {
+                                eprintln!(
+                                    "Node.js: cannot convert return type of callback {}",
+                                    callback_name
+                                );
+                                return slint_interpreter::default_value_for_type(return_type);
+                            }
                         } else {
                             Value::Void
                         }
@@ -192,21 +210,43 @@ impl JsComponentInstance {
             self.inner
                 .set_global_callback(global_name.as_str(), callback_name.as_str(), {
                     let return_type = return_type.clone();
+                    let global_name = global_name.clone();
+                    let callback_name = callback_name.clone();
 
                     move |args| {
-                        let callback: JsFunction = function_ref.get().unwrap();
-                        let result = callback
+                        let Ok(callback) = function_ref.get::<JsFunction>() else {
+                            eprintln!(
+                                "Node.js: cannot get reference of callback {} of global {} because it has the wrong type",
+                                callback_name, global_name
+                            );
+                            return Value::Void;
+                        };
+
+                        let result = match callback
                             .call(
                                 None,
                                 args.iter()
                                     .map(|v| super::value::to_js_unknown(&env, v).unwrap())
                                     .collect::<Vec<JsUnknown>>()
-                                    .as_ref(),
-                            )
-                            .unwrap();
+                                    .as_ref()
+                            ) {
+                            Ok(result) => result,
+                            Err(err) => {
+                                crate::console_err!(env, "Node.js: Invoking global callback '{callback_name}' failed: {err}");
+                                return Value::Void;
+                            }
+                        };
 
                         if let Some(return_type) = &return_type {
-                            super::to_value(&env, result, return_type).unwrap()
+                            if let Ok(value) = super::to_value(&env, result, return_type) {
+                                return value;
+                            } else {
+                                eprintln!(
+                                    "Node.js: cannot convert return type of callback {}",
+                                    callback_name
+                                );
+                                return slint_interpreter::default_value_for_type(return_type);
+                            }
                         } else {
                             Value::Void
                         }

package/rust/interpreter/value.rs

@@ -78,6 +78,7 @@ pub fn to_js_unknown(env: &Env, value: &Value) -> Result<JsUnknown> {
                 model_wrapper.into_js(env)
             }
         }
+        Value::EnumerationValue(_, value) => env.create_string(value).map(|v| v.into_unknown()),
         _ => env.get_undefined().map(|v| v.into_unknown()),
     }
 }
@@ -239,7 +240,14 @@ pub fn to_value(env: &Env, unknown: JsUnknown, typ: &Type) -> Result<Value> {
                 let mut vec = vec![];
 
                 for i in 0..array.len() {
-                    vec.push(to_value(env, array.get(i)?.unwrap(), a)?);
+                    vec.push(to_value(
+                        env,
+                        array.get(i)?.ok_or(napi::Error::from_reason(format!(
+                            "Cannot access array element at index {}",
+                            i
+                        )))?,
+                        a,
+                    )?);
                 }
                 Ok(Value::Model(ModelRc::new(SharedVectorModel::from(SharedVector::from_slice(
                     &vec,
@@ -250,7 +258,19 @@ pub fn to_value(env: &Env, unknown: JsUnknown, typ: &Type) -> Result<Value> {
                 Ok(Value::Model(rust_model))
             }
         }
-        Type::Enumeration(_) => todo!(),
+        Type::Enumeration(e) => {
+            let js_string: JsString = unknown.try_into()?;
+            let value: String = js_string.into_utf8()?.as_str()?.into();
+
+            if !e.values.contains(&value) {
+                return Err(napi::Error::from_reason(format!(
+                    "{value} is not a value of enum {}",
+                    e.name
+                )));
+            }
+
+            Ok(Value::EnumerationValue(e.name.clone(), value))
+        }
         Type::Invalid
         | Type::Model
         | Type::Void

package/rust/lib.rs

@@ -7,7 +7,7 @@ pub use interpreter::*;
 mod types;
 pub use types::*;
 
-use napi::{Env, JsFunction};
+use napi::{Env, JsFunction, JsObject};
 
 #[macro_use]
 extern crate napi_derive;
@@ -54,7 +54,10 @@ pub fn invoke_from_event_loop(env: Env, callback: JsFunction) -> napi::Result<na
     let function_ref = send_wrapper::SendWrapper::new(function_ref);
     i_slint_core::api::invoke_from_event_loop(move || {
         let function_ref = function_ref.take();
-        let callback: JsFunction = function_ref.get().unwrap();
+        let Ok(callback) = function_ref.get::<JsFunction>() else {
+            eprintln!("Node.js: JavaScript invoke_from_event_loop threw an exception");
+            return;
+        };
         callback.call_without_args(None).ok();
     })
     .map_err(|e| napi::Error::from_reason(e.to_string()))
@@ -82,3 +85,38 @@ pub fn init_testing() {
     #[cfg(feature = "testing")]
     i_slint_backend_testing::init_integration_test_with_mock_time();
 }
+
+pub fn print_to_console(env: Env, function: &str, arguments: core::fmt::Arguments) {
+    let Ok(global) = env.get_global() else {
+        eprintln!("Unable to obtain global object");
+        return;
+    };
+
+    let Ok(console_object) = global
+        .get_named_property::<JsObject>("console")
+        .and_then(|console| console.coerce_to_object())
+    else {
+        eprintln!("Unable to obtain console object for logging");
+        return;
+    };
+
+    let Ok(Some(log_fn)) = console_object.get::<&str, JsFunction>(function) else {
+        eprintln!("Unable to obtain console.{function}");
+        return;
+    };
+
+    let message = arguments.to_string();
+    let Ok(js_message) = env.create_string(&message) else {
+        eprintln!("Unable to provide log message to JS env");
+        return;
+    };
+
+    if let Err(err) = log_fn.call(None, &vec![js_message.into_unknown()]) {
+        eprintln!("Unable to invoke console.{function}: {err}");
+    }
+}
+
+#[macro_export]
+macro_rules! console_err {
+    ($env:expr, $($t:tt)*) => ($crate::print_to_console($env, "error", format_args!($($t)*)))
+}

package/rust/types/model.rs

@@ -90,7 +90,10 @@ impl Model for JsModel {
     type Data = slint_interpreter::Value;
 
     fn row_count(&self) -> usize {
-        let model: Object = self.js_impl.get().unwrap();
+        let Ok(model) = self.js_impl.get::<Object>() else {
+            eprintln!("Node.js: JavaScript Model<T>'s rowCount threw an exception");
+            return 0;
+        };
 
         let Ok(row_count_property) = model.get::<&str, JsFunction>("rowCount") else {
             eprintln!("Node.js: JavaScript Model<T> implementation is missing rowCount property");
@@ -121,7 +124,11 @@ impl Model for JsModel {
     }
 
     fn row_data(&self, row: usize) -> Option<Self::Data> {
-        let model: Object = self.js_impl.get().unwrap();
+        let Ok(model) = self.js_impl.get::<Object>() else {
+            eprintln!("Node.js: JavaScript Model<T>'s rowData threw an exception");
+            return None;
+        };
+
         let Ok(row_data_property) = model.get::<&str, JsFunction>("rowData") else {
             eprintln!("Node.js: JavaScript Model<T> implementation is missing rowData property");
             return None;
@@ -152,7 +159,10 @@ impl Model for JsModel {
     }
 
     fn set_row_data(&self, row: usize, data: Self::Data) {
-        let model: Object = self.js_impl.get().unwrap();
+        let Ok(model) = self.js_impl.get::<Object>() else {
+            eprintln!("Node.js: JavaScript Model<T>'s setRowData threw an exception");
+            return;
+        };
 
         let Ok(set_row_data_property) = model.get::<&str, JsFunction>("setRowData") else {
             eprintln!("Node.js: JavaScript Model<T> implementation is missing setRowData property");