@dualbox/editor 1.0.32 → 1.0.35

package/js/dist/GraphEditor.min.js

@@ -39476,7 +39476,7 @@ function () {
     value: function eachPackage(f) {
       var deps = this.getDependencies();
 
-      _import.each(deps.libs, function (version, name) {
+      _import.each(deps.lib, function (version, name) {
         f(name, version);
       });
 
@@ -39488,6 +39488,27 @@ function () {
         f(name, version);
       });
 
+      return this; // for chaining
+    }
+  }, {
+    key: "eachComponent",
+    value: function eachComponent(f) {
+      var _this = this;
+
+      var deps = this.getDependencies();
+
+      var applyArg = function applyArg(version, name) {
+        if (_this.isDualboxComponent(name)) {
+          f(name, version);
+        }
+      };
+
+      _import.each(deps.lib, applyArg);
+
+      _import.each(deps.module, applyArg);
+
+      _import.each(deps.ui, applyArg);
+
       return this; // for chaining
     } // f(panel, panelName)
 
@@ -39532,7 +39553,7 @@ function () {
   }, {
     key: "updateVersions",
     value: function updateVersions(map) {
-      var _this = this;
+      var _this2 = this;
 
       // update modules and UIs
       var updateJson = function updateJson(json, id) {
@@ -39550,9 +39571,9 @@ function () {
       _import.each(this.json.libs, function (version, name) {
         var newVersion = map[name];
 
-        if (newVersion && newVersion != _this.json.libs[name] && _this.json.version != "*") {
+        if (newVersion && newVersion != _this2.json.libs[name] && _this2.json.version != "*") {
           console.log('[*] updating ' + name + ' from ' + version + ' to ' + newVersion);
-          _this.json.libs[name] = newVersion;
+          _this2.json.libs[name] = newVersion;
         }
       });
 
@@ -39562,7 +39583,7 @@ function () {
   }, {
     key: "updateComponents",
     value: function updateComponents(dmap) {
-      var _this2 = this;
+      var _this3 = this;
 
       if (!dmap) {
         console.error("Dependencies map is mandatory in updateComponents.");
@@ -39603,21 +39624,21 @@ function () {
       _import.each(this.json.libs, function (version, name) {
         if (!libDeps[name] && natives.indexOf(name) == -1) {
           console.log('[*] removing lib ' + name);
-          delete _this2.json.libs[name];
+          delete _this3.json.libs[name];
         }
       }); // add the missing one
 
 
       _import.each(libDeps, function (version, name) {
-        if (_this2.json.libs && !_this2.json.libs[name]) {
+        if (_this3.json.libs && !_this3.json.libs[name]) {
           console.log("[*] adding lib " + name);
-          _this2.json.libs[name] = version;
+          _this3.json.libs[name] = version;
         }
       });
 
       _import.each(natives, function (n) {
-        if (_this2.json.libs && !_this2.json.libs[n]) {
-          _this2.json.libs[n] = "*";
+        if (_this3.json.libs && !_this3.json.libs[n]) {
+          _this3.json.libs[n] = "*";
         }
       });
 
@@ -39626,7 +39647,7 @@ function () {
   }, {
     key: "getDependencies",
     value: function getDependencies() {
-      var _this3 = this;
+      var _this4 = this;
 
       var deps = {
         lib: {
@@ -39644,7 +39665,7 @@ function () {
           console.error(('[*] Error while parsing app definition: module ' + json.module + ' exists in version ' + deps.module[json.module] + " and in version " + json.version).red);
         }
 
-        if (_this3.isDualboxPackage(json.module)) {
+        if (_this4.isDualboxPackage(json.module)) {
           deps.module[json.module] = json.version;
         }
       });
@@ -103791,238 +103812,241 @@ var jsplumb_6 = jsplumb.jsPlumb;
  *  Main class of the Graph Editor
  */
 class DualboxEditor {
-    // div: selector or jquery div
-    constructor(div, attrs) {
-        this.div = $(div);
-        this.div.addClass('main-editor-div');
-        this.attrs = attrs;
-
-        // export itself top window
-        window.dualboxEditor = this;
-
-        this.rootAppName = attrs.name ? attrs.name : "Application";
-
-        // MVC model
-        this.m = new GraphModel(this);
-        this.v = new GraphView(this, div, attrs);
-        this.c = new GraphController(this);
-
-        // bind links
-        this.v.m = this.c.m = this.m;
-        this.v.c = this.m.c = this.c;
-        this.c.v = this.m.v = this.v;
-
-        // cache for packages
-        this.packages = {};
-        this.DualBox = null; // local dualbox, for editor use
-
-        // the function to search for modules
-        // attr.search signature: search( text, cb )
-        // callback signature: cb( err, packages ), packages is an array of package.json
-        this.search = (text, type) => {
-            return new Promise((resolve, reject) => {
-                attrs.search(text, (err, packages) => {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        // cache packages in this.packages
-                        lodash.each(packages, (r) => {
-                            if (!this.packages[r.name]) {
-                                this.packages[r.name] = r;
-                            }
-                        });
-
-                        if (type) {
-                            packages = lodash.filter(packages, o => {
-                                return o.name.startsWith('@dualbox/dualbox-' + type)
-                                    || (type == "module" && o.name.startsWith('dualbox-core'))
-                            });
-                        }
-                        resolve(packages);
-                    }
-                });
+  // div: selector or jquery div
+  constructor(div, attrs) {
+    this.div = $(div);
+    this.div.addClass("main-editor-div");
+    this.attrs = attrs;
+
+    // export itself top window
+    window.dualboxEditor = this;
+
+    this.rootAppName = attrs.name ? attrs.name : "Application";
+
+    // MVC model
+    this.m = new GraphModel(this);
+    this.v = new GraphView(this, div, attrs);
+    this.c = new GraphController(this);
+
+    // bind links
+    this.v.m = this.c.m = this.m;
+    this.v.c = this.m.c = this.c;
+    this.c.v = this.m.v = this.v;
+
+    // cache for packages
+    this.packages = {};
+    this.DualBox = null; // local dualbox, for editor use
+
+    // the function to search for modules
+    // attr.search signature: search( text, cb )
+    // callback signature: cb( err, packages ), packages is an array of package.json
+    this.search = (text, type) => {
+      return new Promise((resolve, reject) => {
+        attrs.search(text, (err, packages) => {
+          if (err) {
+            reject(err);
+          } else {
+            // cache packages in this.packages
+            lodash.each(packages, r => {
+              if (!this.packages[r.name]) {
+                this.packages[r.name] = r;
+              }
             });
-        };
 
-        this.types = [];
-        this.getRootTypes = function () {
-            if (lodash.isEmpty(this.types)) {
-                return new Promise((resolve, reject) => {
-                    this.search('dualbox-type-').then((packages) => {
-                        this.types = lodash.filter(packages, (p) => {
-                            var isType = p.name.startsWith('@dualbox/dualbox-type');
-                            var hasTypeDef = lodash.get(p, "dualbox.type");
-
-                            if (isType && !hasTypeDef) {
-                                console.error('Type package ' + p.name + ' has no dualbox Type description.\n'
-                                    + 'Type was not imported');
-                            }
-                            return isType && hasTypeDef;
-                        });
-                        resolve(this.types);
-                    }).catch((e) => {
-                        reject(e);
-                    });
-                });
-            }
-            else {
-                return Promise.resolve(this.types);
+            if (type) {
+              packages = lodash.filter(packages, o => {
+                return (
+                  o.name.startsWith("@dualbox/dualbox-" + type) ||
+                  (type == "module" && o.name.startsWith("dualbox-core"))
+                );
+              });
             }
-        };
-
-        this.getAvailableTypes = async function () {
-            var types = await this.getRootTypes();
-            return lodash.map(types, t => lodash.get(t, "dualbox.type.name"));
-        };
-
+            resolve(packages);
+          }
+        });
+      });
+    };
 
-        // the function to find module by name and version (with cache)
-        // signature: find( name, version ), return a Promise which, when resolved, is a package.json
-        this.loadPackage = (name, version) => {
-            version = version || "*";
+    this.types = [];
+    this.getRootTypes = function() {
+      if (lodash.isEmpty(this.types)) {
+        return new Promise((resolve, reject) => {
+          this.search("dualbox-type-")
+            .then(packages => {
+              this.types = lodash.filter(packages, p => {
+                var isType = p.name.startsWith("@dualbox/dualbox-type");
+                var hasTypeDef = lodash.get(p, "dualbox.type");
+
+                if (isType && !hasTypeDef) {
+                  console.error(
+                    "Type package " +
+                      p.name +
+                      " has no dualbox Type description.\n" +
+                      "Type was not imported"
+                  );
+                }
+                return isType && hasTypeDef;
+              });
+              resolve(this.types);
+            })
+            .catch(e => {
+              reject(e);
+            });
+        });
+      } else {
+        return Promise.resolve(this.types);
+      }
+    };
 
-            return new Promise((resolve, reject) => {
-                if (name.startsWith('dualbox-core')) {
-                    var pkg = null;
-                    lodash.each(this.DualBox.core, (corePackage) => {
-                        if (corePackage.name == name) {
-                            pkg = corePackage;
-                            return false;
-                        }
-                    });
+    this.getAvailableTypes = async function() {
+      var types = await this.getRootTypes();
+      return lodash.map(types, t => lodash.get(t, "dualbox.type.name"));
+    };
 
-                    if (pkg) {
-                        this.packages[name] = pkg;
-                        resolve(pkg);
-                    }
-                    else {
-                        reject("Couldn't resolve core package: " + name);
-                    }
-                    return;
-                }
+    // the function to find module by name and version (with cache)
+    // signature: find( name, version ), return a Promise which, when resolved, is a package.json
+    this.loadPackage = (name, version) => {
+      version = version || "*";
 
-                var loadScript = (pkg, cb) => {
-                    if (attrs.load) {
-                        attrs.load(pkg.name, pkg.version, cb);
-                    }
-                    else {
-                        // Local editor. Bind the callback on the local script load
-                        var script = $('script[data-pkg="' + pkg.name + '"]');
-                        if (!script) {
-                            throw "Couldn't find script in the current document: " + pkg.name + ". Did you forget gulp link-editor ?";
-                        }
+      return new Promise((resolve, reject) => {
+        if (name.startsWith("dualbox-core")) {
+          var pkg = null;
+          lodash.each(this.DualBox.core, corePackage => {
+            if (corePackage.name == name) {
+              pkg = corePackage;
+              return false;
+            }
+          });
 
-                        if (script.attr('data-loaded') === "true") {
-                            cb();
-                            return;
-                        }
-                        else {
-                            script[0].addEventListener("error", function () {
-                                throw "Failed to load script " + pkg.name;
-                            });
+          if (pkg) {
+            this.packages[name] = pkg;
+            resolve(pkg);
+          } else {
+            reject("Couldn't resolve core package: " + name);
+          }
+          return;
+        }
 
-                            var timeout = setTimeout(function () {
-                                cb("Failed to load " + pkg.name + " after 5 seconds");
-                            }, 5000);
-                            script[0].addEventListener("load", () => {
-                                clearTimeout(timeout);
-                                cb();
-                            });
-                        }
-                    }
-                };
+        var loadScript = (pkg, cb) => {
+          if (attrs.load) {
+            attrs.load(pkg.name, pkg.version, cb);
+          } else {
+            // Local editor. Bind the callback on the local script load
+            var script = $('script[data-pkg="' + pkg.name + '"]');
+            if (!script) {
+              throw "Couldn't find script in the current document: " +
+                pkg.name +
+                ". Did you forget gulp link-editor ?";
+            }
 
-                // we need to find the package.json and make sure the script is loaded
-                if (this.packages[name]) {
-                    try {
-                        loadScript(this.packages[name], (err) => {
-                            if (err) reject(err);
-                            else resolve(this.packages[name]);
-                        });
-                    }
-                    catch (e) {
-                        reject(e);
-                    }
-                }
-                else {
-                    // mark the package as beeing resolved
-                    attrs.find(name, version, (err, result) => {
-                        if (err) {
-                            reject(err);
-                        }
-                        else {
-                            this.packages[name] = result; // cache result
-                            loadScript(this.packages[name], (err) => {
-                                if (err) reject(err);
-                                else resolve(result);
-                            });
-                        }
-                    });
-                }
-            })
+            if (script.attr("data-loaded") === "true") {
+              cb();
+              return;
+            } else {
+              script[0].addEventListener("error", function() {
+                throw "Failed to load script " + pkg.name;
+              });
+
+              var timeout = setTimeout(function() {
+                cb("Failed to load " + pkg.name + " after 5 seconds");
+              }, 5000);
+              script[0].addEventListener("load", () => {
+                clearTimeout(timeout);
+                cb();
+              });
+            }
+          }
         };
 
-        // the function to require a dualbox module
-        this.require = (name, version, cb) => {
-            return require(name); // TODO: local only for now
+        var onLoadedScript = err => {
+          if (err) {
+            reject(err);
+          } else {
+            require(name); // make sure the package is required at least once
+            resolve(this.packages[name]);
+          }
         };
 
-
-        // Safety when the user leave the page,
-        // if not already defined externally
-        if (!window.onbeforeunload) {
-            window.onbeforeunload = function () {
-                return "Unsaved changes will be lost, are you sure you want to leave the editor?";
-            };
+        // we need to find the package.json and make sure the script is loaded
+        if (this.packages[name]) {
+          try {
+            loadScript(this.packages[name], onLoadedScript);
+          } catch (e) {
+            reject(e);
+          }
+        } else {
+          // mark the package as beeing resolved
+          attrs.find(name, version, (err, result) => {
+            if (err) {
+              reject(err);
+            } else {
+              this.packages[name] = result; // cache result
+              loadScript(this.packages[name], onLoadedScript);
+            }
+          });
         }
+      });
+    };
 
-        this.loadCorePackages();
+    // the function to require a dualbox module
+    this.require = (name, version, cb) => {
+      return require(name); // TODO: local only for now
+    };
 
-        if (attrs.json) {
-            this.onReady(() => {
-                var p = this.setApp(attrs.json);
-                if (attrs.onLoaded) {
-                    p.then(attrs.onLoaded);
-                }
-            });
-        }
+    // Safety when the user leave the page,
+    // if not already defined externally
+    if (!window.onbeforeunload) {
+      window.onbeforeunload = function() {
+        return "Unsaved changes will be lost, are you sure you want to leave the editor?";
+      };
     }
 
-    // call cb when the editor is initialized
-    onReady(cb) {
-        this.v.onReady(cb);
+    this.loadCorePackages();
+
+    if (attrs.json) {
+      this.onReady(() => {
+        var p = this.setApp(attrs.json);
+        if (attrs.onLoaded) {
+          p.then(attrs.onLoaded);
+        }
+      });
     }
+  }
 
-    async loadCorePackages() {
+  // call cb when the editor is initialized
+  onReady(cb) {
+    this.v.onReady(cb);
+  }
 
-        await this.loadPackage('@dualbox/dualbox');
-        this.DualBox = window.DualBox = this.require('@dualbox/dualbox');
-        lodash.each(this.DualBox.core, async (corePackage) => {
-            await this.loadPackage(corePackage.name);
-        });
-    }
+  async loadCorePackages() {
 
-    setApp(json) {
-        return this.c.load(json);
-    }
+    await this.loadPackage("@dualbox/dualbox");
+    this.DualBox = window.DualBox = this.require("@dualbox/dualbox");
+    lodash.each(this.DualBox.core, async corePackage => {
+      await this.loadPackage(corePackage.name);
+    });
+  }
 
-    getApp() {
-        this.m.get();
-    }
+  setApp(json) {
+    return this.c.load(json);
+  }
 
-    // load all packages needed in the json
-    // return a Promise
-    loadPackages(json) {
-        var promises = []; // array of promises
-        this.promises = promises;
+  getApp() {
+    this.m.get();
+  }
 
-        var parser = new AppParser_1(json);
-        parser.eachPackage((name, version) => {
-            promises.push(this.loadPackage(name, version));
-        });
+  // load all packages needed in the json
+  // return a Promise
+  loadPackages(json) {
+    var promises = []; // array of promises
+    this.promises = promises;
 
-        /*
+    var parser = new AppParser_1(json);
+    parser.eachComponent((name, version) => {
+      promises.push(this.loadPackage(name, version));
+    });
+
+    /*
         // also load core nodes
         promises.push(this.loadPackage('dualbox-core-if', '*'));
         promises.push(this.loadPackage('dualbox-core-value', '*'));
@@ -104032,24 +104056,23 @@ class DualboxEditor {
         promises.push(this.loadPackage('dualbox-core-switch', '*'));
         */
 
-        return Promise.all(promises);
-    }
+    return Promise.all(promises);
+  }
 
-    // sync version of this.loadPackage. Will crash if the package has not been loaded yet
-    getPackage(name, version) {
-        if (this.packages[name] === undefined) {
-            throw "Package " + name + " has not been loaded yet.";
-        }
-        return this.packages[name];
-    };
+  // sync version of this.loadPackage. Will crash if the package has not been loaded yet
+  getPackage(name, version) {
+    if (this.packages[name] === undefined) {
+      throw "Package " + name + " has not been loaded yet.";
+    }
+    return this.packages[name];
+  }
 }
 
 // try to export in window if in browser context
 try {
-    window.DualboxEditor = DualboxEditor;
-}
-catch (e) {
-    console.log('Could not export to window: ' + e);
+  window.DualboxEditor = DualboxEditor;
+} catch (e) {
+  console.log("Could not export to window: " + e);
 }
 
 //export default DualboxEditor;