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

package/dist/models.d.ts

@@ -0,0 +1,169 @@
+import * as napi from "../rust-module.cjs";
+/**
+ * Model<T> is the interface for feeding dynamic data into
+ * `.slint` views.
+ *
+ * A model is organized like a table with rows of data. The
+ * fields of the data type T behave like columns.
+ *
+ * @template T the type of the model's items.
+ *
+ * ### Example
+ * As an example let's see the implementation of {@link ArrayModel}
+ *
+ * ```js
+ * export class ArrayModel<T> extends Model<T> {
+ *    private a: Array<T>
+ *
+ *   constructor(arr: Array<T>) {
+ *        super();
+ *        this.a = arr;
+ *    }
+ *
+ *    rowCount() {
+ *        return this.a.length;
+ *    }
+ *
+ *    rowData(row: number) {
+ *       return this.a[row];
+ *    }
+ *
+ *    setRowData(row: number, data: T) {
+ *        this.a[row] = data;
+ *        this.notifyRowDataChanged(row);
+ *    }
+ *
+ *    push(...values: T[]) {
+ *        let size = this.a.length;
+ *        Array.prototype.push.apply(this.a, values);
+ *        this.notifyRowAdded(size, arguments.length);
+ *    }
+ *
+ *    remove(index: number, size: number) {
+ *        let r = this.a.splice(index, size);
+ *        this.notifyRowRemoved(index, size);
+ *    }
+ *
+ *    get length(): number {
+ *        return this.a.length;
+ *    }
+ *
+ *    values(): IterableIterator<T> {
+ *        return this.a.values();
+ *    }
+ *
+ *    entries(): IterableIterator<[number, T]> {
+ *        return this.a.entries()
+ *    }
+ *}
+ * ```
+ */
+export declare abstract class Model<T> implements Iterable<T> {
+    /**
+     * @hidden
+     */
+    modelNotify: napi.ExternalObject<napi.SharedModelNotify>;
+    /**
+     * @hidden
+     */
+    constructor(modelNotify?: napi.ExternalObject<napi.SharedModelNotify>);
+    /**
+     * Implementations of this function must return the current number of rows.
+     */
+    abstract rowCount(): number;
+    /**
+     * Implementations of this function must return the data at the specified row.
+     * @param row index in range 0..(rowCount() - 1).
+     * @returns undefined if row is out of range otherwise the data.
+     */
+    abstract rowData(row: number): T | undefined;
+    /**
+     * Implementations of this function must store the provided data parameter
+     * in the model at the specified row.
+     * @param _row index in range 0..(rowCount() - 1).
+     * @param _data new data item to store on the given row index
+     */
+    setRowData(_row: number, _data: T): void;
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Notifies the view that the data of the current row is changed.
+     * @param row index of the changed row.
+     */
+    protected notifyRowDataChanged(row: number): void;
+    /**
+     * Notifies the view that multiple rows are added to the model.
+     * @param row index of the first added row.
+     * @param count the number of added items.
+     */
+    protected notifyRowAdded(row: number, count: number): void;
+    /**
+     * Notifies the view that multiple rows are removed to the model.
+     * @param row index of the first removed row.
+     * @param count the number of removed items.
+     */
+    protected notifyRowRemoved(row: number, count: number): void;
+    /**
+     * Notifies the view that the complete data must be reload.
+     */
+    protected notifyReset(): void;
+}
+/**
+ * ArrayModel wraps a JavaScript array for use in `.slint` views. The underlying
+ * array can be modified with the [[ArrayModel.push]] and [[ArrayModel.remove]] methods.
+ */
+export declare class ArrayModel<T> extends Model<T> {
+    #private;
+    /**
+     * Creates a new ArrayModel.
+     *
+     * @param arr
+     */
+    constructor(arr: Array<T>);
+    /**
+     * Returns the number of entries in the array model.
+     */
+    get length(): number;
+    /**
+     * Returns the number of entries in the array model.
+     */
+    rowCount(): number;
+    /**
+     * Returns the data at the specified row.
+     * @param row index in range 0..(rowCount() - 1).
+     * @returns undefined if row is out of range otherwise the data.
+     */
+    rowData(row: number): T;
+    /**
+     * Stores the given data on the given row index and notifies run-time about the changed row.
+     * @param row index in range 0..(rowCount() - 1).
+     * @param data new data item to store on the given row index
+     */
+    setRowData(row: number, data: T): void;
+    /**
+     * Pushes new values to the array that's backing the model and notifies
+     * the run-time about the added rows.
+     * @param values list of values that will be pushed to the array.
+     */
+    push(...values: T[]): void;
+    /**
+     * Removes the last element from the array and returns it.
+     *
+     * @returns The removed element or undefined if the array is empty.
+     */
+    pop(): T | undefined;
+    /**
+     * Removes the specified number of element from the array that's backing
+     * the model, starting at the specified index.
+     * @param index index of first row to remove.
+     * @param size number of rows to remove.
+     */
+    remove(index: number, size: number): void;
+    /**
+     * Returns an iterable of values in the array.
+     */
+    values(): IterableIterator<T>;
+    /**
+     * Returns an iterable of key, value pairs for every entry in the array.
+     */
+    entries(): IterableIterator<[number, T]>;
+}

package/dist/models.js

@@ -0,0 +1,235 @@
+"use strict";
+// Copyright © SixtyFPS GmbH <info@slint.dev>
+// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayModel = exports.Model = void 0;
+const napi = require("../rust-module.cjs");
+class ModelIterator {
+    row;
+    model;
+    constructor(model) {
+        this.model = model;
+        this.row = 0;
+    }
+    next() {
+        if (this.row < this.model.rowCount()) {
+            const row = this.row;
+            this.row++;
+            return {
+                done: false,
+                value: this.model.rowData(row),
+            };
+        }
+        return {
+            done: true,
+            value: undefined,
+        };
+    }
+}
+/**
+ * Model<T> is the interface for feeding dynamic data into
+ * `.slint` views.
+ *
+ * A model is organized like a table with rows of data. The
+ * fields of the data type T behave like columns.
+ *
+ * @template T the type of the model's items.
+ *
+ * ### Example
+ * As an example let's see the implementation of {@link ArrayModel}
+ *
+ * ```js
+ * export class ArrayModel<T> extends Model<T> {
+ *    private a: Array<T>
+ *
+ *   constructor(arr: Array<T>) {
+ *        super();
+ *        this.a = arr;
+ *    }
+ *
+ *    rowCount() {
+ *        return this.a.length;
+ *    }
+ *
+ *    rowData(row: number) {
+ *       return this.a[row];
+ *    }
+ *
+ *    setRowData(row: number, data: T) {
+ *        this.a[row] = data;
+ *        this.notifyRowDataChanged(row);
+ *    }
+ *
+ *    push(...values: T[]) {
+ *        let size = this.a.length;
+ *        Array.prototype.push.apply(this.a, values);
+ *        this.notifyRowAdded(size, arguments.length);
+ *    }
+ *
+ *    remove(index: number, size: number) {
+ *        let r = this.a.splice(index, size);
+ *        this.notifyRowRemoved(index, size);
+ *    }
+ *
+ *    get length(): number {
+ *        return this.a.length;
+ *    }
+ *
+ *    values(): IterableIterator<T> {
+ *        return this.a.values();
+ *    }
+ *
+ *    entries(): IterableIterator<[number, T]> {
+ *        return this.a.entries()
+ *    }
+ *}
+ * ```
+ */
+class Model {
+    /**
+     * @hidden
+     */
+    modelNotify;
+    /**
+     * @hidden
+     */
+    constructor(modelNotify) {
+        this.modelNotify = modelNotify ?? napi.jsModelNotifyNew(this);
+    }
+    /**
+     * Implementations of this function must store the provided data parameter
+     * in the model at the specified row.
+     * @param _row index in range 0..(rowCount() - 1).
+     * @param _data new data item to store on the given row index
+     */
+    setRowData(_row, _data) {
+        console.log("setRowData called on a model which does not re-implement this method. This happens when trying to modify a read-only model");
+    }
+    [Symbol.iterator]() {
+        return new ModelIterator(this);
+    }
+    /**
+     * Notifies the view that the data of the current row is changed.
+     * @param row index of the changed row.
+     */
+    notifyRowDataChanged(row) {
+        napi.jsModelNotifyRowDataChanged(this.modelNotify, row);
+    }
+    /**
+     * Notifies the view that multiple rows are added to the model.
+     * @param row index of the first added row.
+     * @param count the number of added items.
+     */
+    notifyRowAdded(row, count) {
+        napi.jsModelNotifyRowAdded(this.modelNotify, row, count);
+    }
+    /**
+     * Notifies the view that multiple rows are removed to the model.
+     * @param row index of the first removed row.
+     * @param count the number of removed items.
+     */
+    notifyRowRemoved(row, count) {
+        napi.jsModelNotifyRowRemoved(this.modelNotify, row, count);
+    }
+    /**
+     * Notifies the view that the complete data must be reload.
+     */
+    notifyReset() {
+        napi.jsModelNotifyReset(this.modelNotify);
+    }
+}
+exports.Model = Model;
+/**
+ * ArrayModel wraps a JavaScript array for use in `.slint` views. The underlying
+ * array can be modified with the [[ArrayModel.push]] and [[ArrayModel.remove]] methods.
+ */
+class ArrayModel extends Model {
+    /**
+     * @hidden
+     */
+    #array;
+    /**
+     * Creates a new ArrayModel.
+     *
+     * @param arr
+     */
+    constructor(arr) {
+        super();
+        this.#array = arr;
+    }
+    /**
+     * Returns the number of entries in the array model.
+     */
+    get length() {
+        return this.#array.length;
+    }
+    /**
+     * Returns the number of entries in the array model.
+     */
+    rowCount() {
+        return this.#array.length;
+    }
+    /**
+     * Returns the data at the specified row.
+     * @param row index in range 0..(rowCount() - 1).
+     * @returns undefined if row is out of range otherwise the data.
+     */
+    rowData(row) {
+        return this.#array[row];
+    }
+    /**
+     * Stores the given data on the given row index and notifies run-time about the changed row.
+     * @param row index in range 0..(rowCount() - 1).
+     * @param data new data item to store on the given row index
+     */
+    setRowData(row, data) {
+        this.#array[row] = data;
+        this.notifyRowDataChanged(row);
+    }
+    /**
+     * Pushes new values to the array that's backing the model and notifies
+     * the run-time about the added rows.
+     * @param values list of values that will be pushed to the array.
+     */
+    push(...values) {
+        const size = this.#array.length;
+        Array.prototype.push.apply(this.#array, values);
+        this.notifyRowAdded(size, arguments.length);
+    }
+    /**
+     * Removes the last element from the array and returns it.
+     *
+     * @returns The removed element or undefined if the array is empty.
+     */
+    pop() {
+        const last = this.#array.pop();
+        if (last !== undefined) {
+            this.notifyRowRemoved(this.#array.length, 1);
+        }
+        return last;
+    }
+    // FIXME: should this be named splice and have the splice api?
+    /**
+     * Removes the specified number of element from the array that's backing
+     * the model, starting at the specified index.
+     * @param index index of first row to remove.
+     * @param size number of rows to remove.
+     */
+    remove(index, size) {
+        const r = this.#array.splice(index, size);
+        this.notifyRowRemoved(index, size);
+    }
+    /**
+     * Returns an iterable of values in the array.
+     */
+    values() {
+        return this.#array.values();
+    }
+    /**
+     * Returns an iterable of key, value pairs for every entry in the array.
+     */
+    entries() {
+        return this.#array.entries();
+    }
+}
+exports.ArrayModel = ArrayModel;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "slint-ui",
-  "version": "1.9.0-nightly.2024092723",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "version": "1.9.0-nightly.2024100207",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "homepage": "https://github.com/slint-ui/slint",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": {
@@ -20,11 +20,13 @@
   ],
   "description": "Slint is a declarative GUI toolkit to build native user interfaces for desktop and embedded applications.",
   "devDependencies": {
-    "@biomejs/biome": "1.8.3",
     "@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",
@@ -40,7 +42,7 @@
     "build:debug": "napi build --platform --js rust-module.cjs --dts rust-module.d.ts -c binaries.json && npm run compile",
     "build:testing": "napi build --platform --js rust-module.cjs --dts rust-module.d.ts -c binaries.json --features testing && npm run compile",
     "install": "node build-on-demand.mjs",
-    "docs": "npm run build && typedoc --hideGenerator --treatWarningsAsErrors --readme cover.md index.ts",
+    "docs": "npm run build && typedoc --hideGenerator --treatWarningsAsErrors --readme cover.md typescript/index.ts",
     "check": "biome check",
     "format": "biome format",
     "format:fix": "biome format --write",
@@ -65,10 +67,10 @@
     "@napi-rs/cli": "^2.16.5"
   },
   "optionalDependencies": {
-    "@slint-ui/slint-ui-binary-linux-x64-gnu": "1.9.0-nightly.2024092723",
-    "@slint-ui/slint-ui-binary-darwin-x64": "1.9.0-nightly.2024092723",
-    "@slint-ui/slint-ui-binary-darwin-arm64": "1.9.0-nightly.2024092723",
-    "@slint-ui/slint-ui-binary-win32-x64-msvc": "1.9.0-nightly.2024092723",
-    "@slint-ui/slint-ui-binary-win32-ia32-msvc": "1.9.0-nightly.2024092723"
+    "@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/{src → 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/{src → 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/{src → 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/{src → 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");