slint-ui 0.2.0

package/LICENSE.md

@@ -0,0 +1,6 @@
+# Slint License
+
+Slint is available under either a [commercial license](LICENSES/LicenseRef-Slint-commercial.md)
+or at your choice under [GPL 3.0](LICENSES/GPL-3.0-only.txt).
+
+Third party licenses listed in the `LICENSES` folder also apply to parts of the product.

package/README.md

@@ -0,0 +1,146 @@
+# Slint-node
+
+[![npm](https://img.shields.io/npm/v/slint-ui)](https://www.npmjs.com/package/slint-ui)
+
+[Slint](https://slint-ui.com/) is a UI toolkit that supports different programming languages.
+Slint-node is the integration with node.
+
+The complete Node documentation can be viewed online at https://slint-ui.com/docs/node/.
+
+**Warning: Pre-Alpha**
+Slint is still in the early stages of development: APIs will change and important features are still being developed.
+
+## Installing Slint
+
+Slint is available via NPM, so you can install by running the following command:
+
+```sh
+npm install slint-ui
+```
+
+## Using Slint
+
+To initialize the API, you first need to import the `slint-ui` module in our code:
+
+```js
+let slint = require("slint-ui");
+```
+
+This step also installs a hook in NodeJS that allows you to import `.slint` files directly:
+
+```js
+let ui = require("../ui/main.slint");
+```
+
+Combining these two steps leads us to the obligatory "Hello World" example:
+
+```js
+require("slint-ui");
+let ui = require("../ui/main.slint");
+let main = new ui.Main();
+main.run();
+```
+
+See [/examples/printerdemo/node](/examples/printerdemo/node) for a full example.
+
+## API Overview
+
+### Instantiating a component
+
+The exported component is exposed as a type constructor. The type constructor takes as parameter
+an object which allow to initialize the value of public properties or callbacks.
+
+```js
+require("slint-ui");
+// In this example, the main.slint file exports a module which
+// has a counter property and a clicked callback
+let ui = require("ui/main.slint");
+let component = new ui.MainWindow({
+    counter: 42,
+    clicked: function() { console.log("hello"); }
+});
+```
+
+### Accessing a property
+
+Properties are exposed as properties on the component instance
+
+```js
+component.counter = 42;
+console.log(component.counter);
+```
+
+### Callbacks
+
+The callbacks are also exposed as property that have a setHandler function, and that can can be called.
+
+```js
+// connect to a callback
+component.clicked.setHandler(function() { console.log("hello"); })
+// emit a callback
+component.clicked();
+```
+
+### Type Mappings
+
+| `.slint` Type | JavaScript Type | Notes |
+| --- | --- | --- |
+| `int` | `Number` | |
+| `float` | `Number` | |
+| `string` | `String` | |
+| `color` | `String` | Colors are represented as strings in the form `"#rrggbbaa"`. When setting a color property, any CSS compliant color is accepted as a string. |
+| `length` | `Number` | |
+| `physical_length` | `Number` | |
+| `duration` | `Number` | The number of milliseconds |
+| `angle` | `Number` | The value in degrees |
+| structure | `Object` | Structures are mapped to JavaScrip objects with structure fields mapped to properties. |
+| array | `Array` or Model Object | |
+
+### Models
+
+For property of array type, they can either be set using an array.
+In that case, getting the property also return an array.
+If the array was set within the .slint file, the array can be obtained
+
+```js
+component.model = [1, 2, 3];
+// component.model.push(4); // does not work, because it operate on a copy
+// but re-assigning works
+component.model = component.model.concat(4);
+```
+
+Another option is to set a model object.  A model object has the following function:
+
+* `rowCount()`: returns the number of element in the model.
+* `rowData(index)`: return the row at the given index
+* `setRowData(index, data)`: called when the model need to be changed. `this.notify.rowDataChanged` must be called if successful.
+
+When such an object is set to a model property, it gets a new `notify` object with the following function
+
+* `rowDataChanged(index)`: notify the view that the row was changed.
+* `rowAdded(index, count)`: notify the view that rows were added.
+* `rowRemoved(index, count)`: notify the view that a row were removed.
+
+As an example, here is the implementation of the `ArrayModel` (which is available as `slint.ArrayModel`)
+
+```js
+let array = [1, 2, 3];
+let model = {
+    rowCount() { return a.length; },
+    rowData(row) { return a[row]; },
+    setRowData(row, data) { a[row] = data; this.notify.rowDataChanged(row); },
+    push() {
+        let size = a.length;
+        Array.prototype.push.apply(a, arguments);
+        this.notify.rowAdded(size, arguments.length);
+    },
+    remove(index, size) {
+        let r = a.splice(index, size);
+        this.notify.rowRemoved(size, arguments.length);
+    },
+};
+component.model = model;
+model.push(4); // this works
+// does NOT work, getting the model does not return the right object
+// component.model.push(5);
+ ```

package/lib/index.ts

@@ -0,0 +1,239 @@
+// Copyright © SixtyFPS GmbH <info@slint-ui.com>
+// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-commercial
+
+// Load the native library with `process.dlopen` instead of with `require`.
+// This is only done for autotest that do not require nom or neon_cli to
+// copy the lib to its right place
+/**
+ * @hidden
+ */
+function load_native_lib() {
+    const os = require('os');
+    (process as any).dlopen(module, process.env.SLINT_NODE_NATIVE_LIB,
+        os.constants.dlopen.RTLD_NOW);
+    return module.exports;
+}
+
+/**
+ * @hidden
+ */
+let native = !process.env.SLINT_NODE_NATIVE_LIB ? require('../native/index.node') : load_native_lib();
+
+/**
+ * @hidden
+ */
+class Component {
+    protected comp: any;
+
+    constructor(comp: any) {
+        this.comp = comp;
+    }
+
+    run() {
+        this.comp.run();
+    }
+
+    show() {
+        this.window.show();
+    }
+
+    hide() {
+        this.window.hide()
+    }
+
+    get window(): Window {
+        return this.comp.window();
+    }
+
+    send_mouse_click(x: number, y: number) {
+        this.comp.send_mouse_click(x, y)
+    }
+
+    send_keyboard_string_sequence(s: String) {
+        this.comp.send_keyboard_string_sequence(s)
+    }
+}
+
+interface Window {
+    show(): void;
+    hide(): void;
+}
+
+/**
+ * @hidden
+ */
+interface Callback {
+    (): any;
+    setHandler(cb: any): void;
+}
+
+require.extensions['.60'] = require.extensions['.slint'] =
+    function (module, filename) {
+        var c = native.load(filename);
+        module.exports[c.name().replace(/-/g, '_')] = function (init_properties: any) {
+            let comp = c.create(init_properties);
+            let ret = new Component(comp);
+            c.properties().forEach((x: string) => {
+                Object.defineProperty(ret, x.replace(/-/g, '_'), {
+                    get() { return comp.get_property(x); },
+                    set(newValue) { comp.set_property(x, newValue); },
+                    enumerable: true,
+                })
+            });
+            c.callbacks().forEach((x: string) => {
+                Object.defineProperty(ret, x.replace(/-/g, '_'), {
+                    get() {
+                        let callback = function () { return comp.invoke_callback(x, [...arguments]); } as Callback;
+                        callback.setHandler = function (callback) { comp.connect_callback(x, callback) };
+                        return callback;
+                    },
+                    enumerable: true,
+                })
+            });
+            return ret;
+        }
+    }
+
+/**
+ * ModelPeer is the interface that the run-time implements. An instance is
+ * set on dynamic Model<T> instances and can be used to notify the run-time
+ * of changes in the structure or data of the model.
+ */
+interface ModelPeer {
+    /**
+     * Call this function from our own model to notify that fields of data
+     * in the specified row have changed.
+     * @argument row
+     */
+    rowDataChanged(row: number): void;
+    /**
+     * Call this function from your own model to notify that one or multiple
+     * rows were added to the model, starting at the specified row.
+     * @param row
+     * @param count
+     */
+    rowAdded(row: number, count: number): void;
+    /**
+     * Call this function from your own model to notify that one or multiple
+     * rows were removed from the model, starting at the specified row.
+     * @param row
+     * @param count
+     */
+    rowRemoved(row: number, count: number): void;
+}
+
+/**
+ * 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.
+ */
+interface Model<T> {
+    /**
+     * Implementations of this function must return the current number of rows.
+     */
+    rowCount(): number;
+    /**
+     * Implementations of this function must return the data at the specified row.
+     * @param row
+     */
+    rowData(row: number): T;
+    /**
+     * Implementations of this function must store the provided data parameter
+     * in the model at the specified row.
+     * @param row
+     * @param data
+     */
+    setRowData(row: number, data: T): void;
+    /**
+     * This public member is set by the run-time and implementation must use this
+     * to notify the run-time of changes in the model.
+     */
+    notify: ModelPeer;
+}
+
+/**
+ * @hidden
+ */
+class NullPeer implements ModelPeer {
+    rowDataChanged(row: number): void { }
+    rowAdded(row: number, count: number): void { }
+    rowRemoved(row: number, count: number): 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.
+ */
+class ArrayModel<T> implements Model<T> {
+    /**
+     * @hidden
+     */
+    private a: Array<T>
+    notify: ModelPeer;
+
+    /**
+     * Creates a new ArrayModel.
+     *
+     * @param arr
+     */
+    constructor(arr: Array<T>) {
+        this.a = arr;
+        this.notify = new NullPeer();
+    }
+
+    rowCount() {
+        return this.a.length;
+    }
+    rowData(row: number) {
+        return this.a[row];
+    }
+    setRowData(row: number, data: T) {
+        this.a[row] = data;
+        this.notify.rowDataChanged(row);
+    }
+    /**
+     * Pushes new values to the array that's backing the model and notifies
+     * the run-time about the added rows.
+     * @param values
+     */
+    push(...values: T[]) {
+        let size = this.a.length;
+        Array.prototype.push.apply(this.a, values);
+        this.notify.rowAdded(size, arguments.length);
+    }
+    // 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. This is equivalent to calling
+     * Array.slice() on the array and notifying the run-time about the removed
+     * rows.
+     * @param index
+     * @param size
+     */
+    remove(index: number, size: number) {
+        let r = this.a.splice(index, size);
+        this.notify.rowRemoved(index, size);
+    }
+
+    get length(): number {
+        return this.a.length;
+    }
+
+    values(): IterableIterator<T> {
+        return this.a.values();
+    }
+
+    entries(): IterableIterator<[number, T]> {
+        return this.a.entries()
+    }
+}
+
+module.exports = {
+    private_api: native,
+    ArrayModel: ArrayModel,
+    Timer: {
+        singleShot: native.singleshot_timer,
+    },
+};

package/loader.mjs

@@ -0,0 +1,42 @@
+// Copyright © SixtyFPS GmbH <info@slint-ui.com>
+// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-commercial
+
+import { URL, pathToFileURL } from 'url';
+
+const extensionsRegex = /\.(60|slint)$/;
+const baseURL = pathToFileURL(`${process.cwd()}/`).href;
+
+export function resolve(specifier, context, defaultResolve) {
+
+    const { parentURL = baseURL } = context;
+
+    if (extensionsRegex.test(specifier)) {
+        return { url: new URL(specifier, parentURL).href };
+    }
+
+    return defaultResolve(specifier, context, defaultResolve);
+}
+
+
+export function getFormat(url, context, defaultGetFormat) {
+    if (extensionsRegex.test(url)) {
+        return {
+            format: 'module'
+        };
+    }
+    return defaultGetFormat(url, context, defaultGetFormat);
+}
+
+export function transformSource(source, context, defaultTransformSource) {
+    const { url, format } = context;
+
+    if (extensionsRegex.test(url)) {
+        console.log(`This is where one can compile ${url}`)
+        return {
+            source: "console.log('Hey'); export function foo(x) { return x + 55 }"
+        };
+    }
+
+    // Let Node.js handle all other sources.
+    return defaultTransformSource(source, context, defaultTransformSource);
+}

package/native/Cargo.toml

@@ -0,0 +1,38 @@
+# Copyright © SixtyFPS GmbH <info@slint-ui.com>
+# SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-commercial
+
+[package]
+name = "slint-node"
+version = "0.2.0"
+authors = ["Slint Developers <info@slint-ui.com>"]
+edition = "2021"
+build = "build.rs"
+# This is not meant to be used as a library from crate.io
+publish = false
+license = "GPL-3.0-only OR LicenseRef-Slint-commercial"
+repository = "https://github.com/slint-ui/slint"
+homepage = "https://slint-ui.com"
+
+
+[lib]
+path = "lib.rs"
+crate-type = ["cdylib"]
+name = "slint_node_native"
+
+[dependencies]
+i-slint-compiler = { version = "=0.2.0"}
+i-slint-core = { version = "=0.2.0"}
+slint-interpreter = { version = "=0.2.0",  features = ["display-diagnostics"] }
+
+vtable = { version = "0.1.1"}
+
+css-color-parser2 = "1.0.1"
+generativity = "1"
+neon = "0.8.0"
+once_cell = "1.5"
+rand = "0.8"
+scoped-tls-hkt = "0.1"
+spin_on = "0.1" #FIXME: remove and delegate to async JS instead
+
+[build-dependencies]
+neon-build = "0.8.0"

package/native/build.rs

@@ -0,0 +1,6 @@
+// Copyright © SixtyFPS GmbH <info@slint-ui.com>
+// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-commercial
+
+fn main() {
+    neon_build::setup();
+}

package/native/js_model.rs

@@ -0,0 +1,148 @@
+// Copyright © SixtyFPS GmbH <info@slint-ui.com>
+// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-commercial
+
+use i_slint_compiler::langtype::Type;
+use i_slint_core::model::Model;
+use neon::prelude::*;
+use std::cell::Cell;
+use std::rc::{Rc, Weak};
+
+/// Model coming from JS
+pub struct JsModel {
+    notify: i_slint_core::model::ModelNotify,
+    /// The index of the value in the PersistentContext
+    value_index: u32,
+    data_type: Type,
+}
+
+impl JsModel {
+    pub fn new<'cx>(
+        obj: Handle<'cx, JsObject>,
+        data_type: Type,
+        cx: &mut impl Context<'cx>,
+        persistent_context: &crate::persistent_context::PersistentContext<'cx>,
+    ) -> NeonResult<Rc<Self>> {
+        let val = obj.as_value(cx);
+        let model = Rc::new(JsModel {
+            notify: Default::default(),
+            value_index: persistent_context.allocate(cx, val),
+            data_type,
+        });
+
+        let mut notify = SlintModelNotify::new::<_, JsValue, _>(cx, std::iter::empty())?;
+        cx.borrow_mut(&mut notify, |mut notify| notify.0 = Rc::downgrade(&model));
+        let notify = notify.as_value(cx);
+        obj.set(cx, "notify", notify)?;
+
+        Ok(model)
+    }
+
+    pub fn get_object<'cx>(
+        &self,
+        cx: &mut impl Context<'cx>,
+        persistent_context: &crate::persistent_context::PersistentContext<'cx>,
+    ) -> JsResult<'cx, JsObject> {
+        persistent_context.get(cx, self.value_index)?.downcast_or_throw(cx)
+    }
+}
+
+impl Model for JsModel {
+    type Data = slint_interpreter::Value;
+
+    fn row_count(&self) -> usize {
+        let r = Cell::new(0usize);
+        crate::run_with_global_context(&|cx, persistent_context| {
+            let obj = self.get_object(cx, persistent_context).unwrap();
+            let _ = obj
+                .get(cx, "rowCount")
+                .ok()
+                .and_then(|func| func.downcast::<JsFunction>().ok())
+                .and_then(|func| func.call(cx, obj, std::iter::empty::<Handle<JsValue>>()).ok())
+                .and_then(|res| res.downcast::<JsNumber>().ok())
+                .map(|num| r.set(num.value() as _));
+        });
+        r.get()
+    }
+
+    fn row_data(&self, row: usize) -> Option<Self::Data> {
+        if row >= self.row_count() {
+            None
+        } else {
+            let r = Cell::new(slint_interpreter::Value::default());
+            crate::run_with_global_context(&|cx, persistent_context| {
+                let row = JsNumber::new(cx, row as f64);
+                let obj = self.get_object(cx, persistent_context).unwrap();
+                let _ = obj
+                    .get(cx, "rowData")
+                    .ok()
+                    .and_then(|func| func.downcast::<JsFunction>().ok())
+                    .and_then(|func| func.call(cx, obj, std::iter::once(row)).ok())
+                    .and_then(|res| {
+                        crate::to_eval_value(res, self.data_type.clone(), cx, persistent_context)
+                            .ok()
+                    })
+                    .map(|res| r.set(res));
+            });
+            Some(r.into_inner())
+        }
+    }
+
+    fn model_tracker(&self) -> &dyn i_slint_core::model::ModelTracker {
+        &self.notify
+    }
+
+    fn set_row_data(&self, row: usize, data: Self::Data) {
+        crate::run_with_global_context(&|cx, persistent_context| {
+            let row = JsNumber::new(cx, row as f64).as_value(cx);
+            let data = crate::to_js_value(data.clone(), cx, persistent_context).unwrap();
+            let obj = self.get_object(cx, persistent_context).unwrap();
+            let _ = obj
+                .get(cx, "setRowData")
+                .ok()
+                .and_then(|func| func.downcast::<JsFunction>().ok())
+                .and_then(|func| func.call(cx, obj, [row, data].iter().cloned()).ok());
+        });
+    }
+
+    fn as_any(&self) -> &dyn core::any::Any {
+        self
+    }
+}
+
+struct WrappedJsModel(Weak<JsModel>);
+
+declare_types! {
+    class SlintModelNotify for WrappedJsModel {
+        init(_) {
+            Ok(WrappedJsModel(Weak::default()))
+        }
+        method rowDataChanged(mut cx) {
+            let this = cx.this();
+            let row = cx.argument::<JsNumber>(0)?.value() as usize;
+            if let Some(model) = cx.borrow(&this, |x| x.0.upgrade()) {
+                model.notify.row_changed(row)
+            }
+            Ok(JsUndefined::new().as_value(&mut cx))
+        }
+        method rowAdded(mut cx) {
+            let this = cx.this();
+            let row = cx.argument::<JsNumber>(0)?.value() as usize;
+            let count = cx.argument::<JsNumber>(1)?.value() as usize;
+            if let Some(model) = cx.borrow(&this, |x| x.0.upgrade()) {
+                model.notify.row_added(row, count)
+            }
+            Ok(JsUndefined::new().as_value(&mut cx))
+        }
+        method rowRemoved(mut cx) {
+            let this = cx.this();
+            let row = cx.argument::<JsNumber>(0)?.value() as usize;
+            let count = cx.argument::<JsNumber>(1)?.value() as usize;
+            if let Some(model) = cx.borrow(&this, |x| x.0.upgrade()) {
+                model.notify.row_removed(row, count)
+            }
+            Ok(JsUndefined::new().as_value(&mut cx))
+        }
+
+    }
+
+}

package/native/lib.rs

@@ -0,0 +1,569 @@
+// Copyright © SixtyFPS GmbH <info@slint-ui.com>
+// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-commercial
+
+use core::cell::RefCell;
+use i_slint_compiler::langtype::Type;
+use i_slint_core::model::{Model, ModelRc};
+use i_slint_core::window::WindowHandleAccess;
+use i_slint_core::{ImageInner, SharedVector};
+use neon::prelude::*;
+use rand::RngCore;
+use slint_interpreter::ComponentHandle;
+
+mod js_model;
+mod persistent_context;
+
+struct WrappedComponentType(Option<slint_interpreter::ComponentDefinition>);
+struct WrappedComponentRc(Option<slint_interpreter::ComponentInstance>);
+struct WrappedWindow(Option<i_slint_core::window::WindowRc>);
+
+/// We need to do some gymnastic with closures to pass the ExecuteContext with the right lifetime
+type GlobalContextCallback<'c> =
+    dyn for<'b> Fn(&mut ExecuteContext<'b>, &persistent_context::PersistentContext<'b>) + 'c;
+scoped_tls_hkt::scoped_thread_local!(static GLOBAL_CONTEXT:
+    for <'a> &'a dyn for<'c> Fn(&'c GlobalContextCallback<'c>));
+
+/// This function exists as a workaround so one can access the ExecuteContext from callback handler
+fn run_scoped<'cx, T>(
+    cx: &mut impl Context<'cx>,
+    object_with_persistent_context: Handle<'cx, JsObject>,
+    functor: impl FnOnce() -> Result<T, String>,
+) -> NeonResult<T> {
+    let persistent_context =
+        persistent_context::PersistentContext::from_object(cx, object_with_persistent_context)?;
+    cx.execute_scoped(|cx| {
+        let cx = RefCell::new(cx);
+        let cx_fn = move |callback: &GlobalContextCallback| {
+            callback(&mut *cx.borrow_mut(), &persistent_context)
+        };
+        GLOBAL_CONTEXT.set(&&cx_fn, functor)
+    })
+    .or_else(|e| cx.throw_error(e))
+}
+
+fn run_with_global_context(f: &GlobalContextCallback) {
+    GLOBAL_CONTEXT.with(|cx_fn| cx_fn(f))
+}
+
+/// Load a .slint files.
+///
+/// The first argument of this function is a string to the .slint file
+///
+/// The return value is a SlintComponentType
+fn load(mut cx: FunctionContext) -> JsResult<JsValue> {
+    let path = cx.argument::<JsString>(0)?.value();
+    let path = std::path::Path::new(path.as_str());
+    let include_paths = match std::env::var_os("SLINT_INCLUDE_PATH") {
+        Some(paths) => {
+            std::env::split_paths(&paths).filter(|path| !path.as_os_str().is_empty()).collect()
+        }
+        None => vec![],
+    };
+    let mut compiler = slint_interpreter::ComponentCompiler::default();
+    compiler.set_include_paths(include_paths);
+    let c = spin_on::spin_on(compiler.build_from_path(path));
+
+    slint_interpreter::print_diagnostics(compiler.diagnostics());
+
+    let c = if let Some(c) = c { c } else { return cx.throw_error("Compilation error") };
+
+    let mut obj = SlintComponentType::new::<_, JsValue, _>(&mut cx, std::iter::empty())?;
+    cx.borrow_mut(&mut obj, |mut obj| obj.0 = Some(c));
+    Ok(obj.as_value(&mut cx))
+}
+
+fn make_callback_handler<'cx>(
+    cx: &mut impl Context<'cx>,
+    persistent_context: &persistent_context::PersistentContext<'cx>,
+    fun: Handle<'cx, JsFunction>,
+    return_type: Option<Box<Type>>,
+) -> Box<dyn Fn(&[slint_interpreter::Value]) -> slint_interpreter::Value> {
+    let fun_value = fun.as_value(cx);
+    let fun_idx = persistent_context.allocate(cx, fun_value);
+    Box::new(move |args| {
+        let args = args.to_vec();
+        let ret = core::cell::Cell::new(slint_interpreter::Value::Void);
+        let borrow_ret = &ret;
+        let return_type = &return_type;
+        run_with_global_context(&move |cx, persistent_context| {
+            let args = args
+                .iter()
+                .map(|a| to_js_value(a.clone(), cx, persistent_context).unwrap())
+                .collect::<Vec<_>>();
+            let ret = persistent_context
+                .get(cx, fun_idx)
+                .unwrap()
+                .downcast::<JsFunction>()
+                .unwrap()
+                .call::<_, _, JsValue, _>(cx, JsUndefined::new(), args)
+                .unwrap();
+            if let Some(return_type) = return_type {
+                borrow_ret.set(
+                    to_eval_value(ret, (**return_type).clone(), cx, persistent_context).unwrap(),
+                );
+            }
+        });
+        ret.into_inner()
+    })
+}
+
+fn create<'cx>(
+    cx: &mut CallContext<'cx, impl neon::object::This>,
+    component_type: slint_interpreter::ComponentDefinition,
+) -> JsResult<'cx, JsValue> {
+    let component = component_type.create();
+    let persistent_context = persistent_context::PersistentContext::new(cx);
+
+    if let Some(args) = cx.argument_opt(0).and_then(|arg| arg.downcast::<JsObject>().ok()) {
+        let properties = component_type
+            .properties_and_callbacks()
+            .map(|(k, v)| (k.replace('_', "-"), v))
+            .collect::<std::collections::HashMap<_, _>>();
+        for x in args.get_own_property_names(cx)?.to_vec(cx)? {
+            let prop_name = x.to_string(cx)?.value().replace('_', "-");
+            let value = args.get(cx, x)?;
+            let ty = properties
+                .get(&prop_name)
+                .ok_or(())
+                .or_else(|()| {
+                    cx.throw_error(format!("Property {} not found in the component", prop_name))
+                })?
+                .clone();
+            if let Type::Callback { return_type, .. } = ty {
+                let fun = value.downcast_or_throw::<JsFunction, _>(cx)?;
+                component
+                    .set_callback(
+                        prop_name.as_str(),
+                        make_callback_handler(cx, &persistent_context, fun, return_type),
+                    )
+                    .or_else(|_| cx.throw_error("Cannot set callback"))?;
+            } else {
+                let value = to_eval_value(value, ty, cx, &persistent_context)?;
+                component
+                    .set_property(prop_name.as_str(), value)
+                    .or_else(|_| cx.throw_error("Cannot assign property"))?;
+            }
+        }
+    }
+
+    let mut obj = SlintComponent::new::<_, JsValue, _>(cx, std::iter::empty())?;
+    persistent_context.save_to_object(cx, obj.downcast().unwrap());
+    cx.borrow_mut(&mut obj, |mut obj| obj.0 = Some(component));
+    Ok(obj.as_value(cx))
+}
+
+fn to_eval_value<'cx>(
+    val: Handle<'cx, JsValue>,
+    ty: i_slint_compiler::langtype::Type,
+    cx: &mut impl Context<'cx>,
+    persistent_context: &persistent_context::PersistentContext<'cx>,
+) -> NeonResult<slint_interpreter::Value> {
+    use slint_interpreter::Value;
+    match ty {
+        Type::Float32
+        | Type::Int32
+        | Type::Duration
+        | Type::Angle
+        | Type::PhysicalLength
+        | Type::LogicalLength
+        | Type::Percent
+        | Type::UnitProduct(_) => {
+            Ok(Value::Number(val.downcast_or_throw::<JsNumber, _>(cx)?.value()))
+        }
+        Type::String => Ok(Value::String(val.to_string(cx)?.value().into())),
+        Type::Color | Type::Brush => {
+            let c = val
+                .to_string(cx)?
+                .value()
+                .parse::<css_color_parser2::Color>()
+                .or_else(|e| cx.throw_error(&e.to_string()))?;
+            Ok((i_slint_core::Color::from_argb_u8((c.a * 255.) as u8, c.r, c.g, c.b)).into())
+        }
+        Type::Array(a) => match val.downcast::<JsArray>() {
+            Ok(arr) => {
+                let vec = arr.to_vec(cx)?;
+                Ok(Value::Model(ModelRc::new(i_slint_core::model::SharedVectorModel::from(
+                    vec.into_iter()
+                        .map(|i| to_eval_value(i, (*a).clone(), cx, persistent_context))
+                        .collect::<Result<SharedVector<_>, _>>()?,
+                ))))
+            }
+            Err(_) => {
+                let obj = val.downcast_or_throw::<JsObject, _>(cx)?;
+                obj.get(cx, "rowCount")?.downcast_or_throw::<JsFunction, _>(cx)?;
+                obj.get(cx, "rowData")?.downcast_or_throw::<JsFunction, _>(cx)?;
+                let m = js_model::JsModel::new(obj, *a, cx, persistent_context)?;
+                Ok(Value::Model(m.into()))
+            }
+        },
+        Type::Image => {
+            let path = val.to_string(cx)?.value();
+            Ok(Value::Image(
+                i_slint_core::graphics::Image::load_from_path(std::path::Path::new(&path))
+                    .or_else(|_| cx.throw_error(format!("cannot load image {:?}", path)))?,
+            ))
+        }
+        Type::Bool => Ok(Value::Bool(val.downcast_or_throw::<JsBoolean, _>(cx)?.value())),
+        Type::Struct { fields, .. } => {
+            let obj = val.downcast_or_throw::<JsObject, _>(cx)?;
+            Ok(Value::Struct(
+                fields
+                    .iter()
+                    .map(|(pro_name, pro_ty)| {
+                        Ok((
+                            pro_name.clone(),
+                            to_eval_value(
+                                obj.get(cx, pro_name.replace('-', "_").as_str())?,
+                                pro_ty.clone(),
+                                cx,
+                                persistent_context,
+                            )?,
+                        ))
+                    })
+                    .collect::<Result<_, _>>()?,
+            ))
+        }
+        Type::Enumeration(_) => todo!(),
+        Type::Invalid
+        | Type::Void
+        | Type::InferredProperty
+        | Type::InferredCallback
+        | Type::Builtin(_)
+        | Type::Native(_)
+        | Type::Function { .. }
+        | Type::Model
+        | Type::Callback { .. }
+        | Type::Easing
+        | Type::Component(_)
+        | Type::PathData
+        | Type::LayoutCache
+        | Type::ElementReference => cx.throw_error("Cannot convert to a Slint property value"),
+    }
+}
+
+fn to_js_value<'cx>(
+    val: slint_interpreter::Value,
+    cx: &mut impl Context<'cx>,
+    persistent_context: &persistent_context::PersistentContext<'cx>,
+) -> NeonResult<Handle<'cx, JsValue>> {
+    use slint_interpreter::Value;
+    Ok(match val {
+        Value::Void => JsUndefined::new().as_value(cx),
+        Value::Number(n) => JsNumber::new(cx, n).as_value(cx),
+        Value::String(s) => JsString::new(cx, s.as_str()).as_value(cx),
+        Value::Bool(b) => JsBoolean::new(cx, b).as_value(cx),
+        Value::Image(r) => match (&r).into() {
+            &ImageInner::None => JsUndefined::new().as_value(cx),
+            &ImageInner::AbsoluteFilePath(ref path) => {
+                JsString::new(cx, path.as_str()).as_value(cx)
+            }
+            &ImageInner::EmbeddedData { .. }
+            | &ImageInner::EmbeddedImage { .. }
+            | &ImageInner::StaticTextures { .. } => JsNull::new().as_value(cx), // TODO: maybe pass around node buffers?
+        },
+        Value::Model(model) => {
+            if let Some(js_model) = model.as_any().downcast_ref::<js_model::JsModel>() {
+                js_model.get_object(cx, persistent_context)?.as_value(cx)
+            } else {
+                // TODO: this should probably create a proxy object instead of extracting the entire model. On the other hand
+                // we should encounter this only if the model was created in .slint, which is when it'll be an array
+                // of values.
+                let js_array = JsArray::new(cx, model.row_count() as _);
+                for i in 0..model.row_count() {
+                    let v = to_js_value(model.row_data(i).unwrap(), cx, persistent_context)?;
+                    js_array.set(cx, i as u32, v)?;
+                }
+                js_array.as_value(cx)
+            }
+        }
+        Value::Struct(o) => {
+            let js_object = JsObject::new(cx);
+            for (k, e) in o.iter() {
+                let v = to_js_value(e.clone(), cx, persistent_context)?;
+                js_object.set(cx, k.replace('-', "_").as_str(), v)?;
+            }
+            js_object.as_value(cx)
+        }
+        Value::Brush(i_slint_core::Brush::SolidColor(c)) => JsString::new(
+            cx,
+            &format!("#{:02x}{:02x}{:02x}{:02x}", c.red(), c.green(), c.blue(), c.alpha()),
+        )
+        .as_value(cx),
+        _ => todo!("converting {:?} to js has not been implemented", val),
+    })
+}
+
+declare_types! {
+    class SlintComponentType for WrappedComponentType {
+        init(_) {
+            Ok(WrappedComponentType(None))
+        }
+        method create(mut cx) {
+            let this = cx.this();
+            let ct = cx.borrow(&this, |x| x.0.clone());
+            let ct = ct.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            create(&mut cx, ct)
+        }
+        method name(mut cx) {
+            let this = cx.this();
+            let ct = cx.borrow(&this, |x| x.0.clone());
+            let ct = ct.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            Ok(cx.string(ct.name()).as_value(&mut cx))
+        }
+        method properties(mut cx) {
+            let this = cx.this();
+            let ct = cx.borrow(&this, |x| x.0.clone());
+            let ct = ct.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            let properties = ct.properties_and_callbacks().filter(|(_, prop_type)| prop_type.is_property_type());
+            let array = JsArray::new(&mut cx, 0);
+            for (len, (p, _)) in properties.enumerate() {
+                let prop_name = JsString::new(&mut cx, p);
+                array.set(&mut cx, len as u32, prop_name)?;
+            }
+            Ok(array.as_value(&mut cx))
+        }
+        method callbacks(mut cx) {
+            let this = cx.this();
+            let ct = cx.borrow(&this, |x| x.0.clone());
+            let ct = ct.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            let callbacks = ct.properties_and_callbacks().filter(|(_, prop_type)| matches!(prop_type, Type::Callback{..}));
+            let array = JsArray::new(&mut cx, 0);
+            for (len , (p, _)) in callbacks.enumerate() {
+                let prop_name = JsString::new(&mut cx, p);
+                array.set(&mut cx, len as u32, prop_name)?;
+            }
+            Ok(array.as_value(&mut cx))
+        }
+    }
+
+    class SlintComponent for WrappedComponentRc {
+        init(_) {
+            Ok(WrappedComponentRc(None))
+        }
+        method run(mut cx) {
+            let this = cx.this();
+            let component = cx.borrow(&this, |x| x.0.as_ref().map(|c| c.clone_strong()));
+            let component = component.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            run_scoped(&mut cx,this.downcast().unwrap(), || {
+                component.run();
+                Ok(())
+            })?;
+            Ok(JsUndefined::new().as_value(&mut cx))
+        }
+        method window(mut cx) {
+            let this = cx.this();
+            let component = cx.borrow(&this, |x| x.0.as_ref().map(|c| c.clone_strong()));
+            let component = component.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            let window = component.window().window_handle().clone();
+            let mut obj = SlintWindow::new::<_, JsValue, _>(&mut cx, std::iter::empty())?;
+            cx.borrow_mut(&mut obj, |mut obj| obj.0 = Some(window));
+            Ok(obj.as_value(&mut cx))
+        }
+        method get_property(mut cx) {
+            let prop_name = cx.argument::<JsString>(0)?.value();
+            let this = cx.this();
+            let persistent_context =
+                persistent_context::PersistentContext::from_object(&mut cx, this.downcast().unwrap())?;
+            let component = cx.borrow(&this, |x| x.0.as_ref().map(|c| c.clone_strong()));
+            let component = component.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            let value = run_scoped(&mut cx,this.downcast().unwrap(), || {
+                component.get_property(prop_name.as_str())
+                    .map_err(|_| "Cannot read property".to_string())
+            })?;
+            to_js_value(value, &mut cx, &persistent_context)
+        }
+        method set_property(mut cx) {
+            let prop_name = cx.argument::<JsString>(0)?.value();
+            let this = cx.this();
+            let component = cx.borrow(&this, |x| x.0.as_ref().map(|c| c.clone_strong()));
+            let component = component.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            let ty = component.definition().properties_and_callbacks()
+                .find_map(|(name, proptype)| if name == prop_name { Some(proptype) } else { None })
+                .ok_or(())
+                .or_else(|()| {
+                    cx.throw_error(format!("Property {} not found in the component", prop_name))
+                })?;
+
+            let persistent_context =
+                persistent_context::PersistentContext::from_object(&mut cx, this.downcast().unwrap())?;
+
+            let value = to_eval_value(cx.argument::<JsValue>(1)?, ty, &mut cx, &persistent_context)?;
+            run_scoped(&mut cx, this.downcast().unwrap(), || {
+                component.set_property(prop_name.as_str(), value)
+                    .map_err(|_| "Cannot assign property".to_string())
+            })?;
+
+            Ok(JsUndefined::new().as_value(&mut cx))
+        }
+        method invoke_callback(mut cx) {
+            let callback_name = cx.argument::<JsString>(0)?.value();
+            let arguments = cx.argument::<JsArray>(1)?.to_vec(&mut cx)?;
+            let this = cx.this();
+            let component = cx.borrow(&this, |x| x.0.as_ref().map(|c| c.clone_strong()));
+            let component = component.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            let ty = component.definition().properties_and_callbacks()
+                .find_map(|(name, proptype)| if name == callback_name { Some(proptype) } else { None })
+                .ok_or(())
+                .or_else(|()| {
+                    cx.throw_error(format!("Callback {} not found in the component", callback_name))
+                })?;
+            let persistent_context =
+                persistent_context::PersistentContext::from_object(&mut cx, this.downcast().unwrap())?;
+            let args = if let Type::Callback {args, ..} = ty {
+                let count = args.len();
+                let args = arguments.into_iter()
+                    .zip(args.into_iter())
+                    .map(|(a, ty)| to_eval_value(a, ty, &mut cx, &persistent_context))
+                    .collect::<Result<Vec<_>, _>>()?;
+                if args.len() != count {
+                    cx.throw_error(format!("{} expect {} arguments, but {} where provided", callback_name, count, args.len()))?;
+                }
+                args
+
+            } else {
+                cx.throw_error(format!("{} is not a callback", callback_name))?;
+                unreachable!()
+            };
+
+            let res = run_scoped(&mut cx,this.downcast().unwrap(), || {
+                component.invoke_callback(callback_name.as_str(), args.as_slice())
+                    .map_err(|_| "Cannot emit callback".to_string())
+            })?;
+            to_js_value(res, &mut cx, &persistent_context)
+        }
+
+        method connect_callback(mut cx) {
+            let callback_name = cx.argument::<JsString>(0)?.value();
+            let handler = cx.argument::<JsFunction>(1)?;
+            let this = cx.this();
+            let persistent_context =
+                persistent_context::PersistentContext::from_object(&mut cx, this.downcast().unwrap())?;
+            let component = cx.borrow(&this, |x| x.0.as_ref().map(|c| c.clone_strong()));
+            let component = component.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+
+            let ty = component.definition().properties_and_callbacks()
+                .find_map(|(name, proptype)| if name == callback_name { Some(proptype) } else { None })
+                .ok_or(())
+                .or_else(|()| {
+                    cx.throw_error(format!("Callback {} not found in the component", callback_name))
+                })?;
+            if let Type::Callback {return_type, ..} = ty {
+                component.set_callback(
+                    callback_name.as_str(),
+                    make_callback_handler(&mut cx, &persistent_context, handler, return_type)
+                ).or_else(|_| cx.throw_error("Cannot set callback"))?;
+                Ok(JsUndefined::new().as_value(&mut cx))
+            } else {
+                cx.throw_error(format!("{} is not a callback", callback_name))?;
+                unreachable!()
+            }
+        }
+
+        method send_mouse_click(mut cx) {
+            let x = cx.argument::<JsNumber>(0)?.value() as f32;
+            let y = cx.argument::<JsNumber>(1)?.value() as f32;
+            let this = cx.this();
+            let component = cx.borrow(&this, |x| x.0.as_ref().map(|c| c.clone_strong()));
+            let component = component.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            run_scoped(&mut cx,this.downcast().unwrap(), || {
+                slint_interpreter::testing::send_mouse_click(&component, x, y);
+                Ok(())
+            })?;
+            Ok(JsUndefined::new().as_value(&mut cx))
+        }
+
+        method send_keyboard_string_sequence(mut cx) {
+            let sequence = cx.argument::<JsString>(0)?.value();
+            let this = cx.this();
+            let component = cx.borrow(&this, |x| x.0.as_ref().map(|c| c.clone_strong()));
+            let component = component.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            run_scoped(&mut cx,this.downcast().unwrap(), || {
+                slint_interpreter::testing::send_keyboard_string_sequence(&component, sequence.into());
+                Ok(())
+            })?;
+            Ok(JsUndefined::new().as_value(&mut cx))
+        }
+    }
+
+    class SlintWindow for WrappedWindow {
+        init(_) {
+            Ok(WrappedWindow(None))
+        }
+
+        method show(mut cx) {
+            let this = cx.this();
+            let window = cx.borrow(&this, |x| x.0.as_ref().cloned());
+            let window = window.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            window.show();
+            Ok(JsUndefined::new().as_value(&mut cx))
+        }
+
+        method hide(mut cx) {
+            let this = cx.this();
+            let window = cx.borrow(&this, |x| x.0.as_ref().cloned());
+            let window = window.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            window.hide();
+            Ok(JsUndefined::new().as_value(&mut cx))
+        }
+    }
+}
+
+fn singleshot_timer_property(id: u32) -> String {
+    format!("$__slint_singleshot_timer_{}", id)
+}
+
+fn singleshot_timer(mut cx: FunctionContext) -> JsResult<JsValue> {
+    let duration_in_msecs = cx.argument::<JsNumber>(0)?.value() as u64;
+    let handler = cx.argument::<JsFunction>(1)?;
+
+    let global_object: Handle<JsObject> = cx.global().downcast().unwrap();
+    let unique_timer_property = {
+        let mut rng = rand::thread_rng();
+        loop {
+            let id = rng.next_u32();
+            let key = singleshot_timer_property(id);
+            if global_object.get(&mut cx, &*key)?.is_a::<JsUndefined>() {
+                break key;
+            }
+        }
+    };
+
+    let handler_value = handler.as_value(&mut cx);
+    global_object.set(&mut cx, &*unique_timer_property, handler_value).unwrap();
+    let callback = move || {
+        run_with_global_context(&move |cx, _| {
+            let global_object: Handle<JsObject> = cx.global().downcast().unwrap();
+
+            let callback = global_object
+                .get(cx, &*unique_timer_property)
+                .unwrap()
+                .downcast::<JsFunction>()
+                .unwrap();
+
+            global_object.set(cx, &*unique_timer_property, JsUndefined::new()).unwrap();
+
+            callback.call::<_, _, JsValue, _>(cx, JsUndefined::new(), vec![]).unwrap();
+        });
+    };
+
+    i_slint_core::timers::Timer::single_shot(
+        std::time::Duration::from_millis(duration_in_msecs),
+        callback,
+    );
+
+    Ok(JsUndefined::new().upcast())
+}
+
+register_module!(mut m, {
+    m.export_function("load", load)?;
+    m.export_function("mock_elapsed_time", mock_elapsed_time)?;
+    m.export_function("singleshot_timer", singleshot_timer)?;
+    Ok(())
+});
+
+/// let some time elapse for testing purposes
+fn mock_elapsed_time(mut cx: FunctionContext) -> JsResult<JsValue> {
+    let ms = cx.argument::<JsNumber>(0)?.value();
+    i_slint_core::tests::slint_mock_elapsed_time(ms as _);
+    Ok(JsUndefined::new().as_value(&mut cx))
+}

package/native/persistent_context.rs

@@ -0,0 +1,37 @@
+// Copyright © SixtyFPS GmbH <info@slint-ui.com>
+// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-commercial
+
+/*!
+Since neon does not allow to have a persistent handle, use this hack.
+*/
+
+use neon::prelude::*;
+pub struct PersistentContext<'a>(Handle<'a, JsArray>);
+
+const KEY: &str = "$__persistent_context";
+
+/// Since neon does not allow to have a persistent handle, this allocates property in an array.
+/// This array is gonna be kept as a property somewhere.
+impl<'a> PersistentContext<'a> {
+    pub fn new(cx: &mut impl Context<'a>) -> Self {
+        PersistentContext(JsArray::new(cx, 0))
+    }
+
+    pub fn allocate(&self, cx: &mut impl Context<'a>, value: Handle<'a, JsValue>) -> u32 {
+        let idx = self.0.len();
+        self.0.set(cx, idx, value).unwrap();
+        idx
+    }
+
+    pub fn get(&self, cx: &mut impl Context<'a>, idx: u32) -> JsResult<'a, JsValue> {
+        self.0.get(cx, idx)
+    }
+
+    pub fn save_to_object(&self, cx: &mut impl Context<'a>, o: Handle<'a, JsObject>) {
+        o.set(cx, KEY, self.0).unwrap();
+    }
+
+    pub fn from_object(cx: &mut impl Context<'a>, o: Handle<'a, JsObject>) -> NeonResult<Self> {
+        Ok(PersistentContext(o.get(cx, KEY)?.downcast_or_throw(cx)?))
+    }
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "slint-ui",
+    "version": "0.2.0",
+    "homepage": "https://github.com/slint-ui/slint",
+    "license": "SEE LICENSE IN LICENSE.md",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/slint-ui/slint"
+    },
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "dependencies": {
+        "@types/node": "^14.11.11",
+        "neon-cli": "^0.4",
+        "typescript": "^4.0.3"
+    },
+    "scripts": {
+        "install": "neon build --release && tsc",
+        "build": "tsc",
+        "docs": "typedoc lib/index.ts"
+    },
+    "devDependencies": {
+        "typedoc": "^0.19.2"
+    }
+}

package/tsconfig.json

@@ -0,0 +1,71 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+    /* Basic Options */
+    // "incremental": true,                   /* Enable incremental compilation */
+    "target": "es2015", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    // "lib": [],                             /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                       /* Allow javascript files to be compiled. */
+    // "checkJs": true,                       /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    "declaration": true, /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    "outDir": "./dist", /* Redirect output structure to the directory. */
+    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
+    // "removeComments": true,                /* Do not emit comments to output. */
+    // "noEmit": true,                        /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+    /* Strict Type-Checking Options */
+    "strict": true, /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+    /* Module Resolution Options */
+    // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true, /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+    /* Advanced Options */
+    "skipLibCheck": true, /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */
+  },
+  "typedocOptions": {
+    "mode": "file",
+    "out": "docs",
+    "readme": "README.md",
+    "disableSources": true,
+    "theme": "minimal",
+    "hideGenerator": true,
+    "name": "Slint Node"
+  }
+}