@dualbox/editor 1.0.35 → 1.0.37

package/js/dist/GraphEditor.min.js

@@ -103812,267 +103812,271 @@ 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;
-              }
+    // 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);
+                    }
+                });
             });
+        };
 
-            if (type) {
-              packages = lodash.filter(packages, o => {
-                return (
-                  o.name.startsWith("@dualbox/dualbox-" + type) ||
-                  (type == "module" && o.name.startsWith("dualbox-core"))
-                );
-              });
+        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);
             }
-            resolve(packages);
-          }
-        });
-      });
-    };
+        };
 
-    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);
-      }
-    };
+        this.getAvailableTypes = async function () {
+            var types = await this.getRootTypes();
+            return lodash.map(types, t => lodash.get(t, "dualbox.type.name"));
+        };
 
-    this.getAvailableTypes = async function() {
-      var types = await this.getRootTypes();
-      return lodash.map(types, t => lodash.get(t, "dualbox.type.name"));
-    };
+        // 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 || "*";
+
+            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;
+                        }
+                    });
 
-    // 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 || "*";
+                    if (pkg) {
+                        this.packages[name] = pkg;
+                        resolve(pkg);
+                    } else {
+                        reject("Couldn't resolve core package: " + name);
+                    }
+                    return;
+                }
 
-      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;
-            }
-          });
+                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 ?";
+                        }
 
-          if (pkg) {
-            this.packages[name] = pkg;
-            resolve(pkg);
-          } else {
-            reject("Couldn't resolve core package: " + name);
-          }
-          return;
-        }
+                        if (script.attr("data-loaded") === "true") {
+                            cb();
+                            return;
+                        } else {
+                            script[0].addEventListener("error", function () {
+                                throw "Failed to load script " + pkg.name;
+                            });
 
-        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 ?";
-            }
+                            var timeout = setTimeout(function () {
+                                cb("Failed to load " + pkg.name + " after 5 seconds");
+                            }, 5000);
+                            script[0].addEventListener("load", () => {
+                                clearTimeout(timeout);
+                                cb();
+                            });
+                        }
+                    }
+                };
 
-            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();
-              });
-            }
-          }
+                var onLoadedScript = err => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        window.require(name); // make sure the package is required at least once
+                        resolve(this.packages[name]);
+                    }
+                };
+
+                // 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);
+                        }
+                    });
+                }
+            });
         };
 
-        var onLoadedScript = err => {
-          if (err) {
-            reject(err);
-          } else {
-            require(name); // make sure the package is required at least once
-            resolve(this.packages[name]);
-          }
+        // the function to require a dualbox module
+        this.require = (name, version, cb) => {
+            return require(name); // TODO: local only for now
         };
 
-        // 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);
-            }
-          });
+        // 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?";
+            };
         }
-      });
-    };
-
-    // the function to require a dualbox module
-    this.require = (name, version, cb) => {
-      return require(name); // TODO: local only for now
-    };
-
-    // 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?";
-      };
-    }
 
-    this.loadCorePackages();
+        this.loadCorePackages();
 
-    if (attrs.json) {
-      this.onReady(() => {
-        var p = this.setApp(attrs.json);
-        if (attrs.onLoaded) {
-          p.then(attrs.onLoaded);
+        if (attrs.json) {
+            this.onReady(() => {
+                var p = this.setApp(attrs.json);
+                if (attrs.onLoaded) {
+                    p.then(attrs.onLoaded);
+                }
+            });
         }
-      });
     }
-  }
 
-  // call cb when the editor is initialized
-  onReady(cb) {
-    this.v.onReady(cb);
-  }
+    // call cb when the editor is initialized
+    onReady(cb) {
+        this.v.onReady(cb);
+    }
 
-  async loadCorePackages() {
+    async loadCorePackages() {
 
-    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);
-    });
-  }
+        await this.loadPackage("@dualbox/dualbox");
+        if (!window.DualBox && window.DualBox.start) {
+            this.DualBox = window.DualBox = this.require("@dualbox/dualbox");
+        } else {
+            this.DualBox = window.DualBox;
+        }
+        lodash.each(this.DualBox.core, async corePackage => {
+            await this.loadPackage(corePackage.name);
+        });
+    }
 
-  setApp(json) {
-    return this.c.load(json);
-  }
+    setApp(json) {
+        return this.c.load(json);
+    }
 
-  getApp() {
-    this.m.get();
-  }
+    getApp() {
+        this.m.get();
+    }
 
-  // load all packages needed in the json
-  // return a Promise
-  loadPackages(json) {
-    var promises = []; // array of promises
-    this.promises = promises;
+    // 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));
-    });
+        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', '*'));
-        promises.push(this.loadPackage('dualbox-core-from-json', '*'));
-        promises.push(this.loadPackage('dualbox-core-to-json', '*'));
-        promises.push(this.loadPackage('dualbox-core-script', '*'));
-        promises.push(this.loadPackage('dualbox-core-switch', '*'));
-        */
+        /*
+            // also load core nodes
+            promises.push(this.loadPackage('dualbox-core-if', '*'));
+            promises.push(this.loadPackage('dualbox-core-value', '*'));
+            promises.push(this.loadPackage('dualbox-core-from-json', '*'));
+            promises.push(this.loadPackage('dualbox-core-to-json', '*'));
+            promises.push(this.loadPackage('dualbox-core-script', '*'));
+            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.";
+    // 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];
     }
-    return this.packages[name];
-  }
 }
 
 // try to export in window if in browser context
 try {
-  window.DualboxEditor = DualboxEditor;
+    window.DualboxEditor = DualboxEditor;
 } catch (e) {
-  console.log("Could not export to window: " + e);
+    console.log("Could not export to window: " + e);
 }
 
 //export default DualboxEditor;