@dualbox/editor 1.0.78 → 1.0.80

package/js/src/m/GraphModel.js

@@ -1012,6 +1012,29 @@ class GraphNode {
         }
     }
 
+    checkTypeMatch(type, val) {
+        let lowercaseType = type.toLowerCase();
+        switch (lowercaseType) {
+            case "string":
+                if (typeof val !== "string") {
+                    throw "Expected string type but got " + type;
+                }
+                break;
+            case "number":
+                if (typeof val !== "number") {
+                    throw "Expected number type but got " + type;
+                }
+                break;
+            case "boolean":
+                if (typeof val !== "boolean") {
+                    throw "Expected boolean type but got " + type;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
     getInputDefaultValue(inputName) {
         var pkg = this.getPackage();
         var pkgDefault = pkg && pkg.dualbox && pkg.dualbox.input && pkg.dualbox.input[inputName] && pkg.dualbox.input[inputName].value;
@@ -1025,6 +1048,7 @@ class GraphNode {
     }
 
     setInputDefaultValue(inputName, val) {
+        this.checkTypeMatch(this.getInputType(inputName), val);
         this.def.defaultInputs = this.def.defaultInputs || {};
         this.def.defaultInputs[inputName] = val;
         this.m.save();
@@ -1103,6 +1127,7 @@ class GraphNode {
     }
 
     setAttributeValue(attrName, val) {
+        this.checkTypeMatch(this.getAttributeType(attrName), val);
         this.def.attr = this.def.attr || {};
         this.def.attr[attrName] = val;
         this.m.save();
@@ -1901,34 +1926,78 @@ class GraphNode {
             // Deep search and replaces the given property value "prevVal" with "newVal"
 
             // remove the ui of id "id" from interface
-            var removeFromInterface = (o, id) => {
-                let newObject = _.clone(o);
-                let remove = false;
-
-                _.each(o, (val, key) => {
-                    if (key == "node" && val === id) {
-                        remove = true;
-                    } else if (typeof(val) === 'object' || typeof(val) === 'array') {
-                        var cleaned = removeFromInterface(val, id);
-                        if (cleaned === "remove") {
-                            if (key === "dataset" || key === "attributes") {
-                                remove = true; // delete 1 more upper level
-                            } else {
-                                _.remove(newObject, (v, k) => k == key);
-                            }
+            // var removeFromInterface = (o, id) => {
+            //     let newObject = _.clone(o);
+
+            //     if (typeof o === "object" || typeof o === "array") {
+            //         for (let [key, val] of Object.entries(o)) {
+            //             let nodeId = _.get(val, ["attributes", "dataset", "node"]);
+            //             if (nodeId == id) {
+            //                 _.unset(newObject, key);
+            //             } else {
+            //                 newObject[key] = removeFromInterface(val, id);
+            //             }
+            //         }
+            //     }
+
+            //     return newObject;
+            // }
+            // app.interface = removeFromInterface(app.interface, this.id);
+
+            var getUIPath = (o, id, path = []) => {
+                let p = _.clone(path);
+                let identification = ["attributes", "dataset", "node"];
+
+                if (typeof o === "object" || typeof o === "array") {
+                    for (let [key, val] of Object.entries(o)) {
+                        let nodeId = _.get(val, identification);
+                        if (nodeId == id) {
+                            return path.concat(key);
                         } else {
-                            newObject[key] = cleaned;
+                            let fullpath = getUIPath(val, id, path.concat(key));
+                            if (fullpath !== null) {
+                                return fullpath;
+                            }
                         }
                     }
-                });
+                } else {
+                    return null;
+                }
 
-                if (remove) {
-                    return "remove";
+                // if we arrive here, we didn't find a valid path parcouring children nodes
+                return null;
+            }
+
+            var removePath = (json, path) => {
+                if (isNaN(parseInt(_.last(path)))) {
+                    _.unset(json, path); // not an array
                 } else {
-                    return newObject;
+                    // Check if it's an object or an element in an array
+                    if (path.length > 1) {
+                        let p = _.clone(path);
+                        let last = p.pop();
+
+                        let parent = _.get(json, p);
+                        if (Array.isArray(parent)) {
+                            // Array, use _.remove instead
+                            _.remove(parent, (v, k) => k == last);
+                            _.set(json, p, parent);
+                        } else {
+                            _.unset(json, path); // not an array
+                        }
+                    } else {
+                        _.unset(json, path); // not an array
+                    }
                 }
+
+                return json;
+            }
+
+            let UIFullPath = getUIPath(app.interface, this.id);
+            console.log("Found UI " + this.id + " at path " + UIFullPath);
+            if (UIFullPath !== null) {
+                app.interface = removePath(app.interface, UIFullPath);
             }
-            app.interface = removeFromInterface(app.interface, this.id);
 
             // remove this node from all app events (API) using it
             var removeFromAppEvents = (o, id) => {