Enable eslit for mindplot

packages/mindplot/.eslintrc.json

@@ -0,0 +1,11 @@
+{
+    "env": {
+        "browser": true,
+        "commonjs": true
+    },
+    "extends": [
+        "airbnb-base"
+    ],
+    "plugins": ["only-warn"],
+    "rules": {}
+}

packages/mindplot/lib/components/ActionDispatcher.js

@@ -20,85 +20,85 @@ const Events = require('./Events').default;
 // noinspection JSUnusedLocalSymbols
 const ActionDispatcher = new Class({
   Implements: [Events],
-    initialize: function(commandContext) {
-        $assert(commandContext, "commandContext can not be null");
+  initialize(commandContext) {
+    $assert(commandContext, 'commandContext can not be null');
   },
 
-    addRelationship: function(model, mindmap) {
-        throw "method must be implemented.";
+  addRelationship(model, mindmap) {
+    throw 'method must be implemented.';
   },
 
-    addTopics: function(models, parentTopicId) {
-        throw "method must be implemented.";
+  addTopics(models, parentTopicId) {
+    throw 'method must be implemented.';
   },
 
-    deleteEntities: function(topicsIds, relIds) {
-        throw "method must be implemented.";
+  deleteEntities(topicsIds, relIds) {
+    throw 'method must be implemented.';
   },
 
-    dragTopic: function(topicId, position, order, parentTopic) {
-        throw "method must be implemented.";
+  dragTopic(topicId, position, order, parentTopic) {
+    throw 'method must be implemented.';
   },
 
-    moveTopic: function(topicId, position) {
-        throw "method must be implemented.";
+  moveTopic(topicId, position) {
+    throw 'method must be implemented.';
   },
 
-    moveControlPoint: function(ctrlPoint, point) {
-        throw "method must be implemented.";
+  moveControlPoint(ctrlPoint, point) {
+    throw 'method must be implemented.';
   },
 
-    changeFontFamilyToTopic: function(topicIds, fontFamily) {
-        throw "method must be implemented.";
+  changeFontFamilyToTopic(topicIds, fontFamily) {
+    throw 'method must be implemented.';
   },
 
-    changeFontStyleToTopic: function(topicsIds) {
-        throw "method must be implemented.";
+  changeFontStyleToTopic(topicsIds) {
+    throw 'method must be implemented.';
   },
 
-    changeFontColorToTopic: function(topicsIds, color) {
-        throw "method must be implemented.";
+  changeFontColorToTopic(topicsIds, color) {
+    throw 'method must be implemented.';
   },
 
-    changeFontSizeToTopic : function(topicsIds, size) {
-        throw "method must be implemented.";
+  changeFontSizeToTopic(topicsIds, size) {
+    throw 'method must be implemented.';
   },
 
-    changeBackgroundColorToTopic: function(topicsIds, color) {
-        throw "method must be implemented.";
+  changeBackgroundColorToTopic(topicsIds, color) {
+    throw 'method must be implemented.';
   },
 
-    changeBorderColorToTopic: function(topicsIds, color) {
-        throw "method must be implemented.";
+  changeBorderColorToTopic(topicsIds, color) {
+    throw 'method must be implemented.';
   },
 
-    changeShapeTypeToTopic : function(topicsIds, shapeType) {
-        throw "method must be implemented.";
+  changeShapeTypeToTopic(topicsIds, shapeType) {
+    throw 'method must be implemented.';
   },
 
-    changeFontWeightToTopic : function(topicsIds) {
-        throw "method must be implemented.";
+  changeFontWeightToTopic(topicsIds) {
+    throw 'method must be implemented.';
   },
 
-    changeTextToTopic : function(topicsIds, text) {
-        throw "method must be implemented.";
+  changeTextToTopic(topicsIds, text) {
+    throw 'method must be implemented.';
   },
 
-    shrinkBranch : function(topicsIds, collapse) {
-        throw "method must be implemented.";
+  shrinkBranch(topicsIds, collapse) {
+    throw 'method must be implemented.';
   },
 
-    addFeatureToTopic : function(topicId, type, attributes) {
-        throw "method must be implemented.";
+  addFeatureToTopic(topicId, type, attributes) {
+    throw 'method must be implemented.';
   },
 
-    changeFeatureToTopic : function(topicId, featureId, attributes) {
-        throw "method must be implemented.";
+  changeFeatureToTopic(topicId, featureId, attributes) {
+    throw 'method must be implemented.';
   },
 
-    removeFeatureFromTopic : function(topicId, featureId) {
-        throw "method must be implemented.";
-    }
+  removeFeatureFromTopic(topicId, featureId) {
+    throw 'method must be implemented.';
+  },
 });
 
 ActionDispatcher.setInstance = function (dispatcher) {

packages/mindplot/lib/components/ActionIcon.js

@@ -19,46 +19,46 @@ const Icon = require('./Icon').default;
 
 const ActionIcon = new Class({
   Extends: Icon,
-    initialize: function(topic, url) {
+  initialize(topic, url) {
     this.parent(url);
     this._node = topic;
   },
-    getNode:function() {
+  getNode() {
     return this._node;
   },
 
-    setPosition:function(x, y) {
-        var size = this.getSize();
+  setPosition(x, y) {
+    const size = this.getSize();
     this.getImage().setPosition(x - size.width / 2, y - size.height / 2);
   },
 
-    addEvent:function(event, fn) {
+  addEvent(event, fn) {
     this.getImage().addEvent(event, fn);
   },
 
-    addToGroup:function(group) {
+  addToGroup(group) {
     group.append(this.getImage());
   },
 
-    setVisibility:function(visible) {
+  setVisibility(visible) {
     this.getImage().setVisibility(visible);
   },
 
-    isVisible:function() {
+  isVisible() {
     return this.getImage().isVisible();
   },
 
-    setCursor:function(cursor) {
+  setCursor(cursor) {
     return this.getImage().setCursor(cursor);
   },
 
-    moveToBack:function(cursor) {
+  moveToBack(cursor) {
     return this.getImage().moveToBack(cursor);
   },
 
-    moveToFront:function(cursor) {
+  moveToFront(cursor) {
     return this.getImage().moveToFront(cursor);
-    }
+  },
 });
 
 export default ActionIcon;

packages/mindplot/lib/components/CentralTopic.js

@@ -16,6 +16,7 @@
  *   limitations under the License.
  */
 const Core = require('@wismapping/core-js');
+
 const core = Core();
 const Topic = require('./Topic').default;
 const Shape = require('./util/Shape').default;
@@ -29,53 +30,53 @@ const CentralTopic = new Class(
          * @param model
          * @param options
          */
-        initialize: function (model, options) {
+    initialize(model, options) {
       this.parent(model, options);
     },
 
-        _registerEvents: function () {
+    _registerEvents() {
       this.parent();
 
       // This disable the drag of the central topic. But solves the problem of deselecting the nodes when the screen is clicked.
-            this.addEvent('mousedown', function (event) {
+      this.addEvent('mousedown', (event) => {
         event.stopPropagation();
       });
     },
 
     /** */
-        workoutIncomingConnectionPoint: function () {
+    workoutIncomingConnectionPoint() {
       return this.getPosition();
     },
 
     /** */
-        setCursor: function (type) {
+    setCursor(type) {
       type = type == 'move' ? 'default' : type;
       this.parent(type);
     },
 
     /** */
-        updateTopicShape: function () {},
+    updateTopicShape() {},
 
-        _updatePositionOnChangeSize: function () {
+    _updatePositionOnChangeSize() {
       // Center main topic ...
-            var zeroPoint = new core.Point(0, 0);
+      const zeroPoint = new core.Point(0, 0);
       this.setPosition(zeroPoint);
     },
 
     /** */
-        getShrinkConnector: function () {
+    getShrinkConnector() {
       return null;
     },
 
     /** */
-        workoutOutgoingConnectionPoint: function (targetPosition) {
+    workoutOutgoingConnectionPoint(targetPosition) {
       $assert(targetPosition, 'targetPoint can not be null');
-            var pos = this.getPosition();
-            var isAtRight = Shape.isAtRight(targetPosition, pos);
-            var size = this.getSize();
+      const pos = this.getPosition();
+      const isAtRight = Shape.isAtRight(targetPosition, pos);
+      const size = this.getSize();
       return Shape.calculateRectConnectionPoint(pos, size, !isAtRight);
     },
-    }
+  },
 );
 
 export default CentralTopic;

packages/mindplot/lib/components/Command.js

@@ -21,46 +21,40 @@ const Command = new Class(/** @lends mindplot.Command */{
      * @classdesc The command base class for handling do/undo mindmap operations
      * @constructs
      */
-    initialize: function()
-    {
+  initialize() {
     this._id = Command._nextUUID();
   },
 
   /**
      * @abstract
      */
-    execute: function(commandContext)
-    {
-        throw "execute must be implemented.";
+  execute(commandContext) {
+    throw 'execute must be implemented.';
   },
 
   /**
      * Triggered by the undo button - reverses the executed command
      * @abstract
      */
-    undoExecute: function(commandContext)
-    {
-        throw "undo must be implemented.";
+  undoExecute(commandContext) {
+    throw 'undo must be implemented.';
   },
 
   /**
      * Returns the unique id of this command
      * @returns {Number} command id
      */
-    getId:function()
-    {
+  getId() {
     return this._id;
-    }
+  },
 });
 
-Command._nextUUID = function()
-{
-    if (!$defined(Command._uuid))
-    {
+Command._nextUUID = function () {
+  if (!$defined(Command._uuid)) {
     Command._uuid = 1;
   }
 
-    Command._uuid = Command._uuid + 1;
+  Command._uuid += 1;
   return Command._uuid;
 };
 

packages/mindplot/lib/components/ConnectionLine.js

@@ -16,8 +16,10 @@
  *   limitations under the License.
  */
 const Core = require('@wismapping/core-js');
+
 const core = Core();
 const web2D = require('@wismapping/web2d');
+
 const web2d = web2D();
 
 const INodeModel = require('./model/INodeModel').default;
@@ -25,7 +27,7 @@ const { TopicShape } = require('./model/INodeModel');
 const Topic = require('./Topic').default;
 
 const ConnectionLine = new Class({
-    initialize: function (sourceNode, targetNode, lineType) {
+  initialize(sourceNode, targetNode, lineType) {
     $assert(targetNode, 'parentNode node can not be null');
     $assert(sourceNode, 'childNode node can not be null');
     $assert(sourceNode != targetNode, 'Circular connection');
@@ -33,8 +35,8 @@ const ConnectionLine = new Class({
     this._targetTopic = targetNode;
     this._sourceTopic = sourceNode;
 
-        var line;
-        var ctrlPoints = this._getCtrlPoints(sourceNode, targetNode);
+    let line;
+    const ctrlPoints = this._getCtrlPoints(sourceNode, targetNode);
     if (targetNode.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
       line = this._createLine(lineType, ConnectionLine.CURVED);
       line.setSrcControlPoint(ctrlPoints[0]);
@@ -45,27 +47,27 @@ const ConnectionLine = new Class({
       line.setDestControlPoint(ctrlPoints[1]);
     }
     // Set line styles ...
-        var strokeColor = ConnectionLine.getStrokeColor();
+    const strokeColor = ConnectionLine.getStrokeColor();
     line.setStroke(1, 'solid', strokeColor, 1);
     line.setFill(strokeColor, 1);
 
     this._line2d = line;
   },
 
-    _getCtrlPoints: function (sourceNode, targetNode) {
-        var srcPos = sourceNode.workoutOutgoingConnectionPoint(targetNode.getPosition());
-        var destPos = targetNode.workoutIncomingConnectionPoint(sourceNode.getPosition());
-        var deltaX = (srcPos.x - destPos.x) / 3;
+  _getCtrlPoints(sourceNode, targetNode) {
+    const srcPos = sourceNode.workoutOutgoingConnectionPoint(targetNode.getPosition());
+    const destPos = targetNode.workoutIncomingConnectionPoint(sourceNode.getPosition());
+    const deltaX = (srcPos.x - destPos.x) / 3;
     return [new core.Point(deltaX, 0), new core.Point(-deltaX, 0)];
   },
 
-    _createLine: function (lineType, defaultStyle) {
+  _createLine(lineType, defaultStyle) {
     if (!$defined(lineType)) {
       lineType = defaultStyle;
     }
     lineType = parseInt(lineType);
     this._lineType = lineType;
-        var line = null;
+    let line = null;
     switch (lineType) {
       case ConnectionLine.POLYLINE:
         line = new web2d.PolyLine();
@@ -84,27 +86,28 @@ const ConnectionLine = new Class({
     return line;
   },
 
-    setVisibility: function (value) {
+  setVisibility(value) {
     this._line2d.setVisibility(value);
   },
 
-    isVisible: function () {
+  isVisible() {
     return this._line2d.isVisible();
   },
 
-    setOpacity: function (opacity) {
+  setOpacity(opacity) {
     this._line2d.setOpacity(opacity);
   },
 
-    redraw: function () {
-        var line2d = this._line2d;
-        var sourceTopic = this._sourceTopic;
-        var sourcePosition = sourceTopic.getPosition();
+  redraw() {
+    const line2d = this._line2d;
+    const sourceTopic = this._sourceTopic;
+    const sourcePosition = sourceTopic.getPosition();
 
-        var targetTopic = this._targetTopic;
-        var targetPosition = targetTopic.getPosition();
+    const targetTopic = this._targetTopic;
+    const targetPosition = targetTopic.getPosition();
 
-        var sPos, tPos;
+    let sPos; let
+      tPos;
     sPos = sourceTopic.workoutOutgoingConnectionPoint(targetPosition);
     tPos = targetTopic.workoutIncomingConnectionPoint(sourcePosition);
 
@@ -112,7 +115,7 @@ const ConnectionLine = new Class({
     line2d.setTo(sPos.x, sPos.y);
 
     if (line2d.getType() == 'CurvedLine') {
-            var ctrlPoints = this._getCtrlPoints(this._sourceTopic, this._targetTopic);
+      const ctrlPoints = this._getCtrlPoints(this._sourceTopic, this._targetTopic);
       line2d.setSrcControlPoint(ctrlPoints[0]);
       line2d.setDestControlPoint(ctrlPoints[1]);
     }
@@ -121,19 +124,20 @@ const ConnectionLine = new Class({
     this._positionateConnector(targetTopic);
   },
 
-    _positionateConnector: function (targetTopic) {
-        var targetPosition = targetTopic.getPosition();
-        var offset = Topic.CONNECTOR_WIDTH / 2;
-        var targetTopicSize = targetTopic.getSize();
-        var y, x;
+  _positionateConnector(targetTopic) {
+    const targetPosition = targetTopic.getPosition();
+    const offset = Topic.CONNECTOR_WIDTH / 2;
+    const targetTopicSize = targetTopic.getSize();
+    let y; let
+      x;
     if (targetTopic.getShapeType() == TopicShape.LINE) {
       y = targetTopicSize.height;
     } else {
       y = targetTopicSize.height / 2;
     }
-        y = y - offset;
+    y -= offset;
 
-        var connector = targetTopic.getShrinkConnector();
+    const connector = targetTopic.getShrinkConnector();
     if ($defined(connector)) {
       if (Math.sign(targetPosition.x) > 0) {
         x = targetTopicSize.width;
@@ -145,56 +149,56 @@ const ConnectionLine = new Class({
     }
   },
 
-    setStroke: function (color, style, opacity) {
+  setStroke(color, style, opacity) {
     this._line2d.setStroke(null, null, color, opacity);
   },
 
-    addToWorkspace: function (workspace) {
+  addToWorkspace(workspace) {
     workspace.append(this._line2d);
     this._line2d.moveToBack();
   },
 
-    removeFromWorkspace: function (workspace) {
+  removeFromWorkspace(workspace) {
     workspace.removeChild(this._line2d);
   },
 
-    getTargetTopic: function () {
+  getTargetTopic() {
     return this._targetTopic;
   },
 
-    getSourceTopic: function () {
+  getSourceTopic() {
     return this._sourceTopic;
   },
 
-    getLineType: function () {
+  getLineType() {
     return this._lineType;
   },
 
-    getLine: function () {
+  getLine() {
     return this._line2d;
   },
 
-    getModel: function () {
+  getModel() {
     return this._model;
   },
 
-    setModel: function (model) {
+  setModel(model) {
     this._model = model;
   },
 
-    getType: function () {
+  getType() {
     return 'ConnectionLine';
   },
 
-    getId: function () {
+  getId() {
     return this._model.getId();
   },
 
-    moveToBack: function () {
+  moveToBack() {
     this._line2d.moveToBack();
   },
 
-    moveToFront: function () {
+  moveToFront() {
     this._line2d.moveToFront();
   },
 });

packages/mindplot/lib/components/ControlPoint.js

@@ -15,62 +15,64 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const Core = require('@wismapping/core-js')
+const Core = require('@wismapping/core-js');
+
 const core = Core();
-const web2D = require('@wismapping/web2d')
+const web2D = require('@wismapping/web2d');
+
 const web2d = web2D();
 
-const Shape = require('./util/Shape').default
+const Shape = require('./util/Shape').default;
 const ActionDispatcher = require('./ActionDispatcher').default;
 
 const ControlPoint = new Class({
-    initialize: function () {
-        var control1 = new web2d.Elipse({
+  initialize() {
+    const control1 = new web2d.Elipse({
       width: 6,
       height: 6,
       stroke: '1 solid #6589de',
       fillColor: 'gray',
-            visibility: false
+      visibility: false,
     });
     control1.setCursor('pointer');
 
-        var control2 = new web2d.Elipse({
+    const control2 = new web2d.Elipse({
       width: 6,
       height: 6,
       stroke: '1 solid #6589de',
       fillColor: 'gray',
-            visibility: false
+      visibility: false,
     });
     control2.setCursor('pointer');
 
     this._controlPointsController = [control1, control2];
-        this._controlLines = [new web2d.Line({strokeColor: "#6589de", strokeWidth: 1, opacity: 0.3}),
-            new web2d.Line({strokeColor: "#6589de", strokeWidth: 1, opacity: 0.3})];
+    this._controlLines = [new web2d.Line({ strokeColor: '#6589de', strokeWidth: 1, opacity: 0.3 }),
+      new web2d.Line({ strokeColor: '#6589de', strokeWidth: 1, opacity: 0.3 })];
 
     this._isBinded = false;
-        var me = this;
-        this._controlPointsController[0].addEvent('mousedown', function (event) {
+    const me = this;
+    this._controlPointsController[0].addEvent('mousedown', (event) => {
       (me._mouseDown)(event, ControlPoint.FROM, me);
     });
-        this._controlPointsController[0].addEvent('click', function (event) {
+    this._controlPointsController[0].addEvent('click', (event) => {
       (me._mouseClick)(event);
     });
-        this._controlPointsController[0].addEvent('dblclick', function (event) {
+    this._controlPointsController[0].addEvent('dblclick', (event) => {
       (me._mouseClick)(event);
     });
 
-        this._controlPointsController[1].addEvent('mousedown', function (event) {
+    this._controlPointsController[1].addEvent('mousedown', (event) => {
       (me._mouseDown)(event, ControlPoint.TO, me);
     });
-        this._controlPointsController[1].addEvent('click', function (event) {
+    this._controlPointsController[1].addEvent('click', (event) => {
       (me._mouseClick)(event);
     });
-        this._controlPointsController[1].addEvent('dblclick', function (event) {
+    this._controlPointsController[1].addEvent('dblclick', (event) => {
       (me._mouseClick)(event);
     });
   },
 
-    setLine: function (line) {
+  setLine(line) {
     if ($defined(this._line)) {
       this._removeLine();
     }
@@ -84,14 +86,13 @@ const ControlPoint = new Class({
     this._endPoint[1] = this._line.getLine().getTo().clone();
   },
 
-    redraw: function () {
-        if ($defined(this._line))
-            this._createControlPoint();
+  redraw() {
+    if ($defined(this._line)) this._createControlPoint();
   },
 
-    _createControlPoint: function () {
+  _createControlPoint() {
     this._controls = this._line.getLine().getControlPoints();
-        var pos = this._line.getLine().getFrom();
+    let pos = this._line.getLine().getFrom();
     this._controlPointsController[0].setPosition(this._controls[ControlPoint.FROM].x + pos.x, this._controls[ControlPoint.FROM].y + pos.y - 3);
     this._controlLines[0].setFrom(pos.x, pos.y);
     this._controlLines[0].setTo(this._controls[ControlPoint.FROM].x + pos.x + 3, this._controls[ControlPoint.FROM].y + pos.y);
@@ -99,14 +100,13 @@ const ControlPoint = new Class({
     this._controlLines[1].setFrom(pos.x, pos.y);
     this._controlLines[1].setTo(this._controls[ControlPoint.TO].x + pos.x + 3, this._controls[ControlPoint.TO].y + pos.y);
     this._controlPointsController[1].setPosition(this._controls[ControlPoint.TO].x + pos.x, this._controls[ControlPoint.TO].y + pos.y - 3);
+  },
+
+  _removeLine() {
 
   },
 
-    _removeLine: function () {
-
-    },
-
-    _mouseDown: function (event, point, me) {
+  _mouseDown(event, point, me) {
     if (!this._isBinded) {
       this._isBinded = true;
       this._mouseMoveFunction = function (event) {
@@ -124,11 +124,11 @@ const ControlPoint = new Class({
     return false;
   },
 
-    _mouseMoveEvent: function (event, point) {
-        var screen = this._workspace.getScreenManager();
-        var pos = screen.getWorkspaceMousePosition(event);
+  _mouseMoveEvent(event, point) {
+    const screen = this._workspace.getScreenManager();
+    const pos = screen.getWorkspaceMousePosition(event);
 
-        var cords;
+    let cords;
     if (point == 0) {
       cords = Shape.calculateRelationShipPointCoordinates(this._line.getSourceTopic(), pos);
       this._line.setFrom(cords.x, cords.y);
@@ -145,25 +145,24 @@ const ControlPoint = new Class({
     this._controlLines[point].setFrom(cords.x, cords.y);
     this._controlLines[point].setTo(pos.x - 2, pos.y);
     this._line.getLine().updateLine(point);
-
   },
 
-    _mouseUp: function (event, point) {
+  _mouseUp(event, point) {
     this._workspace.getScreenManager().removeEvent('mousemove', this._mouseMoveFunction);
     this._workspace.getScreenManager().removeEvent('mouseup', this._mouseUpFunction);
 
-        var actionDispatcher = ActionDispatcher.getInstance();
+    const actionDispatcher = ActionDispatcher.getInstance();
     actionDispatcher.moveControlPoint(this, point);
     this._isBinded = false;
   },
 
-    _mouseClick: function (event) {
+  _mouseClick(event) {
     event.preventDefault();
     event.stopPropagation();
     return false;
   },
 
-    setVisibility: function (visible) {
+  setVisibility(visible) {
     if (visible) {
       this._controlLines[0].moveToFront();
       this._controlLines[1].moveToFront();
@@ -176,7 +175,7 @@ const ControlPoint = new Class({
     this._controlLines[1].setVisibility(visible);
   },
 
-    addToWorkspace: function (workspace) {
+  addToWorkspace(workspace) {
     this._workspace = workspace;
     workspace.append(this._controlPointsController[0]);
     workspace.append(this._controlPointsController[1]);
@@ -184,7 +183,7 @@ const ControlPoint = new Class({
     workspace.append(this._controlLines[1]);
   },
 
-    removeFromWorkspace: function (workspace) {
+  removeFromWorkspace(workspace) {
     this._workspace = null;
     workspace.removeChild(this._controlPointsController[0]);
     workspace.removeChild(this._controlPointsController[1]);
@@ -192,17 +191,17 @@ const ControlPoint = new Class({
     workspace.removeChild(this._controlLines[1]);
   },
 
-    getControlPoint: function (index) {
+  getControlPoint(index) {
     return this._controls[index];
   },
 
-    getOriginalEndPoint: function (index) {
+  getOriginalEndPoint(index) {
     return this._endPoint[index];
   },
 
-    getOriginalCtrlPoint: function (index) {
+  getOriginalCtrlPoint(index) {
     return this._orignalCtrlPoint[index];
-    }
+  },
 });
 
 ControlPoint.FROM = 0;

packages/mindplot/lib/components/DesignerActionRunner.js

@@ -19,40 +19,38 @@ const DesignerUndoManager = require('./DesignerUndoManager').default;
 const EventBus = require('./layout/EventBus').default;
 
 const DesignerActionRunner = new Class({
-    initialize: function (commandContext, notifier) {
-        $assert(commandContext, "commandContext can not be null");
+  initialize(commandContext, notifier) {
+    $assert(commandContext, 'commandContext can not be null');
 
     this._undoManager = new DesignerUndoManager();
     this._context = commandContext;
     this._notifier = notifier;
   },
 
-    execute: function (command) {
-        $assert(command, "command can not be null");
+  execute(command) {
+    $assert(command, 'command can not be null');
     command.execute(this._context);
     this._undoManager.enqueue(command);
     this.fireChangeEvent();
     EventBus.instance.fireEvent(EventBus.events.DoLayout);
-
   },
 
-    undo: function () {
+  undo() {
     this._undoManager.execUndo(this._context);
     this.fireChangeEvent();
     EventBus.instance.fireEvent(EventBus.events.DoLayout);
   },
 
-    redo: function () {
+  redo() {
     this._undoManager.execRedo(this._context);
     this.fireChangeEvent();
     EventBus.instance.fireEvent(EventBus.events.DoLayout);
-
   },
 
-    fireChangeEvent: function () {
-        var event = this._undoManager.buildEvent();
-        this._notifier.fireEvent("modelUpdate", event);
-    }
+  fireChangeEvent() {
+    const event = this._undoManager.buildEvent();
+    this._notifier.fireEvent('modelUpdate', event);
+  },
 });
 
 export default DesignerActionRunner;

packages/mindplot/lib/components/DesignerKeyboard.js

@@ -20,242 +20,233 @@ const Keyboard = require('./Keyboard').default;
 const DesignerKeyboard = new Class({
   Extends: Keyboard,
   Static: {
-        register:function (designer) {
+    register(designer) {
       this._instance = new DesignerKeyboard(designer);
     },
 
-        getInstance:function () {
+    getInstance() {
       return this._instance;
-        }
+    },
   },
 
-    initialize:function (designer) {
-        $assert(designer, "designer can not be null");
+  initialize(designer) {
+    $assert(designer, 'designer can not be null');
     this._registerEvents(designer);
   },
 
-    _registerEvents:function (designer) {
-
+  _registerEvents(designer) {
     // Try with the keyboard ..
-        var model = designer.getModel();
+    const model = designer.getModel();
     this.addShortcut(
-            ['backspace'], function (event) {
+      ['backspace'], (event) => {
         event.preventDefault();
         event.stopPropagation();
         designer.deleteSelectedEntities();
-            }
+      },
     );
     this.addShortcut(
-            ['space'], function() {
+      ['space'], () => {
         designer.shrinkSelectedBranch();
-            }
+      },
     );
     this.addShortcut(
-            ['f2'],function(event) {
+      ['f2'], (event) => {
         event.stopPropagation();
         event.preventDefault();
-                var node = model.selectedTopic();
+        const node = model.selectedTopic();
         if (node) {
           node.showTextEditor();
         }
-            }
+      },
     );
     this.addShortcut(
-            ['del'], function(event) {
+      ['del'], (event) => {
         designer.deleteSelectedEntities();
         event.preventDefault();
         event.stopPropagation();
-            }
+      },
     );
     this.addShortcut(
-            ['enter'], function() {
+      ['enter'], () => {
         designer.createSiblingForSelectedNode();
-            }
+      },
     );
     this.addShortcut(
-            ['insert'], function(event) {
+      ['insert'], (event) => {
         designer.createChildForSelectedNode();
         event.preventDefault();
         event.stopPropagation();
-            }
+      },
     );
     this.addShortcut(
-            ['tab'], function(event) {
+      ['tab'], (event) => {
         designer.createChildForSelectedNode();
         event.preventDefault();
         event.stopPropagation();
-            }
+      },
     );
     this.addShortcut(
-            ['meta+enter'], function(event) {
+      ['meta+enter'], (event) => {
         event.preventDefault();
         event.stopPropagation();
         designer.createChildForSelectedNode();
-            }
+      },
     );
     this.addShortcut(
-            ['ctrl+z', 'meta+z'], function(event) {
+      ['ctrl+z', 'meta+z'], (event) => {
         event.preventDefault(event);
         event.stopPropagation();
         designer.undo();
-            }
+      },
     );
     this.addShortcut(
-            ['ctrl+c', 'meta+c'], function (event) {
+      ['ctrl+c', 'meta+c'], (event) => {
         event.preventDefault(event);
         event.stopPropagation();
         designer.copyToClipboard();
-            }
+      },
     );
     this.addShortcut(
-            ['ctrl+v', 'meta+v'], function (event) {
+      ['ctrl+v', 'meta+v'], (event) => {
         event.preventDefault(event);
         event.stopPropagation();
         designer.pasteClipboard();
-            }
+      },
     );
     this.addShortcut(
-            ['ctrl+shift+z', 'meta+shift+z', 'ctrl+y', 'meta+y'], function (event) {
+      ['ctrl+shift+z', 'meta+shift+z', 'ctrl+y', 'meta+y'], (event) => {
         event.preventDefault();
         event.stopPropagation();
         designer.redo();
-            }
+      },
     );
     this.addShortcut(
-            ['ctrl+a', 'meta+a'], function (event) {
+      ['ctrl+a', 'meta+a'], (event) => {
         event.preventDefault();
         event.stopPropagation();
         designer.selectAll();
-            }
+      },
     );
     this.addShortcut(
-            ['ctrl+b', 'meta+b'], function (event) {
+      ['ctrl+b', 'meta+b'], (event) => {
         event.preventDefault();
         event.stopPropagation();
 
         designer.changeFontWeight();
-            }
+      },
     );
     this.addShortcut(
-            ['ctrl+s', 'meta+s'], function (event) {
+      ['ctrl+s', 'meta+s'], (event) => {
         event.preventDefault();
         event.stopPropagation();
         $(document).find('#save').trigger('click');
-            }
+      },
     );
     this.addShortcut(
-            ['ctrl+i', 'meta+i'], function (event) {
+      ['ctrl+i', 'meta+i'], (event) => {
         event.preventDefault();
         event.stopPropagation();
 
         designer.changeFontStyle();
-            }
+      },
     );
     this.addShortcut(
-            ['ctrl+shift+a', 'meta+shift+a'], function (event) {
+      ['ctrl+shift+a', 'meta+shift+a'], (event) => {
         event.preventDefault();
         event.stopPropagation();
 
         designer.deselectAll();
-            }
+      },
     );
     this.addShortcut(
-            ['meta+=', 'ctrl+='], function (event) {
+      ['meta+=', 'ctrl+='], (event) => {
         event.preventDefault();
         event.stopPropagation();
 
         designer.zoomIn();
-            }
+      },
     );
     this.addShortcut(
-            ['meta+-', 'ctrl+-'], function (event) {
+      ['meta+-', 'ctrl+-'], (event) => {
         event.preventDefault();
         event.stopPropagation();
 
         designer.zoomOut();
-            }
+      },
     );
-        var me = this;
+    const me = this;
     this.addShortcut(
-            'right', function (event) {
-                var node = model.selectedTopic();
+      'right', (event) => {
+        const node = model.selectedTopic();
         if (node) {
           if (node.isCentralTopic()) {
             me._goToSideChild(designer, node, 'RIGHT');
-                    }
-                    else {
-                        if (node.getPosition().x < 0) {
+          } else if (node.getPosition().x < 0) {
             me._goToParent(designer, node);
-                        }
-                        else if (!node.areChildrenShrunken()) {
+          } else if (!node.areChildrenShrunken()) {
             me._goToChild(designer, node);
           }
-                    }
         } else {
-                    var centralTopic = model.getCentralTopic();
+          const centralTopic = model.getCentralTopic();
           me._goToNode(designer, centralTopic);
         }
         event.preventDefault();
         event.stopPropagation();
-            }
+      },
     );
     this.addShortcut(
-            'left', function (event) {
-                var node = model.selectedTopic();
+      'left', (event) => {
+        const node = model.selectedTopic();
         if (node) {
           if (node.isCentralTopic()) {
             me._goToSideChild(designer, node, 'LEFT');
-                    }
-                    else {
-                        if (node.getPosition().x > 0) {
+          } else if (node.getPosition().x > 0) {
             me._goToParent(designer, node);
-                        }
-                        else if (!node.areChildrenShrunken()) {
+          } else if (!node.areChildrenShrunken()) {
             me._goToChild(designer, node);
           }
-                    }
         } else {
-                    var centralTopic = model.getCentralTopic();
+          const centralTopic = model.getCentralTopic();
           me._goToNode(designer, centralTopic);
         }
         event.preventDefault();
         event.stopPropagation();
-            }
+      },
     );
     this.addShortcut(
-            'up', function (event) {
-                var node = model.selectedTopic();
+      'up', (event) => {
+        const node = model.selectedTopic();
         if (node) {
           if (!node.isCentralTopic()) {
             me._goToBrother(designer, node, 'UP');
           }
         } else {
-                    var centralTopic = model.getCentralTopic();
+          const centralTopic = model.getCentralTopic();
           me._goToNode(designer, centralTopic);
         }
         event.preventDefault();
         event.stopPropagation();
-            }
+      },
     );
     this.addShortcut(
-            'down', function (event) {
-                var node = model.selectedTopic();
+      'down', (event) => {
+        const node = model.selectedTopic();
         if (node) {
           if (!node.isCentralTopic()) {
             me._goToBrother(designer, node, 'DOWN');
           }
         } else {
-                    var centralTopic = model.getCentralTopic();
+          const centralTopic = model.getCentralTopic();
           me._goToNode(designer, centralTopic);
         }
         event.preventDefault();
         event.stopPropagation();
-            }
+      },
     );
-        var excludes = ['esc', 'escape', 'f1', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12'];
+    const excludes = ['esc', 'escape', 'f1', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12'];
 
-        $(document).on('keypress', function (event) {
-            var keyCode;
+    $(document).on('keypress', (event) => {
+      let keyCode;
       // Firefox doesn't skip special keys for keypress event...
       if (event.key && excludes.contains(event.key.toLowerCase())) {
         return;
@@ -267,13 +258,12 @@ const DesignerKeyboard = new Class({
         keyCode = event.keyCode;
       }
 
-            var specialKey = jQuery.hotkeys.specialKeys[keyCode];
-            if (["enter", "capslock"].indexOf(specialKey) == -1 && !jQuery.hotkeys.shiftNums[keyCode]) {
-                var nodes = designer.getModel().filterSelectedTopics();
+      const specialKey = jQuery.hotkeys.specialKeys[keyCode];
+      if (['enter', 'capslock'].indexOf(specialKey) == -1 && !jQuery.hotkeys.shiftNums[keyCode]) {
+        const nodes = designer.getModel().filterSelectedTopics();
         if (nodes.length > 0) {
-
           // If a modifier is press, the key selected must be ignored.
-                    var pressKey = String.fromCharCode(keyCode);
+          const pressKey = String.fromCharCode(keyCode);
           if (event.ctrlKey || event.altKey || event.metaKey) {
             return;
           }
@@ -281,39 +271,36 @@ const DesignerKeyboard = new Class({
           event.stopPropagation();
         }
       }
-            
     });
-
   },
 
-    _goToBrother:function (designer, node, direction) {
-        var parent = node.getParent();
+  _goToBrother(designer, node, direction) {
+    const parent = node.getParent();
     if (parent) {
-            var brothers = parent.getChildren();
+      const brothers = parent.getChildren();
 
-            var target = node;
-            var y = node.getPosition().y;
-            var x = node.getPosition().x;
-            var dist = null;
-            for (var i = 0; i < brothers.length; i++) {
-                var sameSide = (x * brothers[i].getPosition().x) >= 0;
+      let target = node;
+      const { y } = node.getPosition();
+      const { x } = node.getPosition();
+      let dist = null;
+      for (let i = 0; i < brothers.length; i++) {
+        const sameSide = (x * brothers[i].getPosition().x) >= 0;
         if (brothers[i] != node && sameSide) {
-                    var brother = brothers[i];
-                    var brotherY = brother.getPosition().y;
-                    if (direction == "DOWN" && brotherY > y) {
-                        var distancia = y - brotherY;
+          const brother = brothers[i];
+          const brotherY = brother.getPosition().y;
+          if (direction == 'DOWN' && brotherY > y) {
+            let distancia = y - brotherY;
             if (distancia < 0) {
-                            distancia = distancia * (-1);
+              distancia *= (-1);
             }
             if (dist == null || dist > distancia) {
               dist = distancia;
               target = brothers[i];
             }
-                    }
-                    else if (direction == "UP" && brotherY < y) {
-                        var distance = y - brotherY;
+          } else if (direction == 'UP' && brotherY < y) {
+            let distance = y - brotherY;
             if (distance < 0) {
-                            distance = distance * (-1);
+              distance *= (-1);
             }
             if (dist == null || dist > distance) {
               dist = distance;
@@ -326,15 +313,14 @@ const DesignerKeyboard = new Class({
     }
   },
 
-
-    _goToSideChild:function (designer, node, side) {
-        var children = node.getChildren();
+  _goToSideChild(designer, node, side) {
+    const children = node.getChildren();
     if (children.length > 0) {
-            var target = children[0];
-            var top = null;
-            for (var i = 0; i < children.length; i++) {
-                var child = children[i];
-                var childY = child.getPosition().y;
+      let target = children[0];
+      let top = null;
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        const childY = child.getPosition().y;
         if (side == 'LEFT' && child.getPosition().x < 0) {
           if (top == null || childY < top) {
             target = child;
@@ -353,20 +339,20 @@ const DesignerKeyboard = new Class({
     }
   },
 
-    _goToParent:function (designer, node) {
-        var parent = node.getParent();
+  _goToParent(designer, node) {
+    const parent = node.getParent();
     if (parent) {
       this._goToNode(designer, parent);
     }
   },
 
-    _goToChild:function (designer, node) {
-        var children = node.getChildren();
+  _goToChild(designer, node) {
+    const children = node.getChildren();
     if (children.length > 0) {
-            var target = children[0];
-            var top = target.getPosition().y;
-            for (var i = 0; i < children.length; i++) {
-                var child = children[i];
+      let target = children[0];
+      let top = target.getPosition().y;
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
         if (child.getPosition().y < top) {
           top = child.getPosition().y;
           target = child;
@@ -376,25 +362,72 @@ const DesignerKeyboard = new Class({
     }
   },
 
-    _goToNode:function (designer, node) {
+  _goToNode(designer, node) {
     // First deselect all the nodes ...
     designer.deselectAll();
 
     // Give focus to the selected node....
     node.setOnFocus(true);
-    }
+  },
 
 });
 
 DesignerKeyboard.specialKeys = {
-    8: "backspace", 9: "tab", 10: "return", 13: "enter", 16: "shift", 17: "ctrl", 18: "alt", 19: "pause",
-    20: "capslock", 27: "esc", 32: "space", 33: "pageup", 34: "pagedown", 35: "end", 36: "home",
-    37: "left", 38: "up", 39: "right", 40: "down", 45: "insert", 46: "del",
-    96: "0", 97: "1", 98: "2", 99: "3", 100: "4", 101: "5", 102: "6", 103: "7",
-    104: "8", 105: "9", 106: "*", 107: "+", 109: "-", 110: ".", 111 : "/",
-    112: "f1", 113: "f2", 114: "f3", 115: "f4", 116: "f5", 117: "f6", 118: "f7", 119: "f8",
-    120: "f9", 121: "f10", 122: "f11", 123: "f12", 144: "numlock", 145: "scroll", 186: ";", 191: "/",
-    220: "\\", 222: "'", 224: "meta"
+  8: 'backspace',
+  9: 'tab',
+  10: 'return',
+  13: 'enter',
+  16: 'shift',
+  17: 'ctrl',
+  18: 'alt',
+  19: 'pause',
+  20: 'capslock',
+  27: 'esc',
+  32: 'space',
+  33: 'pageup',
+  34: 'pagedown',
+  35: 'end',
+  36: 'home',
+  37: 'left',
+  38: 'up',
+  39: 'right',
+  40: 'down',
+  45: 'insert',
+  46: 'del',
+  96: '0',
+  97: '1',
+  98: '2',
+  99: '3',
+  100: '4',
+  101: '5',
+  102: '6',
+  103: '7',
+  104: '8',
+  105: '9',
+  106: '*',
+  107: '+',
+  109: '-',
+  110: '.',
+  111: '/',
+  112: 'f1',
+  113: 'f2',
+  114: 'f3',
+  115: 'f4',
+  116: 'f5',
+  117: 'f6',
+  118: 'f7',
+  119: 'f8',
+  120: 'f9',
+  121: 'f10',
+  122: 'f11',
+  123: 'f12',
+  144: 'numlock',
+  145: 'scroll',
+  186: ';',
+  191: '/',
+  220: '\\',
+  222: "'",
+  224: 'meta',
 };
 
 export default DesignerKeyboard;

packages/mindplot/lib/components/DesignerModel.js

@@ -29,42 +29,42 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
      * @see {@link ConfigParameters.md}
      * @see {@link editor.html}
      */
-    initialize:function (options) {
+  initialize(options) {
     this._zoom = options.zoom;
     this._topics = [];
     this._relationships = [];
   },
 
   /** @return {Number} zoom between 0.3 (largest text) and 1.9 */
-    getZoom:function () {
+  getZoom() {
     return this._zoom;
   },
 
   /** @param {Number} zoom number between 0.3 and 1.9 to set the zoom to */
-    setZoom:function (zoom) {
+  setZoom(zoom) {
     this._zoom = zoom;
   },
 
   /** @return {@link mindplot.Topic[]} all topics */
-    getTopics:function () {
+  getTopics() {
     return this._topics;
   },
 
   /** @return {mindplot.Relationship[]} all relationships */
-    getRelationships:function () {
+  getRelationships() {
     return this._relationships;
   },
 
   /** @return {mindplot.CentralTopic} the central topic */
-    getCentralTopic:function () {
-        var topics = this.getTopics();
+  getCentralTopic() {
+    const topics = this.getTopics();
     return topics[0];
   },
 
   /** @return {mindplot.Topic[]} selected topics */
-    filterSelectedTopics:function () {
-        var result = [];
-        for (var i = 0; i < this._topics.length; i++) {
+  filterSelectedTopics() {
+    const result = [];
+    for (let i = 0; i < this._topics.length; i++) {
       if (this._topics[i].isOnFocus()) {
         result.push(this._topics[i]);
       }
@@ -75,9 +75,9 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
   /**
      * @return {mindplot.Relationship[]} selected relationships
      */
-    filterSelectedRelationships:function () {
-        var result = [];
-        for (var i = 0; i < this._relationships.length; i++) {
+  filterSelectedRelationships() {
+    const result = [];
+    for (let i = 0; i < this._relationships.length; i++) {
       if (this._relationships[i].isOnFocus()) {
         result.push(this._relationships[i]);
       }
@@ -88,8 +88,8 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
   /**
      * @return {Array.<mindplot.Relationship, mindplot.Topic>} all topics and relationships
      */
-    getEntities:function () {
-        var result = [].append(this._topics);
+  getEntities() {
+    const result = [].append(this._topics);
     result.append(this._relationships);
     return result;
   },
@@ -98,8 +98,8 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
      * removes occurrences of the given topic from the topic array
      * @param {mindplot.Topic} topic the topic to remove
      */
-    removeTopic:function (topic) {
-        $assert(topic, "topic can not be null");
+  removeTopic(topic) {
+    $assert(topic, 'topic can not be null');
     this._topics.erase(topic);
   },
 
@@ -107,8 +107,8 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
      * removes occurrences of the given relationship from the relationship array
      * @param {mindplot.Relationship} rel the relationship to remove
      */
-    removeRelationship:function (rel) {
-        $assert(rel, "rel can not be null");
+  removeRelationship(rel) {
+    $assert(rel, 'rel can not be null');
     this._relationships.erase(rel);
   },
 
@@ -118,9 +118,9 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
      * @throws will throw an error if topic is null or undefined
      * @throws will throw an error if the topic's id is not a number
      */
-    addTopic:function (topic) {
-        $assert(topic, "topic can not be null");
-        $assert(typeof  topic.getId() == "number", "id is not a number:" + topic.getId());
+  addTopic(topic) {
+    $assert(topic, 'topic can not be null');
+    $assert(typeof topic.getId() === 'number', `id is not a number:${topic.getId()}`);
     this._topics.push(topic);
   },
 
@@ -129,8 +129,8 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
      * @param {mindplot.Relationship} rel the relationship to add
      * @throws will throw an error if rel is null or undefined
      */
-    addRelationship:function (rel) {
-        $assert(rel, "rel can not be null");
+  addRelationship(rel) {
+    $assert(rel, 'rel can not be null');
     this._relationships.push(rel);
   },
 
@@ -139,14 +139,13 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
      * @param {String=} errorMsg an error message to display if the validation fails
      * @return {String} returns an array of the selected (and, if applicable, valid) topics' ids
      */
-    filterTopicsIds:function (validate, errorMsg) {
-        var result = [];
-        var topics = this.filterSelectedTopics();
+  filterTopicsIds(validate, errorMsg) {
+    const result = [];
+    const topics = this.filterSelectedTopics();
 
-
-        var isValid = true;
-        for (var i = 0; i < topics.length; i++) {
-            var selectedNode = topics[i];
+    let isValid = true;
+    for (let i = 0; i < topics.length; i++) {
+      const selectedNode = topics[i];
       if ($defined(validate)) {
         isValid = validate(selectedNode);
       }
@@ -165,8 +164,8 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
      * @return {mindplot.Topic} the first selected topic if one or more are found by the
      * filterSelectedTopics function, null otherwise
      */
-    selectedTopic:function () {
-        var topics = this.filterSelectedTopics();
+  selectedTopic() {
+    const topics = this.filterSelectedTopics();
     return (topics.length > 0) ? topics[0] : null;
   },
 
@@ -174,18 +173,17 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
      * @param {String} id the id of the topic to be retrieved
      * @return {mindplot.Topic} the topic with the respective id
      */
-    findTopicById:function (id) {
-        var result = null;
-        for (var i = 0; i < this._topics.length; i++) {
-            var topic = this._topics[i];
+  findTopicById(id) {
+    let result = null;
+    for (let i = 0; i < this._topics.length; i++) {
+      const topic = this._topics[i];
       if (topic.getId() == id) {
         result = topic;
         break;
       }
     }
     return result;
-
-    }
+  },
 });
 
 export default DesignerModel;

packages/mindplot/lib/components/DesignerUndoManager.js

@@ -17,18 +17,18 @@
  */
 
 const DesignerUndoManager = new Class({
-    initialize: function(fireChange) {
+  initialize(fireChange) {
     this._undoQueue = [];
     this._redoQueue = [];
     this._baseId = 0;
   },
 
-    enqueue:function(command) {
-        $assert(command, "Command can  not be null");
-        var length = this._undoQueue.length;
+  enqueue(command) {
+    $assert(command, 'Command can  not be null');
+    const { length } = this._undoQueue;
     if (command.discardDuplicated && length > 0) {
       // Skip duplicated events ...
-            var lastItem = this._undoQueue[length - 1];
+      const lastItem = this._undoQueue[length - 1];
       if (lastItem.discardDuplicated != command.discardDuplicated) {
         this._undoQueue.push(command);
       }
@@ -38,48 +38,48 @@ const DesignerUndoManager = new Class({
     this._redoQueue = [];
   },
 
-    execUndo: function(commandContext) {
+  execUndo(commandContext) {
     if (this._undoQueue.length > 0) {
-            var command = this._undoQueue.pop();
+      const command = this._undoQueue.pop();
       this._redoQueue.push(command);
 
       command.undoExecute(commandContext);
     }
   },
 
-    execRedo: function(commandContext) {
+  execRedo(commandContext) {
     if (this._redoQueue.length > 0) {
-            var command = this._redoQueue.pop();
+      const command = this._redoQueue.pop();
       this._undoQueue.push(command);
       command.execute(commandContext);
     }
   },
 
-    buildEvent: function() {
+  buildEvent() {
     return { undoSteps: this._undoQueue.length, redoSteps: this._redoQueue.length };
   },
 
-    markAsChangeBase: function() {
-        var undoLength = this._undoQueue.length;
+  markAsChangeBase() {
+    const undoLength = this._undoQueue.length;
     if (undoLength > 0) {
-            var command = this._undoQueue[undoLength - 1];
+      const command = this._undoQueue[undoLength - 1];
       this._baseId = command.getId();
     } else {
       this._baseId = 0;
     }
   },
 
-    hasBeenChanged: function() {
-        var result = true;
-        var undoLength= this._undoQueue.length;
+  hasBeenChanged() {
+    let result = true;
+    const undoLength = this._undoQueue.length;
     if (undoLength == 0 && this._baseId == 0) {
       result = false;
     } else if (undoLength > 0) {
-            var command = this._undoQueue[undoLength - 1];
+      const command = this._undoQueue[undoLength - 1];
       result = (this._baseId != command.getId());
     }
     return result;
-    }
+  },
 });
 
 export default DesignerUndoManager;

packages/mindplot/lib/components/DragConnector.js

@@ -17,7 +17,7 @@
  */
 
 const DragConnector = new Class({
-    initialize:function (designerModel, workspace) {
+  initialize(designerModel, workspace) {
     $assert(designerModel, 'designerModel can not be null');
     $assert(workspace, 'workspace can not be null');
 
@@ -26,13 +26,12 @@ const DragConnector = new Class({
     this._workspace = workspace;
   },
 
-    checkConnection:function (dragTopic) {
-        var topics = this._designerModel.getTopics();
+  checkConnection(dragTopic) {
+    const topics = this._designerModel.getTopics();
 
     // Must be disconnected from their current connection ?.
-        var candidates = this._searchConnectionCandidates(dragTopic);
-        var currentConnection = dragTopic.getConnectedToTopic();
-
+    const candidates = this._searchConnectionCandidates(dragTopic);
+    const currentConnection = dragTopic.getConnectedToTopic();
 
     if (currentConnection && (candidates.length == 0 || candidates[0] != currentConnection)) {
       dragTopic.disconnect(this._workspace);
@@ -44,22 +43,22 @@ const DragConnector = new Class({
     }
   },
 
-    _searchConnectionCandidates:function (dragTopic) {
-        var topics = this._designerModel.getTopics();
-        var draggedNode = dragTopic.getDraggedTopic();
+  _searchConnectionCandidates(dragTopic) {
+    let topics = this._designerModel.getTopics();
+    const draggedNode = dragTopic.getDraggedTopic();
 
     // Drag node connects to the border ...
-        var dragTopicWidth = dragTopic.getSize ? dragTopic.getSize().width : 0; // Hack...
-        var xMouseGap = dragTopic.getPosition().x > 0 ? 0 : dragTopicWidth;
-        var sPos = {x:dragTopic.getPosition().x - xMouseGap, y:dragTopic.getPosition().y};
+    const dragTopicWidth = dragTopic.getSize ? dragTopic.getSize().width : 0; // Hack...
+    const xMouseGap = dragTopic.getPosition().x > 0 ? 0 : dragTopicWidth;
+    const sPos = { x: dragTopic.getPosition().x - xMouseGap, y: dragTopic.getPosition().y };
 
     // Perform a initial filter to discard topics:
     //  - Exclude dragged topic
     //  - Exclude dragTopic pivot
     //  - Nodes that are collapsed
     //  - It's not part of the branch dragged itself
-        topics = topics.filter(function (topic) {
-            var result = draggedNode != topic;
+    topics = topics.filter((topic) => {
+      let result = draggedNode != topic;
       result = result && topic != draggedNode;
       result = result && !topic.areChildrenShrunken() && !topic.isCollapsed();
       result = result && !draggedNode.isChildTopic(topic);
@@ -69,13 +68,12 @@ const DragConnector = new Class({
     // Filter all the nodes that are outside the vertical boundary:
     //  * The node is to out of the x scope
     //  * The x distance greater the vertical tolerated distance
-        topics = topics.filter(function (topic) {
-            var tpos = topic.getPosition();
+    topics = topics.filter((topic) => {
+      const tpos = topic.getPosition();
       // Center topic has different alignment than the rest of the nodes. That's why i need to divide it by two...
-            var txborder = tpos.x + (topic.getSize().width / 2) * Math.sign(sPos.x);
-            var distance = (sPos.x - txborder) * Math.sign(sPos.x);
+      const txborder = tpos.x + (topic.getSize().width / 2) * Math.sign(sPos.x);
+      const distance = (sPos.x - txborder) * Math.sign(sPos.x);
       return distance > 0 && (distance < DragConnector.MAX_VERTICAL_CONNECTION_TOLERANCE);
-
     });
 
     // Assign a priority based on the distance:
@@ -83,33 +81,30 @@ const DragConnector = new Class({
     // - Vertical distance
     // - Horizontal proximity
     // - It's already connected.
-        var currentConnection = dragTopic.getConnectedToTopic();
-        var me = this;
-        topics = topics.sort(function (a, b) {
-            var aPos = a.getPosition();
-            var bPos = b.getPosition();
+    const currentConnection = dragTopic.getConnectedToTopic();
+    const me = this;
+    topics = topics.sort((a, b) => {
+      const aPos = a.getPosition();
+      const bPos = b.getPosition();
 
-            var av = me._isVerticallyAligned(a.getSize(), aPos, sPos);
-            var bv = me._isVerticallyAligned(b.getSize(), bPos, sPos);
+      const av = me._isVerticallyAligned(a.getSize(), aPos, sPos);
+      const bv = me._isVerticallyAligned(b.getSize(), bPos, sPos);
       return me._proximityWeight(av, a, sPos, currentConnection) - me._proximityWeight(bv, b, sPos, currentConnection);
-
     });
     return topics;
   },
 
-    _proximityWeight:function (isAligned, target, sPos, currentConnection) {
-        var tPos = target.getPosition();
+  _proximityWeight(isAligned, target, sPos, currentConnection) {
+    const tPos = target.getPosition();
     return (isAligned ? 0 : 200) + Math.abs(tPos.x - sPos.x) + Math.abs(tPos.y - sPos.y) + (currentConnection == target ? 0 : 100);
   },
 
-    _isVerticallyAligned:function (targetSize, targetPosition, sourcePosition) {
-
+  _isVerticallyAligned(targetSize, targetPosition, sourcePosition) {
     return Math.abs(sourcePosition.y - targetPosition.y) < targetSize.height / 2;
-
-    }
+  },
 
 });
 
 DragConnector.MAX_VERTICAL_CONNECTION_TOLERANCE = 80;
 
-export default DragConnector
+export default DragConnector;

packages/mindplot/lib/components/DragManager.js

@@ -18,7 +18,7 @@
 const DragTopic = require('./DragTopic').default;
 
 const DragManager = new Class({
-    initialize:function(workspace, eventDispatcher) {
+  initialize(workspace, eventDispatcher) {
     this._workspace = workspace;
     this._designerModel = workspace;
     this._listeners = {};
@@ -27,27 +27,27 @@ const DragManager = new Class({
     DragTopic.init(this._workspace);
   },
 
-    add : function(node) {
+  add(node) {
     // Add behaviour ...
-        var workspace = this._workspace;
-        var screen = workspace.getScreenManager();
-        var dragManager = this;
-        var me = this;
-        var mouseDownListener = function(event) {
+    const workspace = this._workspace;
+    const screen = workspace.getScreenManager();
+    const dragManager = this;
+    const me = this;
+    const mouseDownListener = function (event) {
       if (workspace.isWorkspaceEventsEnabled()) {
         // Disable double drag...
         workspace.enableWorkspaceEvents(false);
 
         // Set initial position.
-                var layoutManager = me._eventDispatcher.getLayoutManager();
-                var dragNode = node.createDragNode(layoutManager);
+        const layoutManager = me._eventDispatcher.getLayoutManager();
+        const dragNode = node.createDragNode(layoutManager);
 
         // Register mouse move listener ...
-                var mouseMoveListener = dragManager._buildMouseMoveListener(workspace, dragNode, dragManager);
+        const mouseMoveListener = dragManager._buildMouseMoveListener(workspace, dragNode, dragManager);
         screen.addEvent('mousemove', mouseMoveListener);
 
         // Register mouse up listeners ...
-                var mouseUpListener = dragManager._buildMouseUpListener(workspace, node, dragNode, dragManager);
+        const mouseUpListener = dragManager._buildMouseUpListener(workspace, node, dragNode, dragManager);
         screen.addEvent('mouseup', mouseUpListener);
 
         // Change cursor.
@@ -57,11 +57,11 @@ const DragManager = new Class({
     node.addEvent('mousedown', mouseDownListener);
   },
 
-    remove : function(node) {
-        var nodes = this._topics;
-        var contained = false;
-        var index = -1;
-        for (var i = 0; i < nodes.length; i++) {
+  remove(node) {
+    const nodes = this._topics;
+    let contained = false;
+    let index = -1;
+    for (let i = 0; i < nodes.length; i++) {
       if (nodes[i] == node) {
         contained = true;
         index = i;
@@ -69,14 +69,13 @@ const DragManager = new Class({
     }
   },
 
-    _buildMouseMoveListener : function(workspace, dragNode, dragManager) {
-        var screen = workspace.getScreenManager();
-        var me = this;
-        var result = function(event) {
-
+  _buildMouseMoveListener(workspace, dragNode, dragManager) {
+    const screen = workspace.getScreenManager();
+    const me = this;
+    const result = function (event) {
       if (!me._isDragInProcess) {
         // Execute Listeners ..
-                var startDragListener = dragManager._listeners['startdragging'];
+        const startDragListener = dragManager._listeners.startdragging;
         startDragListener(event, dragNode);
 
         // Add shadow node to the workspace.
@@ -85,26 +84,25 @@ const DragManager = new Class({
         me._isDragInProcess = true;
       }
 
-            var pos = screen.getWorkspaceMousePosition(event);
+      const pos = screen.getWorkspaceMousePosition(event);
       dragNode.setPosition(pos.x, pos.y);
 
       // Call mouse move listeners ...
-            var dragListener = dragManager._listeners['dragging'];
+      const dragListener = dragManager._listeners.dragging;
       if ($defined(dragListener)) {
         dragListener(event, dragNode);
       }
 
       event.preventDefault();
-
     };
     dragManager._mouseMoveListener = result;
     return result;
   },
 
-    _buildMouseUpListener : function(workspace, node, dragNode, dragManager) {
-        var screen = workspace.getScreenManager();
-        var me = this;
-        var result = function(event) {
+  _buildMouseUpListener(workspace, node, dragNode, dragManager) {
+    const screen = workspace.getScreenManager();
+    const me = this;
+    const result = function (event) {
       $assert(dragNode.isDragTopic, 'dragNode must be an DragTopic');
 
       // Remove all the events.
@@ -120,9 +118,8 @@ const DragManager = new Class({
       window.document.body.style.cursor = 'default';
 
       if (me._isDragInProcess) {
-
         // Execute Listeners only if the node has been moved.
-                var endDragListener = dragManager._listeners['enddragging'];
+        const endDragListener = dragManager._listeners.enddragging;
         endDragListener(event, dragNode);
 
         // Remove drag node from the workspace.
@@ -130,8 +127,6 @@ const DragManager = new Class({
 
         me._isDragInProcess = false;
       }
-
-
     };
     dragManager._mouseUpListener = result;
     return result;
@@ -143,9 +138,9 @@ const DragManager = new Class({
      *  - dragging
      *  - enddragging
      */
-    addEvent : function(type, listener) {
+  addEvent(type, listener) {
     this._listeners[type] = listener;
-    }
+  },
 });
 
 export default DragManager;

packages/mindplot/lib/components/DragPivot.js

@@ -15,9 +15,11 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const Core = require('@wismapping/core-js')
+const Core = require('@wismapping/core-js');
+
 const core = Core();
-const web2D = require('@wismapping/web2d')
+const web2D = require('@wismapping/web2d');
+
 const web2d = web2D();
 
 const DragTopic = require('./DragTopic').default;
@@ -25,7 +27,7 @@ const Shape = require('./util/Shape').default;
 const INodeModel = require('./model/INodeModel').default;
 
 const DragPivot = new Class({
-    initialize:function() {
+  initialize() {
     this._position = new core.Point();
     this._size = DragTopic.PIVOT_SIZE;
 
@@ -37,16 +39,16 @@ const DragPivot = new Class({
     this._isVisible = false;
   },
 
-    isVisible:function() {
+  isVisible() {
     return this._isVisible;
   },
 
-    getTargetTopic : function() {
+  getTargetTopic() {
     return this._targetTopic;
   },
 
-    _buildStraightLine : function() {
-        var line = new web2d.CurvedLine();
+  _buildStraightLine() {
+    const line = new web2d.CurvedLine();
     line.setStyle(web2d.CurvedLine.SIMPLE_LINE);
     line.setStroke(1, 'solid', '#CC0033');
     line.setOpacity(0.4);
@@ -54,8 +56,8 @@ const DragPivot = new Class({
     return line;
   },
 
-    _buildCurvedLine : function() {
-        var line = new web2d.CurvedLine();
+  _buildCurvedLine() {
+    const line = new web2d.CurvedLine();
     line.setStyle(web2d.CurvedLine.SIMPLE_LINE);
     line.setStroke(1, 'solid', '#CC0033');
     line.setOpacity(0.4);
@@ -63,74 +65,74 @@ const DragPivot = new Class({
     return line;
   },
 
-
-    _redrawLine : function() {
+  _redrawLine() {
     // Update line position.
     $assert(this.getTargetTopic(), 'Illegal invocation. Target node can not be null');
 
-        var pivotRect = this._getPivotRect();
+    const pivotRect = this._getPivotRect();
 
     // Pivot position has not changed. In this case, position change is not required.
-        var targetTopic = this.getTargetTopic();
-        var position = this._position;
+    const targetTopic = this.getTargetTopic();
+    const position = this._position;
 
     // Calculate pivot connection point ...
-        var size = this._size;
-        var targetPosition = targetTopic.getPosition();
-        var line = this._getConnectionLine();
+    const size = this._size;
+    const targetPosition = targetTopic.getPosition();
+    const line = this._getConnectionLine();
 
     // Update Line position.
-        var isAtRight = Shape.isAtRight(targetPosition, position);
-        var pivotPoint = Shape.calculateRectConnectionPoint(position, size, isAtRight);
+    const isAtRight = Shape.isAtRight(targetPosition, position);
+    const pivotPoint = Shape.calculateRectConnectionPoint(position, size, isAtRight);
     line.setFrom(pivotPoint.x, pivotPoint.y);
 
     // Update rect position
-        var cx = position.x - (parseInt(size.width) / 2);
-        var cy = position.y - (parseInt(size.height) / 2);
+    const cx = position.x - (parseInt(size.width) / 2);
+    const cy = position.y - (parseInt(size.height) / 2);
     pivotRect.setPosition(cx, cy);
 
     // Make line visible only when the position has been already changed.
     // This solve several strange effects ;)
-        var targetPoint = targetTopic.workoutIncomingConnectionPoint(pivotPoint);
+    const targetPoint = targetTopic.workoutIncomingConnectionPoint(pivotPoint);
     line.setTo(targetPoint.x, targetPoint.y);
   },
 
-    setPosition : function(point) {
+  setPosition(point) {
     this._position = point;
     this._redrawLine();
   },
 
-    getPosition : function() {
+  getPosition() {
     return this._position;
   },
 
-    _buildRect : function() {
-        var size = this._size;
-        var rectAttributes = {fillColor:'#CC0033',opacity:0.4,width:size.width,height:size.height,strokeColor:'#FF9933'};
-        var rect = new web2d.Rect(0, rectAttributes);
+  _buildRect() {
+    const size = this._size;
+    const rectAttributes = {
+      fillColor: '#CC0033', opacity: 0.4, width: size.width, height: size.height, strokeColor: '#FF9933',
+    };
+    const rect = new web2d.Rect(0, rectAttributes);
     rect.setVisibility(false);
     return rect;
   },
 
-    _getPivotRect : function() {
+  _getPivotRect() {
     return this._dragPivot;
   },
 
-    getSize : function() {
-        var elem2d = this._getPivotRect();
+  getSize() {
+    const elem2d = this._getPivotRect();
     return elem2d.getSize();
   },
 
-    setVisibility : function(value) {
+  setVisibility(value) {
     if (this.isVisible() != value) {
-
-            var pivotRect = this._getPivotRect();
+      const pivotRect = this._getPivotRect();
       pivotRect.setVisibility(value);
 
-            var connectRect = this._connectRect;
+      const connectRect = this._connectRect;
       connectRect.setVisibility(value);
 
-            var line = this._getConnectionLine();
+      const line = this._getConnectionLine();
       if (line) {
         line.setVisibility(value);
       }
@@ -139,9 +141,9 @@ const DragPivot = new Class({
   },
 
   // If the node is connected, validate that there is a line connecting both...
-    _getConnectionLine : function() {
-        var result = null;
-        var parentTopic = this._targetTopic;
+  _getConnectionLine() {
+    let result = null;
+    const parentTopic = this._targetTopic;
     if (parentTopic) {
       if (parentTopic.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
         result = this._straightLine;
@@ -152,37 +154,37 @@ const DragPivot = new Class({
     return result;
   },
 
-    addToWorkspace : function(workspace) {
-        var pivotRect = this._getPivotRect();
+  addToWorkspace(workspace) {
+    const pivotRect = this._getPivotRect();
     workspace.append(pivotRect);
 
-        var connectToRect = this._connectRect;
+    const connectToRect = this._connectRect;
     workspace.append(connectToRect);
 
     // Add a hidden straight line ...
-        var straighLine = this._straightLine;
+    const straighLine = this._straightLine;
     straighLine.setVisibility(false);
     workspace.append(straighLine);
     straighLine.moveToBack();
 
     // Add a hidden curved line ...
-        var curvedLine = this._curvedLine;
+    const curvedLine = this._curvedLine;
     curvedLine.setVisibility(false);
     workspace.append(curvedLine);
     curvedLine.moveToBack();
 
     // Add a connect rect ...
-        var connectRect = this._connectRect;
+    const connectRect = this._connectRect;
     connectRect.setVisibility(false);
     workspace.append(connectRect);
     connectRect.moveToBack();
   },
 
-    removeFromWorkspace : function(workspace) {
-        var shape = this._getPivotRect();
+  removeFromWorkspace(workspace) {
+    const shape = this._getPivotRect();
     workspace.removeChild(shape);
 
-        var connectToRect = this._connectRect;
+    const connectToRect = this._connectRect;
     workspace.removeChild(connectToRect);
 
     if ($defined(this._straightLine)) {
@@ -194,7 +196,7 @@ const DragPivot = new Class({
     }
   },
 
-    connectTo : function(targetTopic, position) {
+  connectTo(targetTopic, position) {
     $assert(!this._outgoingLine, 'Could not connect an already connected node');
     $assert(targetTopic != this, 'Circular connection are not allowed');
     $assert(position, 'position can not be null');
@@ -204,35 +206,35 @@ const DragPivot = new Class({
     this._targetTopic = targetTopic;
 
     // Connected to Rect ...
-        var connectRect = this._connectRect;
-        var targetSize = targetTopic.getSize();
+    const connectRect = this._connectRect;
+    const targetSize = targetTopic.getSize();
 
     // Add 4 pixel in order to keep create a rect bigger than the topic.
-        var width = targetSize.width + 4;
-        var height = targetSize.height + 4;
+    const width = targetSize.width + 4;
+    const height = targetSize.height + 4;
 
     connectRect.setSize(width, height);
 
-        var targetPosition = targetTopic.getPosition();
-        var cx = Math.ceil(targetPosition.x - (width / 2));
-        var cy = Math.ceil(targetPosition.y - (height / 2));
+    const targetPosition = targetTopic.getPosition();
+    const cx = Math.ceil(targetPosition.x - (width / 2));
+    const cy = Math.ceil(targetPosition.y - (height / 2));
     connectRect.setPosition(cx, cy);
 
     // Change elements position ...
-        var pivotRect = this._getPivotRect();
+    const pivotRect = this._getPivotRect();
     pivotRect.moveToFront();
     pivotRect.setPosition(position.x, position.y);
 
     this._redrawLine();
   },
 
-    disconnect : function(workspace) {
+  disconnect(workspace) {
     $assert(workspace, 'workspace can not be null.');
     $assert(this._targetTopic, 'There are not connected topic.');
 
     this.setVisibility(false);
     this._targetTopic = null;
-    }
+  },
 });
 
 export default DragPivot;

packages/mindplot/lib/components/DragTopic.js

@@ -15,14 +15,15 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const Core = require('@wismapping/core-js')
+const Core = require('@wismapping/core-js');
+
 const core = Core();
 
-const ActionDispatcher = require('./ActionDispatcher').default
+const ActionDispatcher = require('./ActionDispatcher').default;
 const DragPivot = require('./DragPivot').default;
 
 const DragTopic = new Class({
-    initialize:function (dragShape, draggedNode, layoutManger) {
+  initialize(dragShape, draggedNode, layoutManger) {
     $assert(dragShape, 'Rect can not be null.');
     $assert(draggedNode, 'draggedNode can not be null.');
     $assert(layoutManger, 'layoutManger can not be null.');
@@ -36,142 +37,141 @@ const DragTopic = new Class({
     this._isFreeLayoutEnabled = false;
   },
 
-    setOrder:function (order) {
+  setOrder(order) {
     this._order = order;
   },
 
-    setPosition:function (x, y) {
+  setPosition(x, y) {
     // Update drag shadow position ....
-        var position = {x:x, y:y};
+    let position = { x, y };
     if (this.isFreeLayoutOn() && this.isConnected()) {
-            var _layoutManager = this._layoutManager;
-            var par = this.getConnectedToTopic();
+      const { _layoutManager } = this;
+      const par = this.getConnectedToTopic();
       position = _layoutManager.predict(par.getId(), this._draggedNode.getId(), position, true).position;
     }
     this._position.setValue(position.x, position.y);
 
     // Elements are positioned in the center.
     // All topic element must be positioned based on the innerShape.
-        var draggedNode = this._draggedNode;
-        var size = draggedNode.getSize();
-        var cx = position.x - (position.x > 0 ? 0 : size.width);
-        var cy = Math.ceil(position.y - (size.height / 2));
+    const draggedNode = this._draggedNode;
+    const size = draggedNode.getSize();
+    const cx = position.x - (position.x > 0 ? 0 : size.width);
+    const cy = Math.ceil(position.y - (size.height / 2));
     this._elem2d.setPosition(cx, cy);
 
     // In case is not free, pivot must be draw ...
     if (this.isConnected() && !this.isFreeLayoutOn()) {
-            var parent = this.getConnectedToTopic();
-            var predict = this._layoutManager.predict(parent.getId(), this._draggedNode.getId(), this.getPosition());
+      const parent = this.getConnectedToTopic();
+      const predict = this._layoutManager.predict(parent.getId(), this._draggedNode.getId(), this.getPosition());
       if (this._order != predict.order) {
-                var dragPivot = this._getDragPivot();
-                var pivotPosition = predict.position;
+        const dragPivot = this._getDragPivot();
+        const pivotPosition = predict.position;
         dragPivot.connectTo(parent, pivotPosition);
         this.setOrder(predict.order);
       }
     }
   },
 
-    updateFreeLayout:function (event) {
-        var isFreeEnabled = (event.metaKey && Browser.Platform.mac) || (event.ctrlKey && !Browser.Platform.mac);
+  updateFreeLayout(event) {
+    const isFreeEnabled = (event.metaKey && Browser.Platform.mac) || (event.ctrlKey && !Browser.Platform.mac);
     if (this.isFreeLayoutOn() != isFreeEnabled) {
-            var dragPivot = this._getDragPivot();
+      const dragPivot = this._getDragPivot();
       dragPivot.setVisibility(!isFreeEnabled);
       this._isFreeLayoutEnabled = isFreeEnabled;
     }
   },
 
-    setVisibility:function (value) {
-        var dragPivot = this._getDragPivot();
+  setVisibility(value) {
+    const dragPivot = this._getDragPivot();
     dragPivot.setVisibility(value);
   },
 
-    isVisible:function () {
-        var dragPivot = this._getDragPivot();
+  isVisible() {
+    const dragPivot = this._getDragPivot();
     return dragPivot.isVisible();
   },
 
-    getInnerShape:function () {
+  getInnerShape() {
     return this._elem2d;
   },
 
-    disconnect:function (workspace) {
+  disconnect(workspace) {
     // Clear connection line ...
-        var dragPivot = this._getDragPivot();
+    const dragPivot = this._getDragPivot();
     dragPivot.disconnect(workspace);
   },
 
-    connectTo:function (parent) {
+  connectTo(parent) {
     $assert(parent, 'Parent connection node can not be null.');
 
     // Where it should be connected ?
-        var predict = designer._eventBussDispatcher._layoutManager.predict(parent.getId(), this._draggedNode.getId(), this.getPosition());
+    const predict = designer._eventBussDispatcher._layoutManager.predict(parent.getId(), this._draggedNode.getId(), this.getPosition());
 
     // Connect pivot ...
-        var dragPivot = this._getDragPivot();
-        var position = predict.position;
+    const dragPivot = this._getDragPivot();
+    const { position } = predict;
     dragPivot.connectTo(parent, position);
     dragPivot.setVisibility(true);
 
     this.setOrder(predict.order);
   },
 
-    getDraggedTopic:function () {
+  getDraggedTopic() {
     return this._draggedNode;
   },
 
-    removeFromWorkspace:function (workspace) {
+  removeFromWorkspace(workspace) {
     if (this._isInWorkspace) {
       // Remove drag shadow.
       workspace.removeChild(this._elem2d);
 
       // Remove pivot shape. To improve performance it will not be removed. Only the visibility will be changed.
-            var dragPivot = this._getDragPivot();
+      const dragPivot = this._getDragPivot();
       dragPivot.setVisibility(false);
 
       this._isInWorkspace = false;
     }
   },
 
-    isInWorkspace:function () {
+  isInWorkspace() {
     return this._isInWorkspace;
   },
 
-    addToWorkspace:function (workspace) {
+  addToWorkspace(workspace) {
     if (!this._isInWorkspace) {
       workspace.append(this._elem2d);
-            var dragPivot = this._getDragPivot();
+      const dragPivot = this._getDragPivot();
       dragPivot.addToWorkspace(workspace);
       this._isInWorkspace = true;
     }
   },
 
-    _getDragPivot:function () {
+  _getDragPivot() {
     return DragTopic.__getDragPivot();
   },
 
-    getPosition:function () {
+  getPosition() {
     return this._position;
   },
 
-    isDragTopic:function () {
+  isDragTopic() {
     return true;
   },
 
-    applyChanges:function (workspace) {
+  applyChanges(workspace) {
     $assert(workspace, 'workspace can not be null');
 
-
-        var actionDispatcher = ActionDispatcher.getInstance();
-        var draggedTopic = this.getDraggedTopic();
-        var topicId = draggedTopic.getId();
-        var position = this.getPosition();
+    const actionDispatcher = ActionDispatcher.getInstance();
+    const draggedTopic = this.getDraggedTopic();
+    const topicId = draggedTopic.getId();
+    const position = this.getPosition();
 
     if (!this.isFreeLayoutOn()) {
-            var order = null;
-            var parent = null;
-            var isDragConnected = this.isConnected();
+      let order = null;
+      let parent = null;
+      const isDragConnected = this.isConnected();
       if (isDragConnected) {
-                var targetTopic = this.getConnectedToTopic();
+        const targetTopic = this.getConnectedToTopic();
         order = this._order;
         parent = targetTopic;
       }
@@ -183,34 +183,33 @@ const DragTopic = new Class({
     }
   },
 
-    getConnectedToTopic:function () {
-        var dragPivot = this._getDragPivot();
+  getConnectedToTopic() {
+    const dragPivot = this._getDragPivot();
     return dragPivot.getTargetTopic();
   },
 
-    isConnected:function () {
+  isConnected() {
     return this.getConnectedToTopic() != null;
   },
 
-    isFreeLayoutOn:function () {
+  isFreeLayoutOn() {
     //        return  this._isFreeLayoutEnabled;
     // Disable free layout ...
     return false;
-    }
+  },
 
 });
 
 DragTopic.PIVOT_SIZE = { width: 50, height: 6 };
 
 DragTopic.init = function (workspace) {
-
-    $assert(workspace, "workspace can not be null");
-    var pivot = DragTopic.__getDragPivot();
+  $assert(workspace, 'workspace can not be null');
+  const pivot = DragTopic.__getDragPivot();
   workspace.append(pivot);
 };
 
 DragTopic.__getDragPivot = function () {
-    var result = DragTopic._dragPivot;
+  let result = DragTopic._dragPivot;
   if (!$defined(result)) {
     result = new DragPivot();
     DragTopic._dragPivot = result;

packages/mindplot/lib/components/EditorOptions.js

@@ -16,11 +16,10 @@
  *   limitations under the License.
  */
 
-const EditorOptions =
-{
-    LayoutManager:"OriginalLayout",
+const EditorOptions = {
+  LayoutManager: 'OriginalLayout',
   //    LayoutManager:"FreeMindLayout",
-    textEditor:"TextEditor"
+  textEditor: 'TextEditor',
 //    textEditor:"RichTextEditor"
 };
 

packages/mindplot/lib/components/EditorProperties.js

@@ -17,22 +17,22 @@
  */
 
 const EditorProperties = new Class({
-    initialize: function () {
+  initialize() {
     this._zoom = 0;
     this._position = 0;
   },
 
-    setZoom: function (zoom) {
+  setZoom(zoom) {
     this._zoom = zoom;
   },
 
-    getZoom: function () {
+  getZoom() {
     return this._zoom;
   },
 
-    asProperties: function () {
-        return "zoom=" + this._zoom + "\n";
-    }
+  asProperties() {
+    return `zoom=${this._zoom}\n`;
+  },
 });
 
 export default EditorProperties;

packages/mindplot/lib/components/Events.js

@@ -1,13 +1,11 @@
 const Events = new Class({
   $events: {},
 
-    _removeOn: function (string) {
-        return string.replace(/^on([A-Z])/, function (full, first) {
-            return first.toLowerCase();
-        });
+  _removeOn(string) {
+    return string.replace(/^on([A-Z])/, (full, first) => first.toLowerCase());
   },
 
-    addEvent: function (type, fn, internal) {
+  addEvent(type, fn, internal) {
     type = this._removeOn(type);
 
     this.$events[type] = (this.$events[type] || []).include(fn);
@@ -15,9 +13,9 @@ const Events = new Class({
     return this;
   },
 
-    fireEvent: function (type, args, delay) {
+  fireEvent(type, args, delay) {
     type = this._removeOn(type);
-        var events = this.$events[type];
+    const events = this.$events[type];
     if (!events) return this;
     args = Array.isArray(args) ? args : [args];
     _.each(
@@ -26,16 +24,16 @@ const Events = new Class({
         if (delay) fn.delay(delay, this, args);
         else fn.apply(this, args);
       },
-            this
+      this,
     );
     return this;
   },
 
-    removeEvent: function (type, fn) {
+  removeEvent(type, fn) {
     type = this._removeOn(type);
-        var events = this.$events[type];
+    const events = this.$events[type];
     if (events && !fn.internal) {
-            var index = events.indexOf(fn);
+      const index = events.indexOf(fn);
       if (index != -1) events.splice(index, 1);
     }
     return this;

packages/mindplot/lib/components/Icon.js

@@ -15,44 +15,45 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const web2D = require('@wismapping/web2d')
-const web2d = web2D()
+const web2D = require('@wismapping/web2d');
+
+const web2d = web2D();
 
 const Icon = new Class({
-    initialize: function (url) {
+  initialize(url) {
     $assert(url, 'topic can not be null');
     this._image = new web2d.Image();
     this._image.setHref(url);
     this._image.setSize(Icon.SIZE, Icon.SIZE);
   },
 
-    getImage: function () {
+  getImage() {
     return this._image;
   },
 
-    setGroup: function (group) {
+  setGroup(group) {
     this._group = group;
   },
 
-    getGroup: function () {
+  getGroup() {
     return this._group;
   },
 
-    getSize: function () {
+  getSize() {
     return this._image.getSize();
   },
 
-    getPosition: function () {
+  getPosition() {
     return this._image.getPosition();
   },
 
-    addEvent: function (type, fnc) {
+  addEvent(type, fnc) {
     this._image.addEvent(type, fnc);
   },
 
-    remove: function () {
-        throw "Unsupported operation";
-    }
+  remove() {
+    throw 'Unsupported operation';
+  },
 });
 
 Icon.SIZE = 90;

packages/mindplot/lib/components/IconGroup.js

@@ -15,7 +15,8 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const web2D = require('@wismapping/web2d')
+const web2D = require('@wismapping/web2d');
+
 const web2d = web2D();
 const Icon = require('./Icon');
 
@@ -27,9 +28,9 @@ const IconGroup = new Class(/**@lends IconGroup */{
      * @throws will throw an error if topicId is null or undefined
      * @throws will throw an error if iconSize is null or undefined
      */
-    initialize: function (topicId, iconSize) {
-        $assert($defined(topicId), "topicId can not be null");
-        $assert($defined(iconSize), "iconSize can not be null");
+  initialize(topicId, iconSize) {
+    $assert($defined(topicId), 'topicId can not be null');
+    $assert($defined(iconSize), 'iconSize can not be null');
 
     this._icons = [];
     this._group = new web2d.Group({
@@ -38,38 +39,37 @@ const IconGroup = new Class(/**@lends IconGroup */{
       x: 0,
       y: 0,
       coordSizeWidth: 0,
-            coordSizeHeight: 100
+      coordSizeHeight: 100,
     });
     this._removeTip = new IconGroup.RemoveTip(this._group, topicId);
     this.seIconSize(iconSize, iconSize);
 
     this._registerListeners();
-
   },
 
   /** */
-    setPosition: function (x, y) {
+  setPosition(x, y) {
     this._group.setPosition(x, y);
   },
 
   /** */
-    getPosition: function () {
+  getPosition() {
     return this._group.getPosition();
   },
 
   /** */
-    getNativeElement: function () {
+  getNativeElement() {
     return this._group;
   },
 
   /** */
-    getSize: function () {
+  getSize() {
     return this._group.getSize();
   },
 
   /** */
-    seIconSize: function (width, height) {
-        this._iconSize = {width: width, height: height};
+  seIconSize(width, height) {
+    this._iconSize = { width, height };
     this._resize(this._icons.length);
   },
 
@@ -78,8 +78,8 @@ const IconGroup = new Class(/**@lends IconGroup */{
      * @param {Boolean} remove
      * @throws will throw an error if icon is not defined
      */
-    addIcon: function (icon, remove) {
-        $defined(icon, "icon is not defined");
+  addIcon(icon, remove) {
+    $defined(icon, 'icon is not defined');
 
     icon.setGroup(this);
     this._icons.push(icon);
@@ -88,7 +88,7 @@ const IconGroup = new Class(/**@lends IconGroup */{
     this._resize(this._icons.length);
     this._positionIcon(icon, this._icons.length - 1);
 
-        var imageShape = icon.getImage();
+    const imageShape = icon.getImage();
     this._group.append(imageShape);
 
     // Register event for the group ..
@@ -97,75 +97,72 @@ const IconGroup = new Class(/**@lends IconGroup */{
     }
   },
 
-    _findIconFromModel: function (iconModel) {
-        var result = null;
-        _.each(this._icons, function (icon) {
-            var elModel = icon.getModel();
+  _findIconFromModel(iconModel) {
+    let result = null;
+    _.each(this._icons, (icon) => {
+      const elModel = icon.getModel();
       if (elModel.getId() == iconModel.getId()) {
         result = icon;
       }
     }, this);
 
     if (result == null) {
-            throw new Error("Icon can no be found:" + iconModel.getId() + ", Icons:" + this._icons);
+      throw new Error(`Icon can no be found:${iconModel.getId()}, Icons:${this._icons}`);
     }
 
     return result;
   },
 
   /** */
-    removeIconByModel: function (featureModel) {
-        $assert(featureModel, "featureModel can not be null");
+  removeIconByModel(featureModel) {
+    $assert(featureModel, 'featureModel can not be null');
 
-        var icon = this._findIconFromModel(featureModel);
+    const icon = this._findIconFromModel(featureModel);
     this._removeIcon(icon);
   },
 
-    _removeIcon: function (icon) {
-        $assert(icon, "icon can not be null");
+  _removeIcon(icon) {
+    $assert(icon, 'icon can not be null');
 
     this._removeTip.close(0);
     this._group.removeChild(icon.getImage());
 
     this._icons.erase(icon);
     this._resize(this._icons.length);
-        var me = this;
+    const me = this;
     // Add all again ...
-        _.each(this._icons, function (elem, i) {
+    _.each(this._icons, (elem, i) => {
       me._positionIcon(elem, i);
     });
   },
 
   /** */
-    moveToFront: function () {
+  moveToFront() {
     this._group.moveToFront();
   },
 
-    _registerListeners: function () {
-        this._group.addEvent('click', function (event) {
+  _registerListeners() {
+    this._group.addEvent('click', (event) => {
       // Avoid node creation ...
       event.stopPropagation();
-
     });
 
-        this._group.addEvent('dblclick', function (event) {
+    this._group.addEvent('dblclick', (event) => {
       event.stopPropagation();
-
     });
   },
 
-    _resize: function (iconsLength) {
+  _resize(iconsLength) {
     this._group.setSize(iconsLength * this._iconSize.width, this._iconSize.height);
 
-        var iconSize = Icon.SIZE + (IconGroup.ICON_PADDING * 2);
+    const iconSize = Icon.SIZE + (IconGroup.ICON_PADDING * 2);
     this._group.setCoordSize(iconsLength * iconSize, iconSize);
   },
 
-    _positionIcon: function (icon, order) {
-
-        var iconSize = Icon.SIZE + (IconGroup.ICON_PADDING * 2);
+  _positionIcon(icon, order) {
+    const iconSize = Icon.SIZE + (IconGroup.ICON_PADDING * 2);
     icon.getImage().setPosition(iconSize * order + IconGroup.ICON_PADDING, IconGroup.ICON_PADDING);
-    }
+  },
 });
 
 /**
@@ -181,18 +178,17 @@ IconGroup.RemoveTip = new Class(/** @lends IconGroup.RemoveTip */{
      * @constructs
      * @param container
      */
-    initialize: function (container) {
-        $assert(container, "group can not be null");
+  initialize(container) {
+    $assert(container, 'group can not be null');
     this._fadeElem = container;
   },
 
-
   /**
      * @param topicId
      * @param icon
      * @throws will throw an error if icon is null or undefined
      */
-    show: function (topicId, icon) {
+  show(topicId, icon) {
     $assert(icon, 'icon can not be null');
 
     // Nothing to do ...
@@ -203,21 +199,21 @@ IconGroup.RemoveTip = new Class(/** @lends IconGroup.RemoveTip */{
       }
 
       // Now, let move the position the icon...
-            var pos = icon.getPosition();
+      const pos = icon.getPosition();
 
       // Register events ...
-            var widget = this._buildWeb2d();
-            widget.addEvent('click', function () {
+      const widget = this._buildWeb2d();
+      widget.addEvent('click', () => {
         icon.remove();
       });
 
-            var me = this;
+      const me = this;
 
-            widget.addEvent('mouseover', function () {
+      widget.addEvent('mouseover', () => {
         me.show(topicId, icon);
       });
 
-            widget.addEvent('mouseout', function () {
+      widget.addEvent('mouseout', () => {
         me.hide();
       });
 
@@ -227,31 +223,29 @@ IconGroup.RemoveTip = new Class(/** @lends IconGroup.RemoveTip */{
       // Setup current element ...
       this._activeIcon = icon;
       this._widget = widget;
-
     } else {
       clearTimeout(this._closeTimeoutId);
     }
   },
 
   /** */
-    hide: function () {
+  hide() {
     this.close(200);
   },
 
   /**
      * @param delay
      */
-    close: function (delay) {
-
+  close(delay) {
     // This is not ok, trying to close the same dialog twice ?
     if (this._closeTimeoutId) {
-            clearTimeout(this._closeTimeoutId)
+      clearTimeout(this._closeTimeoutId);
     }
 
-        var me = this;
+    const me = this;
     if (this._activeIcon) {
-            var widget = this._widget;
-            var close = function () {
+      const widget = this._widget;
+      const close = function () {
         me._activeIcon = null;
         me._fadeElem.removeChild(widget);
         me._widget = null;
@@ -260,59 +254,58 @@ IconGroup.RemoveTip = new Class(/** @lends IconGroup.RemoveTip */{
 
       if (!$defined(delay) || delay == 0) {
         close();
-            }
-            else {
+      } else {
         this._closeTimeoutId = close.delay(delay);
       }
     }
   },
 
-    _buildWeb2d: function () {
-        var result = new web2d.Group({
+  _buildWeb2d() {
+    const result = new web2d.Group({
       width: 10,
       height: 10,
       x: 0,
       y: 0,
       coordSizeWidth: 10,
-            coordSizeHeight: 10
+      coordSizeHeight: 10,
     });
 
-        var outerRect = new web2d.Rect(0, {
+    const outerRect = new web2d.Rect(0, {
       x: 0,
       y: 0,
       width: 10,
       height: 10,
       stroke: '0',
-            fillColor: 'black'
+      fillColor: 'black',
     });
     result.append(outerRect);
     outerRect.setCursor('pointer');
 
-        var innerRect = new web2d.Rect(0, {
+    const innerRect = new web2d.Rect(0, {
       x: 1,
       y: 1,
       width: 8,
       height: 8,
       stroke: '1 solid white',
-            fillColor: 'gray'
+      fillColor: 'gray',
     });
     result.append(innerRect);
 
-        var line = new web2d.Line({stroke: '1 solid white'});
+    const line = new web2d.Line({ stroke: '1 solid white' });
     line.setFrom(1, 1);
     line.setTo(9, 9);
     result.append(line);
 
-        var line2 = new web2d.Line({stroke: '1 solid white'});
+    const line2 = new web2d.Line({ stroke: '1 solid white' });
     line2.setFrom(1, 9);
     line2.setTo(9, 1);
     result.append(line2);
 
     // Some events ...
-        result.addEvent('mouseover', function () {
+    result.addEvent('mouseover', () => {
       innerRect.setFill('#CC0033');
     });
-        result.addEvent('mouseout', function () {
+    result.addEvent('mouseout', () => {
       innerRect.setFill('gray');
     });
 
@@ -324,21 +317,20 @@ IconGroup.RemoveTip = new Class(/** @lends IconGroup.RemoveTip */{
      * @param topicId
      * @param icon
      */
-    decorate: function (topicId, icon) {
-
-        var me = this;
+  decorate(topicId, icon) {
+    const me = this;
 
     if (!icon.__remove) {
-            icon.addEvent('mouseover', function () {
+      icon.addEvent('mouseover', () => {
         me.show(topicId, icon);
       });
 
-            icon.addEvent('mouseout', function () {
+      icon.addEvent('mouseout', () => {
         me.hide();
       });
       icon.__remove = true;
     }
-    }
+  },
 
 });
 

packages/mindplot/lib/components/ImageIcon.js

@@ -20,7 +20,7 @@ const ActionDispatcher = require('./ActionDispatcher').default;
 
 const ImageIcon = new Class({
   Extends: Icon,
-    initialize: function (topic, iconModel, readOnly) {
+  initialize(topic, iconModel, readOnly) {
     $assert(iconModel, 'iconModel can not be null');
     $assert(topic, 'topic can not be null');
 
@@ -28,44 +28,40 @@ const ImageIcon = new Class({
     this._featureModel = iconModel;
 
     // Build graph image representation ...
-        var iconType = iconModel.getIconType();
-        var imgUrl = this._getImageUrl(iconType);
+    const iconType = iconModel.getIconType();
+    const imgUrl = this._getImageUrl(iconType);
     this.parent(imgUrl);
 
     if (!readOnly) {
-
       // Icon
-            var image = this.getImage();
-            var me = this;
-            image.addEvent('click', function () {
-
-                var iconType = iconModel.getIconType();
-                var newIconType = me._getNextFamilyIconId(iconType);
+      const image = this.getImage();
+      const me = this;
+      image.addEvent('click', () => {
+        const iconType = iconModel.getIconType();
+        const newIconType = me._getNextFamilyIconId(iconType);
         iconModel.setIconType(newIconType);
 
-                var imgUrl = me._getImageUrl(newIconType);
+        const imgUrl = me._getImageUrl(newIconType);
         me._image.setHref(imgUrl);
-
       });
       this._image.setCursor('pointer');
     }
   },
 
-    _getImageUrl: function (iconId) {
-        return "icons/" + iconId + ".png";
+  _getImageUrl(iconId) {
+    return `icons/${iconId}.png`;
   },
 
-    getModel: function () {
+  getModel() {
     return this._featureModel;
   },
 
-    _getNextFamilyIconId: function (iconId) {
+  _getNextFamilyIconId(iconId) {
+    const familyIcons = this._getFamilyIcons(iconId);
+    $assert(familyIcons != null, 'Family Icon not found!');
 
-        var familyIcons = this._getFamilyIcons(iconId);
-        $assert(familyIcons != null, "Family Icon not found!");
-
-        var result = null;
-        for (var i = 0; i < familyIcons.length && result == null; i++) {
+    let result = null;
+    for (let i = 0; i < familyIcons.length && result == null; i++) {
       if (familyIcons[i] == iconId) {
         // Is last one?
         if (i == (familyIcons.length - 1)) {
@@ -80,14 +76,14 @@ const ImageIcon = new Class({
     return result;
   },
 
-    _getFamilyIcons: function (iconId) {
-        $assert(iconId != null, "id must not be null");
-        $assert(iconId.indexOf("_") != -1, "Invalid icon id (it must contain '_')");
+  _getFamilyIcons(iconId) {
+    $assert(iconId != null, 'id must not be null');
+    $assert(iconId.indexOf('_') != -1, "Invalid icon id (it must contain '_')");
 
-        var result = null;
-        for (var i = 0; i < ImageIcon.prototype.ICON_FAMILIES.length; i++) {
-            var family = ImageIcon.prototype.ICON_FAMILIES[i];
-            var iconFamilyId = iconId.substr(0, iconId.indexOf("_"));
+    let result = null;
+    for (let i = 0; i < ImageIcon.prototype.ICON_FAMILIES.length; i++) {
+      const family = ImageIcon.prototype.ICON_FAMILIES[i];
+      const iconFamilyId = iconId.substr(0, iconId.indexOf('_'));
 
       if (family.id == iconFamilyId) {
         result = family.icons;
@@ -97,70 +93,70 @@ const ImageIcon = new Class({
     return result;
   },
 
-    remove: function () {
-        var actionDispatcher = ActionDispatcher.getInstance();
-        var featureId = this._featureModel.getId();
-        var topicId = this._topicId;
+  remove() {
+    const actionDispatcher = ActionDispatcher.getInstance();
+    const featureId = this._featureModel.getId();
+    const topicId = this._topicId;
     actionDispatcher.removeFeatureFromTopic(topicId, featureId);
-    }
+  },
 });
 
 ImageIcon.prototype.ICON_FAMILIES = [
-    {"id": "face", "icons": ["face_plain", "face_sad", "face_crying", "face_smile", "face_surprise", "face_wink"]},
-    {"id": "funy", "icons": ["funy_angel", "funy_devilish", "funy_glasses", "funy_grin", "funy_kiss", "funy_monkey"]},
-    {"id": "conn", "icons": ["conn_connect", "conn_disconnect"]},
+  { id: 'face', icons: ['face_plain', 'face_sad', 'face_crying', 'face_smile', 'face_surprise', 'face_wink'] },
+  { id: 'funy', icons: ['funy_angel', 'funy_devilish', 'funy_glasses', 'funy_grin', 'funy_kiss', 'funy_monkey'] },
+  { id: 'conn', icons: ['conn_connect', 'conn_disconnect'] },
   {
-        "id": "sport",
-        "icons": ["sport_basketball", "sport_football", "sport_golf", "sport_raquet", "sport_shuttlecock", "sport_soccer", "sport_tennis"]
+    id: 'sport',
+    icons: ['sport_basketball', 'sport_football', 'sport_golf', 'sport_raquet', 'sport_shuttlecock', 'sport_soccer', 'sport_tennis'],
   },
-    {"id": "bulb", "icons": ["bulb_light_on", "bulb_light_off"]},
-    {"id": "thumb", "icons": ["thumb_thumb_up", "thumb_thumb_down"]},
-    {"id": "tick", "icons": ["tick_tick", "tick_cross"]},
+  { id: 'bulb', icons: ['bulb_light_on', 'bulb_light_off'] },
+  { id: 'thumb', icons: ['thumb_thumb_up', 'thumb_thumb_down'] },
+  { id: 'tick', icons: ['tick_tick', 'tick_cross'] },
   {
-        "id": "onoff",
-        "icons": ["onoff_clock", "onoff_clock_red", "onoff_add", "onoff_delete", "onoff_status_offline", "onoff_status_online"]
+    id: 'onoff',
+    icons: ['onoff_clock', 'onoff_clock_red', 'onoff_add', 'onoff_delete', 'onoff_status_offline', 'onoff_status_online'],
   },
   {
-        "id": "money",
-        "icons": ["money_money", "money_dollar", "money_euro", "money_pound", "money_yen", "money_coins", "money_ruby"]
+    id: 'money',
+    icons: ['money_money', 'money_dollar', 'money_euro', 'money_pound', 'money_yen', 'money_coins', 'money_ruby'],
   },
-    {"id": "time", "icons": ["time_calendar", "time_clock", "time_hourglass"]},
+  { id: 'time', icons: ['time_calendar', 'time_clock', 'time_hourglass'] },
   {
-        "id": "number",
-        "icons": ["number_1", "number_2", "number_3", "number_4", "number_5", "number_6", "number_7", "number_8", "number_9"]
+    id: 'number',
+    icons: ['number_1', 'number_2', 'number_3', 'number_4', 'number_5', 'number_6', 'number_7', 'number_8', 'number_9'],
   },
-    {"id": "chart", "icons": ["chart_bar", "chart_line", "chart_curve", "chart_pie", "chart_organisation"]},
-    {"id": "sign", "icons": ["sign_warning", "sign_info", "sign_stop", "sign_help", "sign_cancel"]},
+  { id: 'chart', icons: ['chart_bar', 'chart_line', 'chart_curve', 'chart_pie', 'chart_organisation'] },
+  { id: 'sign', icons: ['sign_warning', 'sign_info', 'sign_stop', 'sign_help', 'sign_cancel'] },
   {
-        "id": "hard",
-        "icons": ["hard_cd", "hard_computer", "hard_controller", "hard_driver_disk", "hard_ipod", "hard_keyboard", "hard_mouse", "hard_printer"]
+    id: 'hard',
+    icons: ['hard_cd', 'hard_computer', 'hard_controller', 'hard_driver_disk', 'hard_ipod', 'hard_keyboard', 'hard_mouse', 'hard_printer'],
   },
   {
-        "id": "soft",
-        "icons": ["soft_bug", "soft_cursor", "soft_database_table", "soft_database", "soft_feed", "soft_folder_explore", "soft_rss", "soft_penguin"]
+    id: 'soft',
+    icons: ['soft_bug', 'soft_cursor', 'soft_database_table', 'soft_database', 'soft_feed', 'soft_folder_explore', 'soft_rss', 'soft_penguin'],
   },
-    {"id": "arrow", "icons": ["arrow_up", "arrow_down", "arrow_left", "arrow_right"]},
+  { id: 'arrow', icons: ['arrow_up', 'arrow_down', 'arrow_left', 'arrow_right'] },
   {
-        "id": "arrowc",
-        "icons": ["arrowc_rotate_anticlockwise", "arrowc_rotate_clockwise", "arrowc_turn_left", "arrowc_turn_right"]
+    id: 'arrowc',
+    icons: ['arrowc_rotate_anticlockwise', 'arrowc_rotate_clockwise', 'arrowc_turn_left', 'arrowc_turn_right'],
   },
-    {"id": "people", "icons": ["people_group", "people_male1", "people_male2", "people_female1", "people_female2"]},
-    {"id": "mail", "icons": ["mail_envelop", "mail_mailbox", "mail_edit", "mail_list"]},
-    {"id": "flag", "icons": ["flag_blue", "flag_green", "flag_orange", "flag_pink", "flag_purple", "flag_yellow"]},
+  { id: 'people', icons: ['people_group', 'people_male1', 'people_male2', 'people_female1', 'people_female2'] },
+  { id: 'mail', icons: ['mail_envelop', 'mail_mailbox', 'mail_edit', 'mail_list'] },
+  { id: 'flag', icons: ['flag_blue', 'flag_green', 'flag_orange', 'flag_pink', 'flag_purple', 'flag_yellow'] },
   {
-        "id": "bullet",
-        "icons": ["bullet_black", "bullet_blue", "bullet_green", "bullet_orange", "bullet_red", "bullet_pink", "bullet_purple"]
+    id: 'bullet',
+    icons: ['bullet_black', 'bullet_blue', 'bullet_green', 'bullet_orange', 'bullet_red', 'bullet_pink', 'bullet_purple'],
   },
-    {"id": "tag", "icons": ["tag_blue", "tag_green", "tag_orange", "tag_red", "tag_pink", "tag_yellow"]},
+  { id: 'tag', icons: ['tag_blue', 'tag_green', 'tag_orange', 'tag_red', 'tag_pink', 'tag_yellow'] },
   {
-        "id": "object",
-        "icons": ["object_bell", "object_clanbomber", "object_key", "object_pencil", "object_phone", "object_magnifier", "object_clip", "object_music", "object_star", "object_wizard", "object_house", "object_cake", "object_camera", "object_palette", "object_rainbow"]
+    id: 'object',
+    icons: ['object_bell', 'object_clanbomber', 'object_key', 'object_pencil', 'object_phone', 'object_magnifier', 'object_clip', 'object_music', 'object_star', 'object_wizard', 'object_house', 'object_cake', 'object_camera', 'object_palette', 'object_rainbow'],
   },
   {
-        "id": "weather",
-        "icons": ["weather_clear-night", "weather_clear", "weather_few-clouds-night", "weather_few-clouds", "weather_overcast", "weather_severe-alert", "weather_showers-scattered", "weather_showers", "weather_snow", "weather_storm"]
+    id: 'weather',
+    icons: ['weather_clear-night', 'weather_clear', 'weather_few-clouds-night', 'weather_few-clouds', 'weather_overcast', 'weather_severe-alert', 'weather_showers-scattered', 'weather_showers', 'weather_snow', 'weather_storm'],
   },
-    {"id": "task", "icons": ["task_0", "task_25", "task_50", "task_75", "task_100"]}
+  { id: 'task', icons: ['task_0', 'task_25', 'task_50', 'task_75', 'task_100'] },
 ];
 
 export default ImageIcon;

packages/mindplot/lib/components/Keyboard.js

@@ -18,17 +18,17 @@
 
 const Keyboard = new Class({
 
-    initialize: function () {
+  initialize() {
   },
 
-    addShortcut: function (shortcuts, callback) {
+  addShortcut(shortcuts, callback) {
     if (!$.isArray(shortcuts)) {
       shortcuts = [shortcuts];
     }
-        _.each(shortcuts, function (shortcut) {
+    _.each(shortcuts, (shortcut) => {
       $(document).bind('keydown', shortcut, callback);
     });
-    }
+  },
 
 });
 

packages/mindplot/lib/components/LinkIcon.js

@@ -21,7 +21,7 @@ const LinkIconTooltip = require('./widget/LinkIconTooltip').default;
 const LinkIcon = new Class({
 
   Extends: Icon,
-    initialize: function (topic, linkModel, readOnly) {
+  initialize(topic, linkModel, readOnly) {
     $assert(topic, 'topic can not be null');
     $assert(linkModel, 'linkModel can not be null');
 
@@ -33,40 +33,38 @@ const LinkIcon = new Class({
     this._registerEvents();
   },
 
-    _registerEvents: function () {
+  _registerEvents() {
     this._image.setCursor('pointer');
     this._tip = new LinkIconTooltip(this);
 
-        var me = this;
+    const me = this;
     if (!this._readOnly) {
       // Add on click event to open the editor ...
-            this.addEvent('click', function (event) {
+      this.addEvent('click', (event) => {
         me._tip.hide();
         me._topic.showLinkEditor();
         event.stopPropagation();
       });
       // FIXME: we shouldn't have timeout of that..
-            this.addEvent("mouseleave", function (event) {
-                window.setTimeout(function () {
-                    if (!$("#linkPopover:hover").length) {
+      this.addEvent('mouseleave', (event) => {
+        window.setTimeout(() => {
+          if (!$('#linkPopover:hover').length) {
             me._tip.hide();
           }
           event.stopPropagation();
-                }, 100)
+        }, 100);
       });
     }
 
-        $(this.getImage()._peer._native).mouseenter(function () {
+    $(this.getImage()._peer._native).mouseenter(() => {
       me._tip.show();
-        })
+    });
   },
 
-    getModel: function () {
+  getModel() {
     return this._linksModel;
-    }
+  },
 });
-LinkIcon.IMAGE_URL = "images/links.png";
+LinkIcon.IMAGE_URL = 'images/links.png';
 
 export default LinkIcon;
-
- 

packages/mindplot/lib/components/LocalStorageManager.js

@@ -19,46 +19,45 @@ const PersistenceManager = require('./PersistenceManager').default;
 
 const LocalStorageManager = new Class({
   Extends: PersistenceManager,
-        initialize: function (documentUrl, forceLoad) {
+  initialize(documentUrl, forceLoad) {
     this.parent();
     this.documentUrl = documentUrl;
     this.forceLoad = forceLoad;
   },
 
-        saveMapXml: function (mapId, mapXml, pref, saveHistory, events) {
-            localStorage.setItem(mapId + "-xml", mapXml);
+  saveMapXml(mapId, mapXml, pref, saveHistory, events) {
+    localStorage.setItem(`${mapId}-xml`, mapXml);
   },
 
-        discardChanges: function (mapId) {
-            localStorage.removeItem(mapId + "-xml");
+  discardChanges(mapId) {
+    localStorage.removeItem(`${mapId}-xml`);
   },
 
-        loadMapDom: function (mapId) {
-            var xml = localStorage.getItem(mapId + "-xml");
+  loadMapDom(mapId) {
+    let xml = localStorage.getItem(`${mapId}-xml`);
     if (xml == null || this.forceLoad) {
       $.ajax({
-                    url: this.documentUrl.replace("{id}", mapId),
-                    headers: {"Content-Type": "text/plain", "Accept": "application/xml"},
+        url: this.documentUrl.replace('{id}', mapId),
+        headers: { 'Content-Type': 'text/plain', Accept: 'application/xml' },
         type: 'get',
-                    dataType: "text",
+        dataType: 'text',
         async: false,
-                    success: function (response) {
+        success(response) {
           xml = response;
-                    }
+        },
       });
       // If I could not load it from a file, hard code one.
       if (xml == null) {
-                    throw new Error("Map could not be loaded");
+        throw new Error('Map could not be loaded');
       }
     }
 
     return jQuery.parseXML(xml);
   },
 
-        unlockMap: function (mindmap) {
+  unlockMap(mindmap) {
     // Ignore, no implementation required ...
-        }
-    }
-);
+  },
+});
 
 export default LocalStorageManager;

packages/mindplot/lib/components/MainTopic.js

@@ -15,9 +15,11 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const Core = require('@wismapping/core-js')
+const Core = require('@wismapping/core-js');
+
 const core = Core();
 const web2D = require('@wismapping/web2d');
+
 const web2d = web2D();
 
 const Topic = require('./Topic').default;
@@ -32,41 +34,41 @@ const MainTopic = new Class(/** @lends MainTopic */ {
          * @param model
          * @param options
          */
-        initialize: function (model, options) {
+  initialize(model, options) {
     this.parent(model, options);
   },
 
   INNER_RECT_ATTRIBUTES: { stroke: '0.5 solid #009900' },
 
-        _buildDragShape: function () {
-            var innerShape = this._buildShape(this.INNER_RECT_ATTRIBUTES, this.getShapeType());
-            var size = this.getSize();
+  _buildDragShape() {
+    const innerShape = this._buildShape(this.INNER_RECT_ATTRIBUTES, this.getShapeType());
+    const size = this.getSize();
     innerShape.setSize(size.width, size.height);
     innerShape.setPosition(0, 0);
     innerShape.setOpacity(0.5);
     innerShape.setCursor('default');
     innerShape.setVisibility(true);
 
-            var brColor = this.getBorderColor();
+    const brColor = this.getBorderColor();
     innerShape.setAttribute('strokeColor', brColor);
 
-            var bgColor = this.getBackgroundColor();
+    const bgColor = this.getBackgroundColor();
     innerShape.setAttribute('fillColor', bgColor);
 
     //  Create group ...
-            var groupAttributes = {
+    const groupAttributes = {
       width: 100,
       height: 100,
       coordSizeWidth: 100,
       coordSizeHeight: 100,
     };
-            var group = new web2d.Group(groupAttributes);
+    const group = new web2d.Group(groupAttributes);
     group.append(innerShape);
 
     // Add Text ...
     if (this.getShapeType() != TopicShape.IMAGE) {
-                var textShape = this._buildTextShape(true);
-                var text = this.getText();
+      const textShape = this._buildTextShape(true);
+      const text = this.getText();
       textShape.setText(text);
       textShape.setOpacity(0.5);
       group.append(textShape);
@@ -75,10 +77,10 @@ const MainTopic = new Class(/** @lends MainTopic */ {
   },
 
   /** */
-        updateTopicShape: function (targetTopic, workspace) {
+  updateTopicShape(targetTopic, workspace) {
     // Change figure based on the connected topic ...
-            var model = this.getModel();
-            var shapeType = model.getShapeType();
+    const model = this.getModel();
+    let shapeType = model.getShapeType();
     if (!targetTopic.isCentralTopic()) {
       if (!$defined(shapeType)) {
         // Get the real shape type ...
@@ -89,54 +91,54 @@ const MainTopic = new Class(/** @lends MainTopic */ {
   },
 
   /** */
-        disconnect: function (workspace) {
+  disconnect(workspace) {
     this.parent(workspace);
-            var size = this.getSize();
+    const size = this.getSize();
 
-            var model = this.getModel();
-            var shapeType = model.getShapeType();
+    const model = this.getModel();
+    let shapeType = model.getShapeType();
     if (!$defined(shapeType)) {
       // Change figure ...
       shapeType = this.getShapeType();
       this._setShapeType(TopicShape.ROUNDED_RECT, false);
     }
-            var innerShape = this.getInnerShape();
+    const innerShape = this.getInnerShape();
     innerShape.setVisibility(true);
   },
 
-        _updatePositionOnChangeSize: function (oldSize, newSize) {
-            var xOffset = Math.round((newSize.width - oldSize.width) / 2);
-            var pos = this.getPosition();
+  _updatePositionOnChangeSize(oldSize, newSize) {
+    const xOffset = Math.round((newSize.width - oldSize.width) / 2);
+    const pos = this.getPosition();
     if ($defined(pos)) {
       if (pos.x > 0) {
-                    pos.x = pos.x + xOffset;
+        pos.x += xOffset;
       } else {
-                    pos.x = pos.x - xOffset;
+        pos.x -= xOffset;
       }
       this.setPosition(pos);
     }
   },
 
   /** */
-        workoutIncomingConnectionPoint: function (sourcePosition) {
+  workoutIncomingConnectionPoint(sourcePosition) {
     return Shape.workoutIncomingConnectionPoint(this, sourcePosition);
   },
 
   /** */
-        workoutOutgoingConnectionPoint: function (targetPosition) {
+  workoutOutgoingConnectionPoint(targetPosition) {
     $assert(targetPosition, 'targetPoint can not be null');
-            var pos = this.getPosition();
-            var isAtRight = Shape.isAtRight(targetPosition, pos);
-            var size = this.getSize();
+    const pos = this.getPosition();
+    const isAtRight = Shape.isAtRight(targetPosition, pos);
+    const size = this.getSize();
 
-            var result;
+    let result;
     if (this.getShapeType() == TopicShape.LINE) {
       result = new core.Point();
-                var groupPosition = this._elem2d.getPosition();
-                var innerShareSize = this.getInnerShape().getSize();
+      const groupPosition = this._elem2d.getPosition();
+      const innerShareSize = this.getInnerShape().getSize();
 
       if (innerShareSize) {
-                    var magicCorrectionNumber = 0.3;
+        const magicCorrectionNumber = 0.3;
         if (!isAtRight) {
           result.x = groupPosition.x + innerShareSize.width - magicCorrectionNumber;
         } else {
@@ -158,12 +160,11 @@ const MainTopic = new Class(/** @lends MainTopic */ {
         pos,
         size,
         isAtRight,
-                    true
+        true,
       );
     }
     return result;
   },
-    }
-);
+});
 
 export default MainTopic;

packages/mindplot/lib/components/Messages.js

@@ -18,9 +18,9 @@
 
 const Messages = new Class({
   Static: {
-        init: function (locale) {
+    init(locale) {
       locale = $defined(locale) ? locale : 'en';
-            var bundle = Messages.BUNDLES[locale];
+      let bundle = Messages.BUNDLES[locale];
       if (bundle == null && locale.indexOf('_') != -1) {
         // Try to locate without the specialization ...
         locale = locale.substring(0, locale.indexOf('_'));
@@ -36,8 +36,8 @@ global.$msg = function (key) {
     Messages.init('en');
   }
 
-    var msg = Messages.__bundle[key];
-    return msg ? msg : key;
+  const msg = Messages.__bundle[key];
+  return msg || key;
 };
 
 Messages.BUNDLES = {};

packages/mindplot/lib/components/MultilineTextEditor.js

@@ -20,39 +20,37 @@ const ActionDispatcher = require('./ActionDispatcher').default;
 
 const MultilineTextEditor = new Class({
   Extends: Events,
-    initialize: function () {
+  initialize() {
     this._topic = null;
     this._timeoutId = -1;
   },
 
-    _buildEditor: function () {
-
-        var result = $('<div></div>')
+  _buildEditor() {
+    const result = $('<div></div>')
       .attr('id', 'textContainer')
       .css({
-                display: "none",
-                zIndex: "8",
-                overflow: "hidden",
-                border: "0 none"
+        display: 'none',
+        zIndex: '8',
+        overflow: 'hidden',
+        border: '0 none',
       });
 
-
-        var textareaElem = $('<textarea tabindex="-1" value="" wrap="off" ></textarea>')
+    const textareaElem = $('<textarea tabindex="-1" value="" wrap="off" ></textarea>')
       .css({
-                border: "1px gray dashed",
-                background: "rgba(98, 135, 167, .3)",
+        border: '1px gray dashed',
+        background: 'rgba(98, 135, 167, .3)',
         outline: '0 none',
         resize: 'none',
-                overflow: "hidden"
+        overflow: 'hidden',
       });
 
     result.append(textareaElem);
     return result;
   },
 
-    _registerEvents: function (containerElem) {
-        var textareaElem = this._getTextareaElem();
-        var me = this;
+  _registerEvents(containerElem) {
+    const textareaElem = this._getTextareaElem();
+    const me = this;
     textareaElem.on('keydown', function (event) {
       switch (jQuery.hotkeys.specialKeys[event.keyCode]) {
         case 'esc':
@@ -60,33 +58,30 @@ const MultilineTextEditor = new Class({
           break;
         case 'enter':
           if (event.metaKey || event.ctrlKey) {
-
             // Add return ...
-                        var text = textareaElem.val();
-                        var cursorPosition = text.length;
+            const text = textareaElem.val();
+            let cursorPosition = text.length;
             if (textareaElem.selectionStart) {
               cursorPosition = textareaElem.selectionStart;
             }
 
-                        var head = text.substring(0, cursorPosition);
-                        var tail = "";
+            const head = text.substring(0, cursorPosition);
+            let tail = '';
             if (cursorPosition < text.length) {
               tail = text.substring(cursorPosition, text.length);
             }
-                        textareaElem.val(head + "\n" + tail);
+            textareaElem.val(`${head}\n${tail}`);
 
             // Position cursor ...
             if (textareaElem[0].setSelectionRange) {
               textareaElem.focus();
               textareaElem[0].setSelectionRange(cursorPosition + 1, cursorPosition + 1);
             } else if (textareaElem.createTextRange) {
-                            var range = textareaElem.createTextRange();
+              const range = textareaElem.createTextRange();
               range.moveStart('character', cursorPosition + 1);
               range.select();
             }
-
-                    }
-                    else {
+          } else {
             me.close(true);
           }
           break;
@@ -96,7 +91,7 @@ const MultilineTextEditor = new Class({
           var end = $(this).get(0).selectionEnd;
 
           // set textarea value to: text before caret + tab + text after caret
-                    $(this).val($(this).val().substring(0, start) + "\t" + $(this).val().substring(end));
+          $(this).val(`${$(this).val().substring(0, start)}\t${$(this).val().substring(end)}`);
 
           // put caret at right position again
           $(this).get(0).selectionStart = $(this).get(0).selectionEnd = start + 1;
@@ -105,66 +100,63 @@ const MultilineTextEditor = new Class({
       event.stopPropagation();
     });
 
-        textareaElem.on('keypress', function (event) {
+    textareaElem.on('keypress', (event) => {
       event.stopPropagation();
     });
 
-        textareaElem.on('keyup', function (event) {
-            var text = me._getTextareaElem().val();
+    textareaElem.on('keyup', (event) => {
+      const text = me._getTextareaElem().val();
       me.fireEvent('input', [event, text]);
       me._adjustEditorSize();
     });
 
     // If the user clicks on the input, all event must be ignored ...
-        containerElem.on('click', function (event) {
+    containerElem.on('click', (event) => {
       event.stopPropagation();
     });
-        containerElem.on('dblclick', function (event) {
+    containerElem.on('dblclick', (event) => {
       event.stopPropagation();
     });
-        containerElem.on('mousedown', function (event) {
+    containerElem.on('mousedown', (event) => {
       event.stopPropagation();
     });
   },
 
-    _adjustEditorSize: function () {
-
+  _adjustEditorSize() {
     if (this.isVisible()) {
-            var textElem = this._getTextareaElem();
+      const textElem = this._getTextareaElem();
 
-            var lines = textElem.val().split('\n');
-            var maxLineLength = 1;
-            _.each(lines, function (line) {
-                if (maxLineLength < line.length)
-                    maxLineLength = line.length;
+      const lines = textElem.val().split('\n');
+      let maxLineLength = 1;
+      _.each(lines, (line) => {
+        if (maxLineLength < line.length) maxLineLength = line.length;
       });
 
       textElem.attr('cols', maxLineLength);
       textElem.attr('rows', lines.length);
 
       this._containerElem.css({
-                width: (maxLineLength + 3) + 'em',
-                height: textElem.height()
+        width: `${maxLineLength + 3}em`,
+        height: textElem.height(),
       });
     }
   },
 
-    isVisible: function () {
+  isVisible() {
     return $defined(this._containerElem) && this._containerElem.css('display') == 'block';
   },
 
-    _updateModel: function () {
-
+  _updateModel() {
     if (this._topic.getText() != this._getText()) {
-            var text = this._getText();
-            var topicId = this._topic.getId();
+      const text = this._getText();
+      const topicId = this._topic.getId();
 
-            var actionDispatcher = ActionDispatcher.getInstance();
+      const actionDispatcher = ActionDispatcher.getInstance();
       actionDispatcher.changeTextToTopic([topicId], text);
     }
   },
 
-    show: function (topic, text) {
+  show(topic, text) {
     // Close a previous node editor if it's opened ...
     if (this._topic) {
       this.close(false);
@@ -173,7 +165,7 @@ const MultilineTextEditor = new Class({
     this._topic = topic;
     if (!this.isVisible()) {
       // Create editor ui
-            var containerElem = this._buildEditor();
+      const containerElem = this._buildEditor();
       $('body').append(containerElem);
 
       this._containerElem = containerElem;
@@ -182,102 +174,98 @@ const MultilineTextEditor = new Class({
     }
   },
 
-    _showEditor: function (defaultText) {
-
-        var topic = this._topic;
+  _showEditor(defaultText) {
+    const topic = this._topic;
 
     // Hide topic text ...
     topic.getTextShape().setVisibility(false);
 
     // Set Editor Style
-        var nodeText = topic.getTextShape();
-        var font = nodeText.getFont();
+    const nodeText = topic.getTextShape();
+    const font = nodeText.getFont();
     font.size = nodeText.getHtmlFontSize();
     font.color = nodeText.getColor();
     this._setStyle(font);
-        var me = this;
+    const me = this;
     // Set editor's initial size
-        var displayFunc = function () {
+    const displayFunc = function () {
       // Position the editor and set the size...
-            var textShape = topic.getTextShape();
+      const textShape = topic.getTextShape();
 
       me._containerElem.css('display', 'block');
 
       // FIXME: Im not sure if this is best way...
-            var shapePosition = textShape.getNativePosition();
+      const shapePosition = textShape.getNativePosition();
       me._containerElem.offset(shapePosition);
 
       // Set editor's initial text ...
-            var text = $defined(defaultText) ? defaultText : topic.getText();
+      const text = $defined(defaultText) ? defaultText : topic.getText();
       me._setText(text);
 
       // Set the element focus and select the current text ...
-            var inputElem = me._getTextareaElem();
+      const inputElem = me._getTextareaElem();
       me._positionCursor(inputElem, !$defined(defaultText));
-
     };
 
     this._timeoutId = displayFunc.delay(10);
   },
 
-    _setStyle: function (fontStyle) {
-        var inputField = this._getTextareaElem();
+  _setStyle(fontStyle) {
+    const inputField = this._getTextareaElem();
     if (!$defined(fontStyle.font)) {
-            fontStyle.font = "Arial";
+      fontStyle.font = 'Arial';
     }
     if (!$defined(fontStyle.style)) {
-            fontStyle.style = "normal";
+      fontStyle.style = 'normal';
     }
     if (!$defined(fontStyle.weight)) {
-            fontStyle.weight = "normal";
+      fontStyle.weight = 'normal';
     }
     if (!$defined(fontStyle.size)) {
       fontStyle.size = 12;
     }
-        var style = {
-            fontSize: fontStyle.size + "px",
+    const style = {
+      fontSize: `${fontStyle.size}px`,
       fontFamily: fontStyle.font,
       fontStyle: fontStyle.style,
       fontWeight: fontStyle.weight,
-            color: fontStyle.color
+      color: fontStyle.color,
     };
     inputField.css(style);
     this._containerElem.css(style);
   },
 
-    _setText: function (text) {
-        var textareaElem = this._getTextareaElem();
+  _setText(text) {
+    const textareaElem = this._getTextareaElem();
     textareaElem.val(text);
     this._adjustEditorSize();
   },
 
-    _getText: function () {
+  _getText() {
     return this._getTextareaElem().val();
   },
 
-    _getTextareaElem: function () {
+  _getTextareaElem() {
     return this._containerElem.find('textarea');
   },
 
-    _positionCursor: function (textareaElem, selectText) {
+  _positionCursor(textareaElem, selectText) {
     textareaElem.focus();
-        var lengh = textareaElem.val().length;
+    const lengh = textareaElem.val().length;
     if (selectText) {
       // Mark text as selected ...
       if (textareaElem.createTextRange) {
-                var rang = textareaElem.createTextRange();
+        const rang = textareaElem.createTextRange();
         rang.select();
-                rang.move("character", lengh);
-            }
-            else {
+        rang.move('character', lengh);
+      } else {
         textareaElem[0].setSelectionRange(0, lengh);
       }
-
     } else {
       // Move the cursor to the last character ..
       if (textareaElem.createTextRange) {
-                var range = textareaElem.createTextRange();
-                range.move("character", lengh);
+        const range = textareaElem.createTextRange();
+        range.move('character', lengh);
       } else {
         if (Browser.ie11) {
           textareaElem[0].selectionStart = lengh;
@@ -289,10 +277,9 @@ const MultilineTextEditor = new Class({
         textareaElem.focus();
       }
     }
-
   },
 
-    close: function (update) {
+  close(update) {
     if (this.isVisible() && this._topic) {
       // Update changes ...
       clearTimeout(this._timeoutId);
@@ -310,7 +297,7 @@ const MultilineTextEditor = new Class({
       this._timeoutId = -1;
     }
     this._topic = null;
-    }
+  },
 });
 
 export default MultilineTextEditor;

packages/mindplot/lib/components/NodeGraph.js

@@ -27,7 +27,7 @@ const NodeGraph = new Class(
          * @param {Object<Number, String, Boolean>} options
          * @throws will throw an error if nodeModel is null or undefined
          */
-        initialize: function (nodeModel, options) {
+    initialize(nodeModel, options) {
       $assert(nodeModel, 'model can not be null');
 
       this._options = options;
@@ -38,13 +38,13 @@ const NodeGraph = new Class(
     },
 
     /** @return true if option is set to read-only */
-        isReadOnly: function () {
+    isReadOnly() {
       return this._options.readOnly;
     },
 
     /** @return model type */
-        getType: function () {
-            var model = this.getModel();
+    getType() {
+      const model = this.getModel();
       return model.getType();
     },
 
@@ -52,12 +52,12 @@ const NodeGraph = new Class(
          * @param {String} id
          * @throws will throw an error if the topic id is not a number
          */
-        setId: function (id) {
-            $assert(typeof topic.getId() == 'number', 'id is not a number:' + id);
+    setId(id) {
+      $assert(typeof topic.getId() === 'number', `id is not a number:${id}`);
       this.getModel().setId(id);
     },
 
-        _set2DElement: function (elem2d) {
+    _set2DElement(elem2d) {
       this._elem2d = elem2d;
     },
 
@@ -65,51 +65,51 @@ const NodeGraph = new Class(
          * @return 2D element
          * @throws will throw an error if the element is null or undefined within node graph
          */
-        get2DElement: function () {
+    get2DElement() {
       $assert(this._elem2d, 'NodeGraph has not been initialized properly');
       return this._elem2d;
     },
 
     /** @abstract */
-        setPosition: function (point, fireEvent) {
+    setPosition(point, fireEvent) {
       throw 'Unsupported operation';
     },
 
     /** */
-        addEvent: function (type, listener) {
-            var elem = this.get2DElement();
+    addEvent(type, listener) {
+      const elem = this.get2DElement();
       elem.addEvent(type, listener);
     },
 
     /** */
-        removeEvent: function (type, listener) {
-            var elem = this.get2DElement();
+    removeEvent(type, listener) {
+      const elem = this.get2DElement();
       elem.removeEvent(type, listener);
     },
 
     /** */
-        fireEvent: function (type, event) {
-            var elem = this.get2DElement();
+    fireEvent(type, event) {
+      const elem = this.get2DElement();
       elem.trigger(type, event);
     },
 
     /** */
-        setMouseEventsEnabled: function (isEnabled) {
+    setMouseEventsEnabled(isEnabled) {
       this._mouseEvents = isEnabled;
     },
 
     /** */
-        isMouseEventsEnabled: function () {
+    isMouseEventsEnabled() {
       return this._mouseEvents;
     },
 
     /** @return {Object<Number>} size */
-        getSize: function () {
+    getSize() {
       return this._size;
     },
 
     /** @param {Object<Number>} size */
-        setSize: function (size) {
+    setSize(size) {
       this._size.width = parseInt(size.width);
       this._size.height = parseInt(size.height);
     },
@@ -117,7 +117,7 @@ const NodeGraph = new Class(
     /**
          * @return {mindplot.model.NodeModel} the node model
          */
-        getModel: function () {
+    getModel() {
       $assert(this._model, 'Model has not been initialized yet');
       return this._model;
     },
@@ -126,21 +126,21 @@ const NodeGraph = new Class(
          * @param {mindplot.NodeModel} model the node model
          * @throws will throw an error if model is null or undefined
          */
-        setModel: function (model) {
+    setModel(model) {
       $assert(model, 'Model can not be null');
       this._model = model;
     },
 
     /** */
-        getId: function () {
+    getId() {
       return this._model.getId();
     },
 
     /** */
-        setOnFocus: function (focus) {
+    setOnFocus(focus) {
       if (this._onFocus != focus) {
         this._onFocus = focus;
-                var outerShape = this.getOuterShape();
+        const outerShape = this.getOuterShape();
         if (focus) {
           outerShape.setFill(Topic.OUTER_SHAPE_ATTRIBUTES_FOCUS.fillColor);
           outerShape.setOpacity(1);
@@ -159,32 +159,32 @@ const NodeGraph = new Class(
     },
 
     /** @return {Boolean} true if the node graph is on focus */
-        isOnFocus: function () {
+    isOnFocus() {
       return this._onFocus;
     },
 
     /** */
-        dispose: function (workspace) {
+    dispose(workspace) {
       this.setOnFocus(false);
       workspace.removeChild(this);
     },
 
     /** */
-        createDragNode: function (layoutManager) {
-            var dragShape = this._buildDragShape();
+    createDragNode(layoutManager) {
+      const dragShape = this._buildDragShape();
       return new DragTopic(dragShape, this, layoutManager);
     },
 
-        _buildDragShape: function () {
+    _buildDragShape() {
       $assert(false, '_buildDragShape must be implemented by all nodes.');
     },
 
     /** */
-        getPosition: function () {
-            var model = this.getModel();
+    getPosition() {
+      const model = this.getModel();
       return model.getPosition();
     },
-    }
+  },
 );
 
 /**
@@ -204,16 +204,16 @@ NodeGraph.create = function (nodeModel, options) {
 
   $assert(nodeModel, 'Model can not be null');
 
-    var type = nodeModel.getType();
+  const type = nodeModel.getType();
   $assert(type, 'Node model type can not be null');
 
-    var result;
+  let result;
   if (type == INodeModel.CENTRAL_TOPIC_TYPE) {
     result = new CentralTopic(nodeModel, options);
   } else if (type == INodeModel.MAIN_TOPIC_TYPE) {
     result = new MainTopic(nodeModel, options);
   } else {
-        $assert(false, 'unsupported node type:' + type);
+    $assert(false, `unsupported node type:${type}`);
   }
 
   return result;

packages/mindplot/lib/components/NoteIcon.js

@@ -20,7 +20,7 @@ const FloatingTip = require('./widget/FloatingTip').default;
 
 const NoteIcon = new Class({
   Extends: Icon,
-    initialize: function (topic, noteModel, readOnly) {
+  initialize(topic, noteModel, readOnly) {
     $assert(topic, 'topic can not be null');
 
     this.parent(NoteIcon.IMAGE_URL);
@@ -31,13 +31,13 @@ const NoteIcon = new Class({
     this._registerEvents();
   },
 
-    _registerEvents: function () {
+  _registerEvents() {
     this._image.setCursor('pointer');
-        var me = this;
+    const me = this;
 
     if (!this._readOnly) {
       // Add on click event to open the editor ...
-            this.addEvent('click', function (event) {
+      this.addEvent('click', (event) => {
         me._topic.showNoteEditor();
         event.stopPropagation();
       });
@@ -46,39 +46,37 @@ const NoteIcon = new Class({
       title: $msg('NOTE'),
       container: 'body',
       // Content can also be a function of the target element!
-            content: function () {
+      content() {
         return me._buildTooltipContent();
       },
       html: true,
       placement: 'bottom',
-            destroyOnExit: true
+      destroyOnExit: true,
     });
-
   },
 
-    _buildTooltipContent: function () {
-        if ($("body").find("#textPopoverNote").length == 1) {
-            var text = $("body").find("#textPopoverNote");
+  _buildTooltipContent() {
+    if ($('body').find('#textPopoverNote').length == 1) {
+      var text = $('body').find('#textPopoverNote');
       text.text(this._linksModel.getText());
     } else {
-            var result = $('<div id="textPopoverNote"></div>').css({padding: '5px'});
+      const result = $('<div id="textPopoverNote"></div>').css({ padding: '5px' });
 
       var text = $('<div></div>').text(this._linksModel.getText())
         .css({
           'white-space': 'pre-wrap',
-                    'word-wrap': 'break-word'
-                }
-            );
+          'word-wrap': 'break-word',
+        });
       result.append(text);
       return result;
     }
   },
 
-    getModel: function () {
+  getModel() {
     return this._linksModel;
-    }
+  },
 });
 
-NoteIcon.IMAGE_URL = "images/notes.png";
+NoteIcon.IMAGE_URL = 'images/notes.png';
 
-export default NoteIcon
+export default NoteIcon;

packages/mindplot/lib/components/Options.js

@@ -1,14 +1,16 @@
 const Options = new Class({
 
-    setOptions: function () {
-        var options = this.options = Object.merge.apply(null, [{}, this.options].append(arguments));
-        if (this.addEvent) for (var option in options) {
+  setOptions() {
+    const options = this.options = Object.merge.apply(null, [{}, this.options].append(arguments));
+    if (this.addEvent) {
+      for (const option in options) {
         if (typeOf(options[option]) != 'function' || !(/^on[A-Z]/).test(option)) continue;
         this.addEvent(option, options[option]);
         delete options[option];
       }
-        return this;
     }
+    return this;
+  },
 
 });
 

packages/mindplot/lib/components/PersistenceManager.js

@@ -16,34 +16,35 @@
  *   limitations under the License.
  */
 const Core = require('@wismapping/core-js');
+
 const core = Core();
 const XMLSerializerFactory = require('./persistence/XMLSerializerFactory');
 
 const PersistenceManager = new Class({
   Static: {
-        loadFromDom: function (mapId, mapDom) {
+    loadFromDom(mapId, mapDom) {
       $assert(mapId, 'mapId can not be null');
       $assert(mapDom, 'mapDom can not be null');
 
-            var serializer = XMLSerializerFactory.getSerializerFromDocument(mapDom);
+      const serializer = XMLSerializerFactory.getSerializerFromDocument(mapDom);
       return serializer.loadFromDom(mapDom, mapId);
     },
   },
 
-    initialize: function () {},
+  initialize() {},
 
-    save: function (mindmap, editorProperties, saveHistory, events, sync) {
+  save(mindmap, editorProperties, saveHistory, events, sync) {
     $assert(mindmap, 'mindmap can not be null');
     $assert(editorProperties, 'editorProperties can not be null');
 
-        var mapId = mindmap.getId();
+    const mapId = mindmap.getId();
     $assert(mapId, 'mapId can not be null');
 
-        var serializer = XMLSerializerFactory.getSerializerFromMindmap(mindmap);
-        var domMap = serializer.toXML(mindmap);
-        var mapXml = core.Utils.innerXML(domMap);
+    const serializer = XMLSerializerFactory.getSerializerFromMindmap(mindmap);
+    const domMap = serializer.toXML(mindmap);
+    const mapXml = core.Utils.innerXML(domMap);
 
-        var pref = JSON.stringify(editorProperties);
+    const pref = JSON.stringify(editorProperties);
     try {
       this.saveMapXml(mapId, mapXml, pref, saveHistory, events, sync);
     } catch (e) {
@@ -52,25 +53,25 @@ const PersistenceManager = new Class({
     }
   },
 
-    load: function (mapId) {
+  load(mapId) {
     $assert(mapId, 'mapId can not be null');
-        var domDocument = this.loadMapDom(mapId);
+    const domDocument = this.loadMapDom(mapId);
     return PersistenceManager.loadFromDom(mapId, domDocument);
   },
 
-    discardChanges: function (mapId) {
+  discardChanges(mapId) {
     throw new Error('Method must be implemented');
   },
 
-    loadMapDom: function (mapId) {
+  loadMapDom(mapId) {
     throw new Error('Method must be implemented');
   },
 
-    saveMapXml: function (mapId, mapXml, pref, saveHistory, events, sync) {
+  saveMapXml(mapId, mapXml, pref, saveHistory, events, sync) {
     throw new Error('Method must be implemented');
   },
 
-    unlockMap: function (mindmap) {
+  unlockMap(mindmap) {
     throw new Error('Method must be implemented');
   },
 });

packages/mindplot/lib/components/Relationship.js

@@ -15,10 +15,12 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const Core = require('@wismapping/core-js')
+const Core = require('@wismapping/core-js');
+
 const core = Core();
 
-const web2D = require('@wismapping/web2d')
+const web2D = require('@wismapping/web2d');
+
 const web2d = web2D();
 
 const ConnectionLine = require('./ConnectionLine').default;
@@ -26,24 +28,24 @@ const ControlPoint = require('./ControlPoint').default;
 
 const INodeModel = require('./model/INodeModel').default;
 
-const Shape = require('./util/Shape').default
+const Shape = require('./util/Shape').default;
 
 const Relationship = new Class({
   Extends: ConnectionLine,
   Static: {
-        getStrokeColor: function () {
+    getStrokeColor() {
       return '#9b74e6';
     },
-        type: "Relationship"
+    type: 'Relationship',
   },
-    initialize: function (sourceNode, targetNode, model) {
-        $assert(sourceNode, "sourceNode can not be null");
-        $assert(targetNode, "targetNode can not be null");
+  initialize(sourceNode, targetNode, model) {
+    $assert(sourceNode, 'sourceNode can not be null');
+    $assert(targetNode, 'targetNode can not be null');
 
     this.parent(sourceNode, targetNode, model.getLineType());
     this.setModel(model);
 
-        var strokeColor = Relationship.getStrokeColor();
+    const strokeColor = Relationship.getStrokeColor();
 
     this._line2d.setIsSrcControlPointCustom(false);
     this._line2d.setIsDestControlPointCustom(false);
@@ -51,9 +53,9 @@ const Relationship = new Class({
     this._line2d.setStroke(1, 'solid', strokeColor);
     this._line2d.setDashed(4, 2);
     this._focusShape = this._createLine(this.getLineType(), ConnectionLine.SIMPLE_CURVED);
-        this._focusShape.setStroke(2, "solid", "#3f96ff");
+    this._focusShape.setStroke(2, 'solid', '#3f96ff');
 
-        var ctrlPoints = this._line2d.getControlPoints();
+    const ctrlPoints = this._line2d.getControlPoints();
     this._focusShape.setSrcControlPoint(ctrlPoints[0]);
     this._focusShape.setDestControlPoint(ctrlPoints[1]);
     this._focusShape.setVisibility(false);
@@ -75,48 +77,48 @@ const Relationship = new Class({
 
     // Position the line ...
     if ($defined(model.getSrcCtrlPoint())) {
-            var srcPoint = model.getSrcCtrlPoint().clone();
+      const srcPoint = model.getSrcCtrlPoint().clone();
       this.setSrcControlPoint(srcPoint);
     }
     if ($defined(model.getDestCtrlPoint())) {
-            var destPoint = model.getDestCtrlPoint().clone();
+      const destPoint = model.getDestCtrlPoint().clone();
       this.setDestControlPoint(destPoint);
     }
   },
 
-    setStroke: function (color, style, opacity) {
+  setStroke(color, style, opacity) {
     this.parent(color, style, opacity);
     this._startArrow.setStrokeColor(color);
   },
 
-    redraw: function () {
-        var line2d = this._line2d;
-        var sourceTopic = this._sourceTopic;
-        var sourcePosition = sourceTopic.getPosition();
+  redraw() {
+    const line2d = this._line2d;
+    const sourceTopic = this._sourceTopic;
+    const sourcePosition = sourceTopic.getPosition();
 
-        var targetTopic = this._targetTopic;
-        var targetPosition = targetTopic.getPosition();
+    const targetTopic = this._targetTopic;
+    let targetPosition = targetTopic.getPosition();
     if (targetTopic.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
       targetPosition = Shape.workoutIncomingConnectionPoint(targetTopic, sourcePosition);
     }
 
-        var sPos, tPos;
+    let sPos; let
+      tPos;
     this._line2d.setStroke(2);
-        var ctrlPoints = this._line2d.getControlPoints();
+    const ctrlPoints = this._line2d.getControlPoints();
     if (!this._line2d.isDestControlPointCustom() && !this._line2d.isSrcControlPointCustom()) {
-
-            var defaultPoints = Shape.calculateDefaultControlPoints(sourcePosition, targetPosition);
+      const defaultPoints = Shape.calculateDefaultControlPoints(sourcePosition, targetPosition);
       ctrlPoints[0].x = defaultPoints[0].x;
       ctrlPoints[0].y = defaultPoints[0].y;
 
       ctrlPoints[1].x = defaultPoints[1].x;
       ctrlPoints[1].y = defaultPoints[1].y;
     }
-        var spoint = new core.Point();
+    const spoint = new core.Point();
     spoint.x = parseInt(ctrlPoints[0].x) + parseInt(sourcePosition.x);
     spoint.y = parseInt(ctrlPoints[0].y) + parseInt(sourcePosition.y);
 
-        var tpoint = new core.Point();
+    const tpoint = new core.Point();
     tpoint.x = parseInt(ctrlPoints[1].x) + parseInt(targetPosition.x);
     tpoint.y = parseInt(ctrlPoints[1].y) + parseInt(targetPosition.y);
 
@@ -141,9 +143,9 @@ const Relationship = new Class({
     this._controlPointsController.redraw();
   },
 
-    _positionArrows: function () {
-        var tpos = this._line2d.getTo();
-        var spos = this._line2d.getFrom();
+  _positionArrows() {
+    const tpos = this._line2d.getTo();
+    const spos = this._line2d.getFrom();
 
     this._startArrow.setFrom(spos.x, spos.y);
     this._startArrow.moveToBack();
@@ -153,8 +155,8 @@ const Relationship = new Class({
       this._endArrow.moveToBack();
     }
 
-        if (this._line2d.getType() == "CurvedLine") {
-            var controlPoints = this._line2d.getControlPoints();
+    if (this._line2d.getType() == 'CurvedLine') {
+      const controlPoints = this._line2d.getControlPoints();
       this._startArrow.setControlPoint(controlPoints[0]);
       if (this._endArrow) {
         this._endArrow.setControlPoint(controlPoints[1]);
@@ -172,7 +174,7 @@ const Relationship = new Class({
     this._startArrow.setVisibility(this.isVisible() && this._showStartArrow);
   },
 
-    addToWorkspace: function (workspace) {
+  addToWorkspace(workspace) {
     workspace.append(this._focusShape);
     workspace.append(this._controlPointsController);
 
@@ -181,36 +183,33 @@ const Relationship = new Class({
     this._isInWorkspace = true;
 
     workspace.append(this._startArrow);
-        if (this._endArrow)
-            workspace.append(this._endArrow);
+    if (this._endArrow) workspace.append(this._endArrow);
 
     this.parent(workspace);
     this._positionArrows();
     this.redraw();
-
   },
 
-    _initializeControlPointController: function () {
+  _initializeControlPointController() {
     this.setOnFocus(true);
   },
 
-    removeFromWorkspace: function (workspace) {
+  removeFromWorkspace(workspace) {
     workspace.removeChild(this._focusShape);
     workspace.removeChild(this._controlPointsController);
     this._line2d.removeEvent('click', this._controlPointControllerListener);
     this._isInWorkspace = false;
     workspace.removeChild(this._startArrow);
-        if (this._endArrow)
-            workspace.removeChild(this._endArrow);
+    if (this._endArrow) workspace.removeChild(this._endArrow);
 
     this.parent(workspace);
   },
 
-    getType: function () {
+  getType() {
     return Relationship.type;
   },
 
-    setOnFocus: function (focus) {
+  setOnFocus(focus) {
     // Change focus shape
     if (this.isOnFocus() != focus) {
       if (focus) {
@@ -225,13 +224,13 @@ const Relationship = new Class({
     }
   },
 
-    _refreshShape: function () {
-        var sPos = this._line2d.getFrom();
-        var tPos = this._line2d.getTo();
-        var ctrlPoints = this._line2d.getControlPoints();
+  _refreshShape() {
+    const sPos = this._line2d.getFrom();
+    const tPos = this._line2d.getTo();
+    const ctrlPoints = this._line2d.getControlPoints();
     this._focusShape.setFrom(sPos.x, sPos.y);
     this._focusShape.setTo(tPos.x, tPos.y);
-        var shapeCtrlPoints = this._focusShape.getControlPoints();
+    const shapeCtrlPoints = this._focusShape.getControlPoints();
     shapeCtrlPoints[0].x = ctrlPoints[0].x;
     shapeCtrlPoints[0].y = ctrlPoints[0].y;
     shapeCtrlPoints[1].x = ctrlPoints[1].x;
@@ -239,107 +238,100 @@ const Relationship = new Class({
     this._focusShape.updateLine();
   },
 
-    addEvent: function (type, listener) {
+  addEvent(type, listener) {
     // Translate to web 2d events ...
     if (type == 'onfocus') {
       type = 'mousedown';
     }
 
-        var line = this._line2d;
+    const line = this._line2d;
     line.addEvent(type, listener);
   },
 
-    isOnFocus: function () {
+  isOnFocus() {
     return this._onFocus;
   },
 
-    isInWorkspace: function () {
+  isInWorkspace() {
     return this._isInWorkspace;
   },
 
-    setVisibility: function (value) {
+  setVisibility(value) {
     this.parent(value);
-        if (this._showEndArrow)
-            this._endArrow.setVisibility(this._showEndArrow);
+    if (this._showEndArrow) this._endArrow.setVisibility(this._showEndArrow);
     this._startArrow.setVisibility(this._showStartArrow && value);
   },
 
-    setOpacity: function (opacity) {
+  setOpacity(opacity) {
     this.parent(opacity);
-        if (this._showEndArrow)
-            this._endArrow.setOpacity(opacity);
-        if (this._showStartArrow)
-            this._startArrow.setOpacity(opacity);
+    if (this._showEndArrow) this._endArrow.setOpacity(opacity);
+    if (this._showStartArrow) this._startArrow.setOpacity(opacity);
   },
 
-    setShowEndArrow: function (visible) {
+  setShowEndArrow(visible) {
     this._showEndArrow = visible;
-        if (this._isInWorkspace)
-            this.redraw();
+    if (this._isInWorkspace) this.redraw();
   },
 
-    setShowStartArrow: function (visible) {
+  setShowStartArrow(visible) {
     this._showStartArrow = visible;
-        if (this._isInWorkspace)
-            this.redraw();
+    if (this._isInWorkspace) this.redraw();
   },
 
-    setFrom: function (x, y) {
-        $assert($defined(x), "x must be defined");
-        $assert($defined(y), "y must be defined");
+  setFrom(x, y) {
+    $assert($defined(x), 'x must be defined');
+    $assert($defined(y), 'y must be defined');
 
     this._line2d.setFrom(x, y);
     this._startArrow.setFrom(x, y);
   },
 
-    setTo: function (x, y) {
-        $assert($defined(x), "x must be defined");
-        $assert($defined(y), "y must be defined");
+  setTo(x, y) {
+    $assert($defined(x), 'x must be defined');
+    $assert($defined(y), 'y must be defined');
 
     this._line2d.setTo(x, y);
-        if (this._endArrow)
-            this._endArrow.setFrom(x, y);
+    if (this._endArrow) this._endArrow.setFrom(x, y);
   },
 
-    setSrcControlPoint: function (control) {
+  setSrcControlPoint(control) {
     this._line2d.setSrcControlPoint(control);
     this._startArrow.setControlPoint(control);
   },
 
-    setDestControlPoint: function (control) {
+  setDestControlPoint(control) {
     this._line2d.setDestControlPoint(control);
-        if (this._showEndArrow)
-            this._endArrow.setControlPoint(control);
+    if (this._showEndArrow) this._endArrow.setControlPoint(control);
   },
 
-    getControlPoints: function () {
+  getControlPoints() {
     return this._line2d.getControlPoints();
   },
 
-    isSrcControlPointCustom: function () {
+  isSrcControlPointCustom() {
     return this._line2d.isSrcControlPointCustom();
   },
 
-    isDestControlPointCustom: function () {
+  isDestControlPointCustom() {
     return this._line2d.isDestControlPointCustom();
   },
 
-    setIsSrcControlPointCustom: function (isCustom) {
+  setIsSrcControlPointCustom(isCustom) {
     this._line2d.setIsSrcControlPointCustom(isCustom);
   },
 
-    setIsDestControlPointCustom: function (isCustom) {
+  setIsDestControlPointCustom(isCustom) {
     this._line2d.setIsDestControlPointCustom(isCustom);
   },
 
-    getId: function () {
+  getId() {
     return this._model.getId();
   },
 
-    fireEvent: function (type, event) {
-        var elem = this._line2d;
+  fireEvent(type, event) {
+    const elem = this._line2d;
     elem.trigger(type, event);
-    }
+  },
 });
 
 export default Relationship;

packages/mindplot/lib/components/RelationshipPivot.js

@@ -15,17 +15,19 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const Core = require('@wismapping/core-js')
+const Core = require('@wismapping/core-js');
+
 const core = Core();
-const web2D = require('@wismapping/web2d')
+const web2D = require('@wismapping/web2d');
+
 const web2d = web2D();
-const INodeModel = require('./model/INodeModel').default
+const INodeModel = require('./model/INodeModel').default;
 const Shape = require('./util/Shape').default;
 
 const RelationshipPivot = new Class({
-    initialize: function (workspace, designer) {
-        $assert(workspace, "workspace can not be null");
-        $assert(designer, "designer can not be null");
+  initialize(workspace, designer) {
+    $assert(workspace, 'workspace can not be null');
+    $assert(designer, 'designer can not be null');
     this._workspace = workspace;
     this._designer = designer;
 
@@ -33,25 +35,24 @@ const RelationshipPivot = new Class({
     this._mouseMoveEvent = this._mouseMove.bind(this);
     this._onClickEvent = this._cleanOnMouseClick.bind(this);
     this._onTopicClick = this._connectOnFocus.bind(this);
-
   },
 
-    start: function (sourceTopic, targetPos) {
-        $assert(sourceTopic, "sourceTopic can not be null");
-        $assert(targetPos, "targetPos can not be null");
+  start(sourceTopic, targetPos) {
+    $assert(sourceTopic, 'sourceTopic can not be null');
+    $assert(targetPos, 'targetPos can not be null');
 
     this.dispose();
     this._sourceTopic = sourceTopic;
     if (sourceTopic != null) {
       this._workspace.enableWorkspaceEvents(false);
 
-            var sourcePos = sourceTopic.getPosition();
-            var strokeColor = Relationship.getStrokeColor();
+      const sourcePos = sourceTopic.getPosition();
+      const strokeColor = Relationship.getStrokeColor();
 
       this._pivot = new web2d.CurvedLine();
       this._pivot.setStyle(web2d.CurvedLine.SIMPLE_LINE);
 
-            var fromPos = this._calculateFromPosition(sourcePos);
+      const fromPos = this._calculateFromPosition(sourcePos);
       this._pivot.setFrom(fromPos.x, fromPos.y);
 
       this._pivot.setTo(targetPos.x, targetPos.y);
@@ -70,26 +71,25 @@ const RelationshipPivot = new Class({
       this._workspace.addEvent('click', this._onClickEvent);
 
       // Register focus events on all topics ...
-            var model = this._designer.getModel();
-            var topics = model.getTopics();
-            _.each(topics, function (topic) {
+      const model = this._designer.getModel();
+      const topics = model.getTopics();
+      _.each(topics, (topic) => {
         topic.addEvent('ontfocus', this._onTopicClick);
-            }.bind(this));
+      });
     }
-
   },
 
-    dispose: function () {
-        var workspace = this._workspace;
+  dispose() {
+    const workspace = this._workspace;
 
     if (this._isActive()) {
       workspace.removeEvent('mousemove', this._mouseMoveEvent);
       workspace.removeEvent('click', this._onClickEvent);
 
-            var model = this._designer.getModel();
-            var topics = model.getTopics();
-            var me = this;
-            _.each(topics, function (topic) {
+      const model = this._designer.getModel();
+      const topics = model.getTopics();
+      const me = this;
+      _.each(topics, (topic) => {
         topic.removeEvent('ontfocus', me._onTopicClick);
       });
 
@@ -103,21 +103,21 @@ const RelationshipPivot = new Class({
     }
   },
 
-    _mouseMove: function (event) {
-        var screen = this._workspace.getScreenManager();
-        var pos = screen.getWorkspaceMousePosition(event);
+  _mouseMove(event) {
+    const screen = this._workspace.getScreenManager();
+    const pos = screen.getWorkspaceMousePosition(event);
 
     // Leave the arrow a couple of pixels away from the cursor.
-        var sourcePosition = this._sourceTopic.getPosition();
-        var gapDistance = Math.sign(pos.x - sourcePosition.x) * 5;
+    const sourcePosition = this._sourceTopic.getPosition();
+    const gapDistance = Math.sign(pos.x - sourcePosition.x) * 5;
 
-        var sPos = this._calculateFromPosition(pos);
+    const sPos = this._calculateFromPosition(pos);
     this._pivot.setFrom(sPos.x, sPos.y);
 
     // Update target position ...
     this._pivot.setTo(pos.x - gapDistance, pos.y);
 
-        var controlPoints = this._pivot.getControlPoints();
+    const controlPoints = this._pivot.getControlPoints();
     this._startArrow.setFrom(pos.x - gapDistance, pos.y);
     this._startArrow.setControlPoint(controlPoints[1]);
 
@@ -125,43 +125,41 @@ const RelationshipPivot = new Class({
     return false;
   },
 
-    _cleanOnMouseClick: function (event) {
-
+  _cleanOnMouseClick(event) {
     // The user clicks on a desktop on in other element that is not a node.
     this.dispose();
     event.stopPropagation();
   },
 
-    _calculateFromPosition: function (toPosition) {
-
+  _calculateFromPosition(toPosition) {
     // Calculate origin position ...
-        var sourcePosition = this._sourceTopic.getPosition();
+    let sourcePosition = this._sourceTopic.getPosition();
     if (this._sourceTopic.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
       sourcePosition = Shape.workoutIncomingConnectionPoint(this._sourceTopic, toPosition);
     }
-        var controlPoint = Shape.calculateDefaultControlPoints(sourcePosition, toPosition);
+    const controlPoint = Shape.calculateDefaultControlPoints(sourcePosition, toPosition);
 
-        var spoint = new core.Point();
+    const spoint = new core.Point();
     spoint.x = parseInt(controlPoint[0].x) + parseInt(sourcePosition.x);
     spoint.y = parseInt(controlPoint[0].y) + parseInt(sourcePosition.y);
     return Shape.calculateRelationShipPointCoordinates(this._sourceTopic, spoint);
   },
 
-    _connectOnFocus: function (event, targetTopic) {
-        var sourceTopic = this._sourceTopic;
-        var mindmap = this._designer.getMindmap();
+  _connectOnFocus(event, targetTopic) {
+    const sourceTopic = this._sourceTopic;
+    const mindmap = this._designer.getMindmap();
 
     // Avoid circular connections ...
     if (targetTopic.getId() != sourceTopic.getId()) {
-            var relModel = mindmap.createRelationship(targetTopic.getId(), sourceTopic.getId());
+      const relModel = mindmap.createRelationship(targetTopic.getId(), sourceTopic.getId());
       this._designer._actionDispatcher.addRelationship(relModel);
     }
     this.dispose();
   },
 
-    _isActive: function () {
+  _isActive() {
     return this._pivot != null;
-    }
+  },
 });
 
 export default RelationshipPivot;

packages/mindplot/lib/components/RestPersistenceManager.js

@@ -19,13 +19,13 @@ const PersistenceManager = require('./PersistenceManager').default;
 
 const RESTPersistenceManager = new Class({
   Extends: PersistenceManager,
-        initialize: function (options) {
+  initialize(options) {
     this.parent();
-            $assert(options.documentUrl, "documentUrl can not be null");
-            $assert(options.revertUrl, "revertUrl can not be null");
-            $assert(options.lockUrl, "lockUrl can not be null");
-            $assert(options.session, "session can not be null");
-            $assert(options.timestamp, "timestamp can not be null");
+    $assert(options.documentUrl, 'documentUrl can not be null');
+    $assert(options.revertUrl, 'revertUrl can not be null');
+    $assert(options.lockUrl, 'lockUrl can not be null');
+    $assert(options.session, 'session can not be null');
+    $assert(options.timestamp, 'timestamp can not be null');
 
     this.documentUrl = options.documentUrl;
     this.revertUrl = options.revertUrl;
@@ -34,58 +34,55 @@ const RESTPersistenceManager = new Class({
     this.session = options.session;
   },
 
-        saveMapXml: function (mapId, mapXml, pref, saveHistory, events, sync) {
-
-            var data = {
+  saveMapXml(mapId, mapXml, pref, saveHistory, events, sync) {
+    const data = {
       id: mapId,
       xml: mapXml,
-                properties: pref
+      properties: pref,
     };
 
-            var persistence = this;
-            var query = "minor=" + !saveHistory;
-            query = query + "&timestamp=" + this.timestamp;
-            query = query + "&session=" + this.session;
+    const persistence = this;
+    let query = `minor=${!saveHistory}`;
+    query = `${query}&timestamp=${this.timestamp}`;
+    query = `${query}&session=${this.session}`;
 
     if (!persistence.onSave) {
-
       // Mark save in process and fire a event unlocking the save ...
       persistence.onSave = true;
-                persistence.clearTimeout = setTimeout(function () {
+      persistence.clearTimeout = setTimeout(() => {
         persistence.clearTimeout = null;
         persistence.onSave = false;
       }, 10000);
 
       $.ajax({
-                    url: this.documentUrl.replace("{id}", mapId) + "?" + query,
+        url: `${this.documentUrl.replace('{id}', mapId)}?${query}`,
         type: 'put',
-                    dataType: "json",
+        dataType: 'json',
         data: JSON.stringify(data),
-                    contentType: "application/json; charset=utf-8",
+        contentType: 'application/json; charset=utf-8',
         async: !sync,
 
-                    success: function (data, textStatus, jqXHRresponseText) {
+        success(data, textStatus, jqXHRresponseText) {
           persistence.timestamp = data;
           events.onSuccess();
         },
-                    error: function (jqXHR, textStatus, errorThrown) {
+        error(jqXHR, textStatus, errorThrown) {
           events.onError(persistence._buildError());
         },
-                    complete: function () {
+        complete() {
           // Clear event timeout ...
           if (persistence.clearTimeout) {
             clearTimeout(persistence.clearTimeout);
           }
           persistence.onSave = false;
         },
-                    fail: function (xhr, textStatus) {
+        fail(xhr, textStatus) {
+          const { responseText } = xhr;
+          let userMsg = { severity: 'SEVERE', message: $msg('SAVE_COULD_NOT_BE_COMPLETED') };
 
-                        var responseText = xhr.responseText;
-                        var userMsg = {severity: "SEVERE", message: $msg('SAVE_COULD_NOT_BE_COMPLETED')};
-
-                        var contentType = xhr.getResponseHeader("Content-Type");
-                        if (contentType != null && contentType.indexOf("application/json") != -1) {
-                            var serverMsg = null;
+          const contentType = xhr.getResponseHeader('Content-Type');
+          if (contentType != null && contentType.indexOf('application/json') != -1) {
+            let serverMsg = null;
             try {
               serverMsg = $.parseJSON(responseText);
               serverMsg = serverMsg.globalSeverity ? serverMsg : null;
@@ -93,74 +90,70 @@ const RESTPersistenceManager = new Class({
               // Message could not be decoded ...
             }
             userMsg = persistence._buildError(serverMsg);
-
-                        } else {
-                            if (this.status == 405) {
-                                userMsg = {severity: "SEVERE", message: $msg('SESSION_EXPIRED')};
-                            }
+          } else if (this.status == 405) {
+            userMsg = { severity: 'SEVERE', message: $msg('SESSION_EXPIRED') };
           }
           events.onError(userMsg);
           persistence.onSave = false;
-                    }
+        },
       });
     }
   },
 
-        discardChanges: function (mapId) {
+  discardChanges(mapId) {
     $.ajax({
-                url: this.revertUrl.replace("{id}", mapId),
+      url: this.revertUrl.replace('{id}', mapId),
       async: false,
       method: 'post',
-                headers: {"Content-Type": "application/json; charset=utf-8", "Accept": "application/json"}
+      headers: { 'Content-Type': 'application/json; charset=utf-8', Accept: 'application/json' },
     });
   },
 
-        unlockMap: function (mindmap) {
-            var mapId = mindmap.getId();
+  unlockMap(mindmap) {
+    const mapId = mindmap.getId();
     $.ajax({
-                url: this.lockUrl.replace("{id}", mapId),
+      url: this.lockUrl.replace('{id}', mapId),
       async: false,
       method: 'put',
-                headers: {"Content-Type": "text/plain"},
-                data: "false"
+      headers: { 'Content-Type': 'text/plain' },
+      data: 'false',
     });
   },
 
-        _buildError: function (jsonSeverResponse) {
-            var message = jsonSeverResponse ? jsonSeverResponse.globalErrors[0] : null;
-            var severity = jsonSeverResponse ? jsonSeverResponse.globalSeverity : null;
+  _buildError(jsonSeverResponse) {
+    let message = jsonSeverResponse ? jsonSeverResponse.globalErrors[0] : null;
+    let severity = jsonSeverResponse ? jsonSeverResponse.globalSeverity : null;
 
     if (!message) {
       message = $msg('SAVE_COULD_NOT_BE_COMPLETED');
     }
 
     if (!severity) {
-                severity = "INFO";
+      severity = 'INFO';
     }
-            return {severity: severity, message: message};
+    return { severity, message };
   },
 
-        loadMapDom: function (mapId) {
+  loadMapDom(mapId) {
     // Let's try to open one from the local directory ...
-            var xml;
+    let xml;
     $.ajax({
-                url: this.documentUrl.replace("{id}", mapId) + "/xml",
+      url: `${this.documentUrl.replace('{id}', mapId)}/xml`,
       method: 'get',
       async: false,
-                headers: {"Content-Type": "text/plain", "Accept": "application/xml"},
-                success: function (responseText) {
+      headers: { 'Content-Type': 'text/plain', Accept: 'application/xml' },
+      success(responseText) {
         xml = responseText;
-                }
+      },
     });
 
     // If I could not load it from a file, hard code one.
     if (xml == null) {
-                throw new Error("Map could not be loaded");
+      throw new Error('Map could not be loaded');
     }
 
     return xml;
-        }
-    }
-);
+  },
+});
 
 export default RESTPersistenceManager;

packages/mindplot/lib/components/ScreenManager.js

@@ -16,112 +16,109 @@
  *   limitations under the License.
  */
 const Core = require('@wismapping/core-js');
+
 const core = Core();
 
 const ScreenManager = new Class({
-    initialize: function (divElement) {
-        $assert(divElement, "can not be null");
+  initialize(divElement) {
+    $assert(divElement, 'can not be null');
     this._divContainer = divElement;
     this._padding = { x: 0, y: 0 };
 
     // Ignore default click event propagation. Prevent 'click' event on drag.
     this._clickEvents = [];
-        this._divContainer.bind('click', function (event) {
-            event.stopPropagation()
+    this._divContainer.bind('click', (event) => {
+      event.stopPropagation();
     });
 
-        this._divContainer.bind('dblclick', function (event) {
+    this._divContainer.bind('dblclick', (event) => {
       event.stopPropagation();
       event.preventDefault();
     });
   },
 
-    setScale: function (scale) {
+  setScale(scale) {
     $assert(scale, 'Screen scale can not be null');
     this._scale = scale;
   },
 
-    addEvent: function (event, listener) {
-        if (event == 'click')
-            this._clickEvents.push(listener);
-        else
-            this._divContainer.bind(event, listener);
+  addEvent(event, listener) {
+    if (event == 'click') this._clickEvents.push(listener);
+    else this._divContainer.bind(event, listener);
   },
 
-    removeEvent: function (event, listener) {
+  removeEvent(event, listener) {
     if (event == 'click') {
       this._clickEvents.remove(listener);
-        }
-        else {
+    } else {
       this._divContainer.unbind(event, listener);
     }
   },
 
-    fireEvent: function (type, event) {
+  fireEvent(type, event) {
     if (type == 'click') {
-            _.each(this._clickEvents, function (listener) {
+      _.each(this._clickEvents, (listener) => {
         listener(type, event);
       });
-        }
-        else {
+    } else {
       this._divContainer.trigger(type, event);
     }
   },
 
-    _getElementPosition: function (elem) {
+  _getElementPosition(elem) {
     // Retrieve current element position.
-        var elementPosition = elem.getPosition();
-        var x = elementPosition.x;
-        var y = elementPosition.y;
+    const elementPosition = elem.getPosition();
+    let { x } = elementPosition;
+    let { y } = elementPosition;
 
     // Add workspace offset.
-        x = x - this._padding.x;
-        y = y - this._padding.y;
+    x -= this._padding.x;
+    y -= this._padding.y;
 
     // Scale coordinate in order to be relative to the workspace. That's coord/size;
-        x = x / this._scale;
-        y = y / this._scale;
+    x /= this._scale;
+    y /= this._scale;
 
     // Remove decimal part..
-        return {x: x, y: y};
+    return { x, y };
   },
 
-    getWorkspaceIconPosition: function (e) {
+  getWorkspaceIconPosition(e) {
     // Retrieve current icon position.
-        var image = e.getImage();
-        var elementPosition = image.getPosition();
-        var imageSize = e.getSize();
+    const image = e.getImage();
+    const elementPosition = image.getPosition();
+    const imageSize = e.getSize();
 
     // Add group offset
-        var iconGroup = e.getGroup();
-        var group = iconGroup.getNativeElement();
-        var coordOrigin = group.getCoordOrigin();
-        var groupSize = group.getSize();
-        var coordSize = group.getCoordSize();
+    const iconGroup = e.getGroup();
+    const group = iconGroup.getNativeElement();
+    const coordOrigin = group.getCoordOrigin();
+    const groupSize = group.getSize();
+    const coordSize = group.getCoordSize();
 
-        var scale = {x: coordSize.width / parseInt(groupSize.width), y: coordSize.height / parseInt(groupSize.height)};
+    const scale = { x: coordSize.width / parseInt(groupSize.width), y: coordSize.height / parseInt(groupSize.height) };
 
-        var x = (elementPosition.x - coordOrigin.x - (parseInt(imageSize.width) / 2)) / scale.x;
-        var y = (elementPosition.y - coordOrigin.y - (parseInt(imageSize.height) / 2)) / scale.y;
+    let x = (elementPosition.x - coordOrigin.x - (parseInt(imageSize.width) / 2)) / scale.x;
+    let y = (elementPosition.y - coordOrigin.y - (parseInt(imageSize.height) / 2)) / scale.y;
 
     // Retrieve iconGroup Position
-        var groupPosition = iconGroup.getPosition();
-        x = x + groupPosition.x;
-        y = y + groupPosition.y;
+    const groupPosition = iconGroup.getPosition();
+    x += groupPosition.x;
+    y += groupPosition.y;
 
     // Retrieve topic Position
-        var topic = iconGroup.getTopic();
-        var topicPosition = this._getElementPosition(topic);
-        topicPosition.x = topicPosition.x - (parseInt(topic.getSize().width) / 2);
+    const topic = iconGroup.getTopic();
+    const topicPosition = this._getElementPosition(topic);
+    topicPosition.x -= (parseInt(topic.getSize().width) / 2);
 
     // Remove decimal part..
     return { x: x + topicPosition.x, y: y + topicPosition.y };
   },
 
-    getWorkspaceMousePosition: function (event) {
+  getWorkspaceMousePosition(event) {
     // Retrieve current mouse position.
-        var x = event.clientX;
-        var y = event.clientY;
+    let x = event.clientX;
+    let y = event.clientY;
 
     // FIXME: paulo: why? Subtract div position.
     /* var containerPosition = this.getContainer().position();
@@ -129,25 +126,25 @@ const ScreenManager = new Class({
          y = y - containerPosition.y; */
 
     // Scale coordinate in order to be relative to the workspace. That's coordSize/size;
-        x = x * this._scale;
-        y = y * this._scale;
+    x *= this._scale;
+    y *= this._scale;
 
     // Add workspace offset.
-        x = x + this._padding.x;
-        y = y + this._padding.y;
+    x += this._padding.x;
+    y += this._padding.y;
 
     // Remove decimal part..
     return new core.Point(x, y);
   },
 
-    getContainer: function () {
+  getContainer() {
     return this._divContainer;
   },
 
-    setOffset: function (x, y) {
+  setOffset(x, y) {
     this._padding.x = x;
     this._padding.y = y;
-    }
+  },
 });
 
 export default ScreenManager;

packages/mindplot/lib/components/ShrinkConnector.js

@@ -15,61 +15,58 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const web2D = require('@wismapping/web2d')
+const web2D = require('@wismapping/web2d');
+
 const web2d = web2D();
 
-const Topic = require('./Topic').default
+const Topic = require('./Topic').default;
 const ActionDispatcher = require('./ActionDispatcher').default;
 
 const ShirinkConnector = new Class({
-    initialize: function (topic) {
-
-        var ellipse = new web2D.Elipse(Topic.prototype.INNER_RECT_ATTRIBUTES);
+  initialize(topic) {
+    const ellipse = new web2D.Elipse(Topic.prototype.INNER_RECT_ATTRIBUTES);
     this._ellipse = ellipse;
     ellipse.setFill('rgb(62,118,179)');
 
     ellipse.setSize(Topic.CONNECTOR_WIDTH, Topic.CONNECTOR_WIDTH);
-        ellipse.addEvent('click', function (event) {
-            var model = topic.getModel();
-            var collapse = !model.areChildrenShrunken();
+    ellipse.addEvent('click', (event) => {
+      const model = topic.getModel();
+      const collapse = !model.areChildrenShrunken();
 
-            var topicId = topic.getId();
-            var actionDispatcher = ActionDispatcher.getInstance();
+      const topicId = topic.getId();
+      const actionDispatcher = ActionDispatcher.getInstance();
       actionDispatcher.shrinkBranch([topicId], collapse);
 
       event.stopPropagation();
-
     });
 
-        ellipse.addEvent('mousedown', function (event) {
+    ellipse.addEvent('mousedown', (event) => {
       // Avoid node creation ...
       event.stopPropagation();
     });
 
-        ellipse.addEvent('dblclick', function (event) {
+    ellipse.addEvent('dblclick', (event) => {
       // Avoid node creation ...
       event.stopPropagation();
     });
 
-        ellipse.addEvent('mouseover', function (event) {
-
+    ellipse.addEvent('mouseover', (event) => {
       ellipse.setFill('rgb(153, 0, 255)');
     });
-        var me = this;
-        ellipse.addEvent('mouseout', function (event) {
-            var color = topic.getBackgroundColor();
+    const me = this;
+    ellipse.addEvent('mouseout', (event) => {
+      const color = topic.getBackgroundColor();
       me.setFill(color);
     });
 
     ellipse.setCursor('default');
     this._fillColor = '#f7f7f7';
-        var model = topic.getModel();
+    const model = topic.getModel();
     this.changeRender(model.areChildrenShrunken());
-
   },
 
-    changeRender: function (isShrink) {
-        var elipse = this._ellipse;
+  changeRender(isShrink) {
+    const elipse = this._ellipse;
     if (isShrink) {
       elipse.setStroke('2', 'solid');
     } else {
@@ -77,38 +74,38 @@ const ShirinkConnector = new Class({
     }
   },
 
-    setVisibility: function (value) {
+  setVisibility(value) {
     this._ellipse.setVisibility(value);
   },
 
-    setOpacity: function (opacity) {
+  setOpacity(opacity) {
     this._ellipse.setOpacity(opacity);
   },
 
-    setFill: function (color) {
+  setFill(color) {
     this._fillColor = color;
     this._ellipse.setFill(color);
   },
 
-    setAttribute: function (name, value) {
+  setAttribute(name, value) {
     this._ellipse.setAttribute(name, value);
   },
 
-    addToWorkspace: function (group) {
+  addToWorkspace(group) {
     group.append(this._ellipse);
   },
 
-    setPosition: function (x, y) {
+  setPosition(x, y) {
     this._ellipse.setPosition(x, y);
   },
 
-    moveToBack: function () {
+  moveToBack() {
     this._ellipse.moveToBack();
   },
 
-    moveToFront: function () {
+  moveToFront() {
     this._ellipse.moveToFront();
-    }
+  },
 });
 
 export default ShirinkConnector;

packages/mindplot/lib/components/StandaloneActionDispatcher.js

@@ -36,42 +36,42 @@ const StandaloneActionDispatcher = new Class(
          * @constructs
          * @param {mindplot.CommandContext} commandContext
          */
-        initialize: function (commandContext) {
+    initialize(commandContext) {
       this.parent(commandContext);
       this._actionRunner = new DesignerActionRunner(commandContext, this);
     },
 
     /** */
-        addTopics: function (models, parentTopicsId) {
-            var command = new AddTopicCommand(models, parentTopicsId);
+    addTopics(models, parentTopicsId) {
+      const command = new AddTopicCommand(models, parentTopicsId);
       this.execute(command);
     },
 
     /** */
-        addRelationship: function (model) {
-            var command = new AddRelationshipCommand(model);
+    addRelationship(model) {
+      const command = new AddRelationshipCommand(model);
       this.execute(command);
     },
 
     /** */
-        deleteEntities: function (topicsIds, relIds) {
-            var command = new DeleteCommand(topicsIds, relIds);
+    deleteEntities(topicsIds, relIds) {
+      const command = new DeleteCommand(topicsIds, relIds);
       this.execute(command);
     },
 
     /** */
-        dragTopic: function (topicId, position, order, parentTopic) {
-            var command = new DragTopicCommand(topicId, position, order, parentTopic);
+    dragTopic(topicId, position, order, parentTopic) {
+      const command = new DragTopicCommand(topicId, position, order, parentTopic);
       this.execute(command);
     },
 
     /** */
-        moveTopic: function (topicId, position) {
+    moveTopic(topicId, position) {
       $assert($defined(topicId), 'topicsId can not be null');
       $assert($defined(position), 'position can not be null');
 
-            var commandFunc = function (topic, value) {
-                var result = topic.getPosition();
+      const commandFunc = function (topic, value) {
+        const result = topic.getPosition();
         EventBus.instance.fireEvent(EventBus.events.NodeMoveEvent, {
           node: topic.getModel(),
           position: value,
@@ -79,193 +79,193 @@ const StandaloneActionDispatcher = new Class(
         return result;
       };
 
-            var command = new GenericFunctionCommand(commandFunc, topicId, position);
+      const command = new GenericFunctionCommand(commandFunc, topicId, position);
       this.execute(command);
     },
 
     /** */
-        moveControlPoint: function (ctrlPoint, point) {
-            var command = new MoveControlPointCommand(ctrlPoint, point);
+    moveControlPoint(ctrlPoint, point) {
+      const command = new MoveControlPointCommand(ctrlPoint, point);
       this.execute(command);
     },
 
     /** */
-        changeFontStyleToTopic: function (topicsIds) {
-            var commandFunc = function (topic) {
-                var result = topic.getFontStyle();
-                var style = result == 'italic' ? 'normal' : 'italic';
+    changeFontStyleToTopic(topicsIds) {
+      const commandFunc = function (topic) {
+        const result = topic.getFontStyle();
+        const style = result == 'italic' ? 'normal' : 'italic';
         topic.setFontStyle(style, true);
         return result;
       };
-            var command = new GenericFunctionCommand(commandFunc, topicsIds);
+      const command = new GenericFunctionCommand(commandFunc, topicsIds);
       this.execute(command);
     },
 
     /** */
-        changeTextToTopic: function (topicsIds, text) {
+    changeTextToTopic(topicsIds, text) {
       $assert($defined(topicsIds), 'topicsIds can not be null');
 
-            var commandFunc = function (topic, value) {
-                var result = topic.getText();
+      const commandFunc = function (topic, value) {
+        const result = topic.getText();
         topic.setText(value);
         return result;
       };
       commandFunc.commandType = 'changeTextToTopic';
 
-            var command = new GenericFunctionCommand(commandFunc, topicsIds, text);
+      const command = new GenericFunctionCommand(commandFunc, topicsIds, text);
       this.execute(command);
     },
 
     /** */
-        changeFontFamilyToTopic: function (topicIds, fontFamily) {
+    changeFontFamilyToTopic(topicIds, fontFamily) {
       $assert(topicIds, 'topicIds can not be null');
       $assert(fontFamily, 'fontFamily can not be null');
 
-            var commandFunc = function (topic, fontFamily) {
-                var result = topic.getFontFamily();
+      const commandFunc = function (topic, fontFamily) {
+        const result = topic.getFontFamily();
         topic.setFontFamily(fontFamily, true);
 
         topic._adjustShapes();
         return result;
       };
 
-            var command = new GenericFunctionCommand(commandFunc, topicIds, fontFamily);
+      const command = new GenericFunctionCommand(commandFunc, topicIds, fontFamily);
       this.execute(command);
     },
 
     /** */
-        changeFontColorToTopic: function (topicsIds, color) {
+    changeFontColorToTopic(topicsIds, color) {
       $assert(topicsIds, 'topicIds can not be null');
       $assert(color, 'color can not be null');
 
-            var commandFunc = function (topic, color) {
-                var result = topic.getFontColor();
+      const commandFunc = function (topic, color) {
+        const result = topic.getFontColor();
         topic.setFontColor(color, true);
         return result;
       };
 
-            var command = new GenericFunctionCommand(commandFunc, topicsIds, color);
+      const command = new GenericFunctionCommand(commandFunc, topicsIds, color);
       command.discardDuplicated = 'fontColorCommandId';
       this.execute(command);
     },
 
     /** */
-        changeBackgroundColorToTopic: function (topicsIds, color) {
+    changeBackgroundColorToTopic(topicsIds, color) {
       $assert(topicsIds, 'topicIds can not be null');
       $assert(color, 'color can not be null');
 
-            var commandFunc = function (topic, color) {
-                var result = topic.getBackgroundColor();
+      const commandFunc = function (topic, color) {
+        const result = topic.getBackgroundColor();
         topic.setBackgroundColor(color);
         return result;
       };
 
-            var command = new GenericFunctionCommand(commandFunc, topicsIds, color);
+      const command = new GenericFunctionCommand(commandFunc, topicsIds, color);
       command.discardDuplicated = 'backColor';
       this.execute(command);
     },
 
     /** */
-        changeBorderColorToTopic: function (topicsIds, color) {
+    changeBorderColorToTopic(topicsIds, color) {
       $assert(topicsIds, 'topicIds can not be null');
       $assert(color, 'topicIds can not be null');
 
-            var commandFunc = function (topic, color) {
-                var result = topic.getBorderColor();
+      const commandFunc = function (topic, color) {
+        const result = topic.getBorderColor();
         topic.setBorderColor(color);
         return result;
       };
 
-            var command = new GenericFunctionCommand(commandFunc, topicsIds, color);
+      const command = new GenericFunctionCommand(commandFunc, topicsIds, color);
       command.discardDuplicated = 'borderColorCommandId';
       this.execute(command);
     },
 
     /** */
-        changeFontSizeToTopic: function (topicsIds, size) {
+    changeFontSizeToTopic(topicsIds, size) {
       $assert(topicsIds, 'topicIds can not be null');
       $assert(size, 'size can not be null');
 
-            var commandFunc = function (topic, size) {
-                var result = topic.getFontSize();
+      const commandFunc = function (topic, size) {
+        const result = topic.getFontSize();
         topic.setFontSize(size, true);
 
         topic._adjustShapes();
         return result;
       };
 
-            var command = new GenericFunctionCommand(commandFunc, topicsIds, size);
+      const command = new GenericFunctionCommand(commandFunc, topicsIds, size);
       this.execute(command);
     },
 
     /** */
-        changeShapeTypeToTopic: function (topicsIds, shapeType) {
+    changeShapeTypeToTopic(topicsIds, shapeType) {
       $assert(topicsIds, 'topicsIds can not be null');
       $assert(shapeType, 'shapeType can not be null');
 
-            var commandFunc = function (topic, shapeType) {
-                var result = topic.getShapeType();
+      const commandFunc = function (topic, shapeType) {
+        const result = topic.getShapeType();
         topic.setShapeType(shapeType, true);
         return result;
       };
 
-            var command = new GenericFunctionCommand(commandFunc, topicsIds, shapeType);
+      const command = new GenericFunctionCommand(commandFunc, topicsIds, shapeType);
       this.execute(command);
     },
 
     /** */
-        changeFontWeightToTopic: function (topicsIds) {
+    changeFontWeightToTopic(topicsIds) {
       $assert(topicsIds, 'topicsIds can not be null');
 
-            var commandFunc = function (topic) {
-                var result = topic.getFontWeight();
-                var weight = result == 'bold' ? 'normal' : 'bold';
+      const commandFunc = function (topic) {
+        const result = topic.getFontWeight();
+        const weight = result == 'bold' ? 'normal' : 'bold';
         topic.setFontWeight(weight, true);
 
         topic._adjustShapes();
         return result;
       };
 
-            var command = new GenericFunctionCommand(commandFunc, topicsIds);
+      const command = new GenericFunctionCommand(commandFunc, topicsIds);
       this.execute(command);
     },
 
     /** */
-        shrinkBranch: function (topicsIds, collapse) {
+    shrinkBranch(topicsIds, collapse) {
       $assert(topicsIds, 'topicsIds can not be null');
 
-            var commandFunc = function (topic, isShrink) {
+      const commandFunc = function (topic, isShrink) {
         topic.setChildrenShrunken(isShrink);
         return !isShrink;
       };
 
-            var command = new GenericFunctionCommand(commandFunc, topicsIds, collapse);
+      const command = new GenericFunctionCommand(commandFunc, topicsIds, collapse);
       this.execute(command, false);
     },
 
     /** */
-        addFeatureToTopic: function (topicId, featureType, attributes) {
-            var command = new AddFeatureToTopicCommand(topicId, featureType, attributes);
+    addFeatureToTopic(topicId, featureType, attributes) {
+      const command = new AddFeatureToTopicCommand(topicId, featureType, attributes);
       this.execute(command);
     },
 
     /** */
-        changeFeatureToTopic: function (topicId, featureId, attributes) {
-            var command = new ChangeFeatureToTopicCommand(topicId, featureId, attributes);
+    changeFeatureToTopic(topicId, featureId, attributes) {
+      const command = new ChangeFeatureToTopicCommand(topicId, featureId, attributes);
       this.execute(command);
     },
 
     /** */
-        removeFeatureFromTopic: function (topicId, featureId) {
-            var command = new RemoveFeatureFromTopicCommand(topicId, featureId);
+    removeFeatureFromTopic(topicId, featureId) {
+      const command = new RemoveFeatureFromTopicCommand(topicId, featureId);
       this.execute(command);
     },
 
     /** */
-        execute: function (command) {
+    execute(command) {
       this._actionRunner.execute(command);
     },
-    }
+  },
 );
 
 const CommandContext = new Class(
@@ -274,108 +274,102 @@ const CommandContext = new Class(
          * @constructs
          * @param {mindplot.Designer} designer
          */
-        initialize: function (designer) {
+    initialize(designer) {
       $assert(designer, 'designer can not be null');
       this._designer = designer;
     },
 
     /** */
-        findTopics: function (topicsIds) {
+    findTopics(topicsIds) {
       $assert($defined(topicsIds), 'topicsIds can not be null');
       if (!(topicsIds instanceof Array)) {
         topicsIds = [topicsIds];
       }
 
-            var designerTopics = this._designer.getModel().getTopics();
-            var result = designerTopics.filter(function (topic) {
-                return topicsIds.contains(topic.getId());
-            });
+      const designerTopics = this._designer.getModel().getTopics();
+      const result = designerTopics.filter((topic) => topicsIds.contains(topic.getId()));
 
       if (result.length != topicsIds.length) {
-                var ids = designerTopics.map(function (topic) {
-                    return topic.getId();
-                });
+        const ids = designerTopics.map((topic) => topic.getId());
         $assert(
           result.length == topicsIds.length,
-                    'Could not find topic. Result:' +
-                        result +
-                        ', Filter Criteria:' +
-                        topicsIds +
-                        ', Current Topics: [' +
-                        ids +
-                        ']'
+          `Could not find topic. Result:${
+            result
+          }, Filter Criteria:${
+            topicsIds
+          }, Current Topics: [${
+            ids
+          }]`,
         );
       }
       return result;
     },
 
     /** */
-        deleteTopic: function (topic) {
+    deleteTopic(topic) {
       this._designer.removeTopic(topic);
     },
 
     /** */
-        createTopic: function (model) {
+    createTopic(model) {
       $assert(model, 'model can not be null');
       return this._designer.nodeModelToNodeGraph(model);
     },
 
     /** */
-        createModel: function () {
-            var mindmap = this._designer.getMindmap();
+    createModel() {
+      const mindmap = this._designer.getMindmap();
       return mindmap.createNode(NodeModel.MAIN_TOPIC_TYPE);
     },
 
     /** */
-        addTopic: function (topic) {
-            var mindmap = this._designer.getMindmap();
+    addTopic(topic) {
+      const mindmap = this._designer.getMindmap();
       return mindmap.addBranch(topic.getModel());
     },
 
     /** */
-        connect: function (childTopic, parentTopic) {
+    connect(childTopic, parentTopic) {
       childTopic.connectTo(parentTopic, this._designer._workspace);
     },
 
     /** */
-        disconnect: function (topic) {
+    disconnect(topic) {
       topic.disconnect(this._designer._workspace);
     },
 
     /** */
-        addRelationship: function (model) {
+    addRelationship(model) {
       $assert(model, 'model cannot be null');
       return this._designer.addRelationship(model);
     },
 
     /** */
-        deleteRelationship: function (relationship) {
+    deleteRelationship(relationship) {
       this._designer.deleteRelationship(relationship);
     },
 
     /** */
-        findRelationships: function (relIds) {
+    findRelationships(relIds) {
       $assert($defined(relIds), 'relId can not be null');
       if (!(relIds instanceof Array)) {
         relIds = [relIds];
       }
 
-            var designerRel = this._designer.getModel().getRelationships();
-            return designerRel.filter(function (rel) {
-                return relIds.contains(rel.getId());
-            });
+      const designerRel = this._designer.getModel().getRelationships();
+      return designerRel.filter((rel) => relIds.contains(rel.getId()));
     },
 
     /** */
-        moveTopic: function (topic, position) {
+    moveTopic(topic, position) {
       $assert(topic, 'topic cannot be null');
       $assert(position, 'position cannot be null');
       EventBus.instance.fireEvent(EventBus.events.NodeMoveEvent, {
         node: topic.getModel(),
-                position: position,
+        position,
       });
     },
-    }
+  },
 );
 
 export { StandaloneActionDispatcher, CommandContext };

packages/mindplot/lib/components/TextEditor.js

@@ -12,70 +12,66 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const web2D = require('@wismapping/web2d')
-const web2d = web2D()
+const web2D = require('@wismapping/web2d');
 
-const ActionDispatcher = require('./ActionDispatcher').default 
+const web2d = web2D();
+
+const ActionDispatcher = require('./ActionDispatcher').default;
 
 // FIXME: Not used!
 const TextEditor = new Class({
-    initialize: function (topic) {
+  initialize(topic) {
     this._topic = topic;
   },
 
-    _buildEditor: function () {
-
+  _buildEditor() {
     this._size = { width: 500, height: 100 };
-        var result = new Element('div');
+    const result = new Element('div');
     result.setStyles({
-                position: "absolute",
-                display: "none",
-                zIndex: "8",
-                width: "500px",
-                height: "100px"
-            }
-        );
+      position: 'absolute',
+      display: 'none',
+      zIndex: '8',
+      width: '500px',
+      height: '100px',
+    });
 
-
-        var inputContainer = new Element('div');
+    const inputContainer = new Element('div');
     inputContainer.setStyles({
-            border: "none",
-            overflow: "auto"
+      border: 'none',
+      overflow: 'auto',
     });
     inputContainer.inject(result);
 
-        var inputText = new Element('input',
+    const inputText = new Element('input',
       {
-                type: "text",
+        type: 'text',
         tabindex: '-1',
-                value: ""
-            }
-        );
+        value: '',
+      });
     inputText.setStyles({
-            border: "none",
-            background: "transparent"
+      border: 'none',
+      background: 'transparent',
     });
     inputText.inject(inputContainer);
 
-        var spanContainer = new Element('div');
-        spanContainer.setStyle('visibility', "hidden");
+    const spanContainer = new Element('div');
+    spanContainer.setStyle('visibility', 'hidden');
     spanContainer.inject(result);
 
-        var spanElem = new Element('span', {tabindex: "-1"});
-        spanElem.setStyle('white-space', "nowrap");
+    const spanElem = new Element('span', { tabindex: '-1' });
+    spanElem.setStyle('white-space', 'nowrap');
     spanElem.setStyle('nowrap', 'nowrap');
     spanElem.inject(spanContainer);
 
-
     return result;
   },
 
-    _registerEvents: function (divElem) {
-        var inputElem = this._getTextareaElem();
-        var spanElem = this._getSpanElem();
-        var me = this;
+  _registerEvents(divElem) {
+    const inputElem = this._getTextareaElem();
+    const spanElem = this._getSpanElem();
+    const me = this;
 
-        divElem.addEvent('keydown', function (event) {
+    divElem.addEvent('keydown', (event) => {
       switch (event.key) {
         case 'esc':
           me.close(false);
@@ -88,7 +84,7 @@ const TextEditor = new Class({
           var size = inputElem.value.length + 1;
           inputElem.size = size;
           if (spanElem.offsetWidth > (parseInt(divElem.style.width) - 100)) {
-                        divElem.style.width = (spanElem.offsetWidth + 100) + "px";
+            divElem.style.width = `${spanElem.offsetWidth + 100}px`;
           }
           break;
       }
@@ -96,37 +92,35 @@ const TextEditor = new Class({
     });
 
     // If the user clicks on the input, all event must be ignored ...
-        divElem.addEvent('click', function (event) {
+    divElem.addEvent('click', (event) => {
       event.stopPropagation();
     });
-        divElem.addEvent('dblclick', function (event) {
+    divElem.addEvent('dblclick', (event) => {
       event.stopPropagation();
     });
-        divElem.addEvent('mousedown', function (event) {
+    divElem.addEvent('mousedown', (event) => {
       event.stopPropagation();
     });
   },
 
-    isVisible: function () {
+  isVisible() {
     return $defined(this._containerElem) && this._containerElem.getStyle('display') == 'block';
   },
 
-    _updateModel: function () {
-
+  _updateModel() {
     if (this._topic.getText() != this._getText()) {
-            var text = this._getText();
-            var topicId = this._topic.getId();
+      const text = this._getText();
+      const topicId = this._topic.getId();
 
-            var actionDispatcher = ActionDispatcher.getInstance();
+      const actionDispatcher = ActionDispatcher.getInstance();
       actionDispatcher.changeTextToTopic([topicId], text);
     }
   },
 
-    show: function (text) {
-
+  show(text) {
     if (!this.isVisible()) {
       // Create editor ui
-            var editorElem = this._buildEditor();
+      const editorElem = this._buildEditor();
       editorElem.inject($(document.body)[0]);
 
       this._containerElem = editorElem;
@@ -135,62 +129,60 @@ const TextEditor = new Class({
     }
   },
 
-    _showEditor: function (defaultText) {
-
-        var topic = this._topic;
+  _showEditor(defaultText) {
+    const topic = this._topic;
 
     // Hide topic text ...
     topic.getTextShape().setVisibility(false);
 
     // Set Editor Style
-        var nodeText = topic.getTextShape();
-        var font = nodeText.getFont();
+    const nodeText = topic.getTextShape();
+    const font = nodeText.getFont();
     font.size = nodeText.getHtmlFontSize();
     font.color = nodeText.getColor();
     this._setStyle(font);
 
     // Set editor's initial text
-        var text = $defined(defaultText) ? defaultText : topic.getText();
+    const text = $defined(defaultText) ? defaultText : topic.getText();
     this._setText(text);
 
-        var me = this;
+    const me = this;
     // Set editor's initial size
-        var displayFunc = function () {
+    const displayFunc = function () {
       // Position the editor and set the size...
-            var textShape = me._topic.getTextShape();
+      const textShape = me._topic.getTextShape();
 
       me._containerElem.css('display', 'block');
 
       me._containerElem.offset(textShape.getNativePosition());
       // Set size ...
-            var elemSize = topic.getSize();
+      const elemSize = topic.getSize();
       me._setEditorSize(elemSize.width, elemSize.height);
 
-            var textareaElem = me._getTextareaElem();
+      const textareaElem = me._getTextareaElem();
       textareaElem.focus();
       me._positionCursor(textareaElem, !$defined(defaultText));
-
     };
 
     displayFunc.delay(10);
   },
 
-    _setStyle: function (fontStyle) {
-        var inputField = this._getTextareaElem();
-        var spanField = this._getSpanElem();
+  _setStyle(fontStyle) {
+    const inputField = this._getTextareaElem();
+    const spanField = this._getSpanElem();
     if (!$defined(fontStyle.font)) {
-            fontStyle.font = "Arial";
+      fontStyle.font = 'Arial';
     }
     if (!$defined(fontStyle.style)) {
-            fontStyle.style = "normal";
+      fontStyle.style = 'normal';
     }
     if (!$defined(fontStyle.weight)) {
-            fontStyle.weight = "normal";
+      fontStyle.weight = 'normal';
     }
     if (!$defined(fontStyle.size)) {
       fontStyle.size = 12;
     }
-        inputField.style.fontSize = fontStyle.size + "px";
+    inputField.style.fontSize = `${fontStyle.size}px`;
     inputField.style.fontFamily = fontStyle.font;
     inputField.style.fontStyle = fontStyle.style;
     inputField.style.fontWeight = fontStyle.weight;
@@ -198,59 +190,57 @@ const TextEditor = new Class({
     spanField.style.fontFamily = fontStyle.font;
     spanField.style.fontStyle = fontStyle.style;
     spanField.style.fontWeight = fontStyle.weight;
-        spanField.style.fontSize = fontStyle.size + "px";
+    spanField.style.fontSize = `${fontStyle.size}px`;
   },
 
-    _setText: function (text) {
-        var inputField = this._getTextareaElem();
+  _setText(text) {
+    const inputField = this._getTextareaElem();
     inputField.size = text.length + 1;
-        this._containerElem.style.width = (inputField.size * parseInt(inputField.style.fontSize) + 100) + "px";
-        var spanField = this._getSpanElem();
+    this._containerElem.style.width = `${inputField.size * parseInt(inputField.style.fontSize) + 100}px`;
+    const spanField = this._getSpanElem();
     spanField.innerHTML = text;
     inputField.value = text;
   },
 
-    _getText: function () {
+  _getText() {
     return this._getTextareaElem().value;
   },
 
-    _getTextareaElem: function () {
+  _getTextareaElem() {
     return this._containerElem.getElement('input');
   },
 
-    _getSpanElem: function () {
+  _getSpanElem() {
     return this._containerElem.getElement('span');
   },
 
-    _setEditorSize: function (width, height) {
-        var textShape = this._topic.getTextShape();
-        var scale = web2d.utils.TransformUtil.workoutScale(textShape._peer);
+  _setEditorSize(width, height) {
+    const textShape = this._topic.getTextShape();
+    const scale = web2d.utils.TransformUtil.workoutScale(textShape._peer);
     this._size = { width: width * scale.width, height: height * scale.height };
-        this._containerElem.style.width = this._size.width * 2 + "px";
-        this._containerElem.style.height = this._size.height + "px";
+    this._containerElem.style.width = `${this._size.width * 2}px`;
+    this._containerElem.style.height = `${this._size.height}px`;
   },
 
-    _positionCursor: function (inputElem, selectText) {
+  _positionCursor(inputElem, selectText) {
     // Select text if it's required ...
     if (inputElem.createTextRange) // ie
     {
-            var range = inputElem.createTextRange();
-            var pos = inputElem.value.length;
+      const range = inputElem.createTextRange();
+      const pos = inputElem.value.length;
       if (!selectText) {
         range.select();
-                range.move("character", pos);
-            }
-            else {
-                range.move("character", pos);
+        range.move('character', pos);
+      } else {
+        range.move('character', pos);
         range.select();
       }
-        }
-        else if (!selectText) {
+    } else if (!selectText) {
       inputElem.setSelectionRange(0, inputElem.value.length);
     }
   },
 
-    close: function (update) {
+  close(update) {
     if (this.isVisible()) {
       // Update changes ...
       if (!$defined(update) || update) {
@@ -264,7 +254,7 @@ const TextEditor = new Class({
       this._containerElem.dispose();
       this._containerElem = null;
     }
-    }
+  },
 });
 
 export default TextEditor;

packages/mindplot/lib/components/TextEditorFactory.js

@@ -20,7 +20,7 @@ const TextEditor = require('./TextEditor').default;
 const TextEditorFactory = {};
 
 TextEditorFactory.getTextEditorFromName = function (name) {
-    var editorClass = null;
+  let editorClass = null;
   if (name == 'RichTextEditor') {
     editorClass = RichTextEditor;
   } else {

packages/mindplot/lib/components/TopicEventDispatcher.js

@@ -24,33 +24,33 @@ const TopicEventDispatcher = new Class({
   Static: {
     _instance: null,
 
-        configure: function (readOnly) {
+    configure(readOnly) {
       this._instance = new TopicEventDispatcher(readOnly);
     },
 
-        getInstance: function () {
+    getInstance() {
       return this._instance;
     },
   },
 
-    initialize: function (readOnly) {
+  initialize(readOnly) {
     this._readOnly = readOnly;
     this._activeEditor = null;
     this._multilineEditor = new MultilineTextEditor();
   },
 
-    close: function (update) {
+  close(update) {
     if (this.isVisible()) {
       this._activeEditor.close(update);
       this._activeEditor = null;
     }
   },
 
-    show: function (topic, options) {
+  show(topic, options) {
     this.process(TopicEvent.EDIT, topic, options);
   },
 
-    process: function (eventType, topic, options) {
+  process(eventType, topic, options) {
     $assert(eventType, 'eventType can not be null');
 
     // Close all previous open editor ....
@@ -59,20 +59,20 @@ const TopicEventDispatcher = new Class({
     }
 
     // Open the new editor ...
-        var model = topic.getModel();
+    const model = topic.getModel();
     if (
-            model.getShapeType() != TopicShape.IMAGE &&
-            !this._readOnly &&
-            eventType == TopicEvent.EDIT
+      model.getShapeType() != TopicShape.IMAGE
+            && !this._readOnly
+            && eventType == TopicEvent.EDIT
     ) {
       this._multilineEditor.show(topic, options ? options.text : null);
       this._activeEditor = this._multilineEditor;
     } else {
-            this.fireEvent(eventType, { model: model, readOnly: this._readOnly });
+      this.fireEvent(eventType, { model, readOnly: this._readOnly });
     }
   },
 
-    isVisible: function () {
+  isVisible() {
     return this._activeEditor != null && this._activeEditor.isVisible();
   },
 });

packages/mindplot/lib/components/TopicFeature.js

@@ -29,31 +29,29 @@ const TopicFeature = {
   Icon: {
     id: IconModel.FEATURE_TYPE,
     model: IconModel,
-        icon: ImageIcon
+    icon: ImageIcon,
   },
 
   /** the link object */
   Link: {
     id: LinkModel.FEATURE_TYPE,
     model: LinkModel,
-        icon: LinkIcon
+    icon: LinkIcon,
   },
 
   /** the note object */
   Note: {
     id: NoteModel.FEATURE_TYPE,
     model: NoteModel,
-        icon: NoteIcon
+    icon: NoteIcon,
   },
 
   /**
      * @param id the feature metadata id
      * @return {Boolean} returns true if the given id is contained in the metadata array
      */
-    isSupported: function (id) {
-        return TopicFeature._featuresMetadataById.some(function (elem) {
-            return elem.id == id;
-        });
+  isSupported(id) {
+    return TopicFeature._featuresMetadataById.some((elem) => elem.id == id);
   },
 
   /**
@@ -64,13 +62,11 @@ const TopicFeature = {
      * @return {mindplot.model.FeatureModel} a new instance of the feature model subclass matching
      * the topic feature
      */
-    createModel: function (type, attributes) {
+  createModel(type, attributes) {
     $assert(type, 'type can not be null');
     $assert(attributes, 'attributes can not be null');
 
-        var model = TopicFeature._featuresMetadataById.filter(function (elem) {
-            return elem.id == type;
-        })[0].model;
+    const { model } = TopicFeature._featuresMetadataById.filter((elem) => elem.id == type)[0];
     return new model(attributes);
   },
 
@@ -82,15 +78,13 @@ const TopicFeature = {
      * @throws will throw an error if model is null or undefined
      * @return {mindplot.Icon} a new instance of the icon subclass matching the topic feature
      */
-    createIcon: function (topic, model, readOnly) {
+  createIcon(topic, model, readOnly) {
     $assert(topic, 'topic can not be null');
     $assert(model, 'model can not be null');
 
-        var icon = TopicFeature._featuresMetadataById.filter(function (elem) {
-            return elem.id == model.getType();
-        })[0].icon;
+    const { icon } = TopicFeature._featuresMetadataById.filter((elem) => elem.id == model.getType())[0];
     return new icon(topic, model, readOnly);
-    }
+  },
 };
 
 TopicFeature._featuresMetadataById = [TopicFeature.Icon, TopicFeature.Link, TopicFeature.Note];

packages/mindplot/lib/components/TopicStyle.js

@@ -19,14 +19,14 @@ const { TopicShape } = require('./model/INodeModel');
 
 const TopicStyle = new Class({
   Static: {
-        _getStyles: function (topic) {
+    _getStyles(topic) {
       $assert(topic, 'topic can not be null');
 
-            var result;
+      let result;
       if (topic.isCentralTopic()) {
         result = TopicStyle.STYLES.CENTRAL_TOPIC;
       } else {
-                var targetTopic = topic.getOutgoingConnectedTopic();
+        const targetTopic = topic.getOutgoingConnectedTopic();
         if ($defined(targetTopic)) {
           if (targetTopic.isCentralTopic()) {
             result = TopicStyle.STYLES.MAIN_TOPIC;
@@ -40,28 +40,28 @@ const TopicStyle = new Class({
       return result;
     },
 
-        defaultText: function (topic) {
-            var msgKey = this._getStyles(topic).msgKey;
+    defaultText(topic) {
+      const { msgKey } = this._getStyles(topic);
       return $msg(msgKey);
     },
 
-        defaultFontStyle: function (topic) {
+    defaultFontStyle(topic) {
       return this._getStyles(topic).fontStyle;
     },
 
-        defaultBackgroundColor: function (topic) {
+    defaultBackgroundColor(topic) {
       return this._getStyles(topic).backgroundColor;
     },
 
-        defaultBorderColor: function (topic) {
+    defaultBorderColor(topic) {
       return this._getStyles(topic).borderColor;
     },
 
-        getInnerPadding: function (topic) {
+    getInnerPadding(topic) {
       return this._getStyles(topic).innerPadding;
     },
 
-        defaultShapeType: function (topic) {
+    defaultShapeType(topic) {
       return this._getStyles(topic).shapeType;
     },
   },

packages/mindplot/lib/components/Workspace.js

@@ -15,11 +15,12 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const web2D = require('@wismapping/web2d')
+const web2D = require('@wismapping/web2d');
+
 const web2d = web2D();
 
 const Workspace = new Class({
-    initialize: function (screenManager, zoom) {
+  initialize(screenManager, zoom) {
     // Create a suitable container ...
     $assert(screenManager, 'Div container can not be null');
     $assert(zoom, 'zoom container can not be null');
@@ -27,12 +28,12 @@ const Workspace = new Class({
     this._zoom = zoom;
     this._screenManager = screenManager;
 
-        var divContainer = screenManager.getContainer();
+    const divContainer = screenManager.getContainer();
     this._screenWidth = parseInt(divContainer.css('width'));
     this._screenHeight = parseInt(divContainer.css('height'));
 
     // Initialize web2d workspace.
-        var workspace = this._createWorkspace();
+    const workspace = this._createWorkspace();
     this._workspace = workspace;
 
     // Append to the workspace...
@@ -44,26 +45,26 @@ const Workspace = new Class({
     this._eventsEnabled = true;
   },
 
-    _createWorkspace: function () {
+  _createWorkspace() {
     // Initialize workspace ...
-        var coordOriginX = -(this._screenWidth / 2);
-        var coordOriginY = -(this._screenHeight / 2);
+    const coordOriginX = -(this._screenWidth / 2);
+    const coordOriginY = -(this._screenHeight / 2);
 
-        var workspaceProfile = {
-            width: this._screenWidth + "px",
-            height: this._screenHeight + "px",
+    const workspaceProfile = {
+      width: `${this._screenWidth}px`,
+      height: `${this._screenHeight}px`,
       coordSizeWidth: this._screenWidth,
       coordSizeHeight: this._screenHeight,
-            coordOriginX: coordOriginX,
-            coordOriginY: coordOriginY,
+      coordOriginX,
+      coordOriginY,
       fillColor: 'transparent',
-            strokeWidth: 0
+      strokeWidth: 0,
     };
     web2d.Toolkit.init();
     return new web2d.Workspace(workspaceProfile);
   },
 
-    append: function (shape) {
+  append(shape) {
     if ($defined(shape.addToWorkspace)) {
       shape.addToWorkspace(this);
     } else {
@@ -71,7 +72,7 @@ const Workspace = new Class({
     }
   },
 
-    removeChild: function (shape) {
+  removeChild(shape) {
     // Element is a node, not a web2d element?
     if ($defined(shape.removeFromWorkspace)) {
       shape.removeFromWorkspace(this);
@@ -80,27 +81,27 @@ const Workspace = new Class({
     }
   },
 
-    addEvent: function (type, listener) {
+  addEvent(type, listener) {
     this._workspace.addEvent(type, listener);
   },
 
-    removeEvent: function (type, listener) {
+  removeEvent(type, listener) {
     $assert(type, 'type can not be null');
     $assert(listener, 'listener can not be null');
     this._workspace.removeEvent(type, listener);
   },
 
-    getSize: function () {
+  getSize() {
     return this._workspace.getCoordSize();
   },
 
-    setZoom: function (zoom, center) {
+  setZoom(zoom, center) {
     this._zoom = zoom;
-        var workspace = this._workspace;
+    const workspace = this._workspace;
 
     // Update coord scale...
-        var coordWidth = zoom * this._screenWidth;
-        var coordHeight = zoom * this._screenHeight;
+    const coordWidth = zoom * this._screenWidth;
+    const coordHeight = zoom * this._screenHeight;
     workspace.setCoordSize(coordWidth, coordHeight);
 
     // View port coords ...
@@ -110,8 +111,8 @@ const Workspace = new Class({
     }
 
     // Center topic....
-        var coordOriginX;
-        var coordOriginY;
+    let coordOriginX;
+    let coordOriginY;
 
     if (center) {
       if (this._viewPort) {
@@ -122,7 +123,7 @@ const Workspace = new Class({
         coordOriginY = -(coordHeight / 2);
       }
     } else {
-            var coordOrigin = workspace.getCoordOrigin();
+      const coordOrigin = workspace.getCoordOrigin();
       coordOriginX = coordOrigin.x;
       coordOriginY = coordOrigin.y;
     }
@@ -137,66 +138,62 @@ const Workspace = new Class({
     this._screenManager.fireEvent('update');
   },
 
-    getScreenManager: function () {
+  getScreenManager() {
     return this._screenManager;
   },
 
-    enableWorkspaceEvents: function (value) {
+  enableWorkspaceEvents(value) {
     this._eventsEnabled = value;
   },
 
-    isWorkspaceEventsEnabled: function () {
+  isWorkspaceEventsEnabled() {
     return this._eventsEnabled;
   },
 
-    dumpNativeChart: function () {
+  dumpNativeChart() {
     return this._workspace.dumpNativeChart();
   },
 
-    _registerDragEvents: function () {
-        var workspace = this._workspace;
-        var screenManager = this._screenManager;
-        var mWorkspace = this;
-        var mouseDownListener = function (event) {
+  _registerDragEvents() {
+    const workspace = this._workspace;
+    const screenManager = this._screenManager;
+    const mWorkspace = this;
+    const mouseDownListener = function (event) {
       if (!$defined(workspace._mouseMoveListener)) {
         if (mWorkspace.isWorkspaceEventsEnabled()) {
           mWorkspace.enableWorkspaceEvents(false);
 
-                    var mouseDownPosition = screenManager.getWorkspaceMousePosition(event);
-                    var originalCoordOrigin = workspace.getCoordOrigin();
+          const mouseDownPosition = screenManager.getWorkspaceMousePosition(event);
+          const originalCoordOrigin = workspace.getCoordOrigin();
 
-                    var wasDragged = false;
+          let wasDragged = false;
           workspace._mouseMoveListener = function (event) {
+            const currentMousePosition = screenManager.getWorkspaceMousePosition(event);
 
-                        var currentMousePosition = screenManager.getWorkspaceMousePosition(event);
+            const offsetX = currentMousePosition.x - mouseDownPosition.x;
+            const coordOriginX = -offsetX + originalCoordOrigin.x;
 
-                        var offsetX = currentMousePosition.x - mouseDownPosition.x;
-                        var coordOriginX = -offsetX + originalCoordOrigin.x;
-
-                        var offsetY = currentMousePosition.y - mouseDownPosition.y;
-                        var coordOriginY = -offsetY + originalCoordOrigin.y;
+            const offsetY = currentMousePosition.y - mouseDownPosition.y;
+            const coordOriginY = -offsetY + originalCoordOrigin.y;
 
             workspace.setCoordOrigin(coordOriginX, coordOriginY);
 
             // Change cursor.
             if (Browser.firefox) {
-                            window.document.body.style.cursor = "-moz-grabbing";
+              window.document.body.style.cursor = '-moz-grabbing';
             } else {
-                            window.document.body.style.cursor = "move";
+              window.document.body.style.cursor = 'move';
             }
             event.preventDefault();
 
             // Fire drag event ...
             screenManager.fireEvent('update');
             wasDragged = true;
-
-
           };
           screenManager.addEvent('mousemove', workspace._mouseMoveListener);
 
           // Register mouse up listeners ...
           workspace._mouseUpListener = function (event) {
-
             screenManager.removeEvent('mousemove', workspace._mouseMoveListener);
             screenManager.removeEvent('mouseup', workspace._mouseUpListener);
             workspace._mouseUpListener = null;
@@ -204,7 +201,7 @@ const Workspace = new Class({
             window.document.body.style.cursor = 'default';
 
             // Update screen manager offset.
-                        var coordOrigin = workspace.getCoordOrigin();
+            const coordOrigin = workspace.getCoordOrigin();
             screenManager.setOffset(coordOrigin.x, coordOrigin.y);
             mWorkspace.enableWorkspaceEvents(true);
 
@@ -221,9 +218,9 @@ const Workspace = new Class({
     screenManager.addEvent('mousedown', mouseDownListener);
   },
 
-    setViewPort: function (size) {
+  setViewPort(size) {
     this._viewPort = size;
-    }
+  },
 });
 
 export default Workspace;

packages/mindplot/lib/components/commands/AddFeatureToTopicCommand.js

@@ -29,8 +29,7 @@ const AddFeatureToTopicCommand = new Class(/** @lends AddFeatureToTopicCommand *
      * @extends mindplot.Command
      * @see mindplot.model.FeatureModel and subclasses
      */
-    initialize:function (topicId, featureType, attributes) {
-
+  initialize(topicId, featureType, attributes) {
     $assert($defined(topicId), 'topicId can not be null');
     $assert(featureType, 'featureType can not be null');
     $assert(attributes, 'attributes can not be null');
@@ -45,12 +44,12 @@ const AddFeatureToTopicCommand = new Class(/** @lends AddFeatureToTopicCommand *
   /**
      * Overrides abstract parent method
      */
-    execute:function (commandContext) {
-        var topic = commandContext.findTopics(this._topicId)[0];
+  execute(commandContext) {
+    const topic = commandContext.findTopics(this._topicId)[0];
 
     // Feature must be created only one time.
     if (!this._featureModel) {
-            var model = topic.getModel();
+      const model = topic.getModel();
       this._featureModel = model.createFeature(this._featureType, this._attributes);
     }
     topic.addFeature(this._featureModel);
@@ -60,10 +59,10 @@ const AddFeatureToTopicCommand = new Class(/** @lends AddFeatureToTopicCommand *
      * Overrides abstract parent method
      * @see {@link mindplot.Command.undoExecute}
      */
-    undoExecute:function (commandContext) {
-        var topic = commandContext.findTopics(this._topicId)[0];
+  undoExecute(commandContext) {
+    const topic = commandContext.findTopics(this._topicId)[0];
     topic.removeFeature(this._featureModel);
-    }
+  },
 });
 
-export default AddFeatureToTopicCommand
+export default AddFeatureToTopicCommand;

packages/mindplot/lib/components/commands/AddRelationshipCommand.js

@@ -15,7 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const Command = require('../Command').default
+const Command = require('../Command').default;
 
 const AddRelationshipCommand = new Class(/** @lends AddRelationshipCommand */{
   Extends: Command,
@@ -25,7 +25,7 @@ const AddRelationshipCommand = new Class(/** @lends AddRelationshipCommand */{
      * @param {XMLDOM} model
      * @extends mindplot.Command
      */
-    initialize:function (model) {
+  initialize(model) {
     $assert(model, 'Relationship model can not be null');
 
     this.parent();
@@ -35,8 +35,8 @@ const AddRelationshipCommand = new Class(/** @lends AddRelationshipCommand */{
   /**
      * Overrides abstract parent method
      */
-    execute:function (commandContext) {
-        var relationship = commandContext.addRelationship(this._model);
+  execute(commandContext) {
+    const relationship = commandContext.addRelationship(this._model);
     relationship.setOnFocus(true);
   },
 
@@ -44,10 +44,10 @@ const AddRelationshipCommand = new Class(/** @lends AddRelationshipCommand */{
      * Overrides abstract parent method
      * @see {@link mindplot.Command.undoExecute}
      */
-    undoExecute:function (commandContext) {
-        var rel = commandContext.findRelationships(this._model.getId());
+  undoExecute(commandContext) {
+    const rel = commandContext.findRelationships(this._model.getId());
     commandContext.deleteRelationship(rel[0]);
-    }
+  },
 });
 
 export default AddRelationshipCommand;

packages/mindplot/lib/components/commands/AddTopicCommand.js

@@ -29,11 +29,11 @@ const AddTopicCommand = new Class(
          * when attaching a dragged node or a node/branch from clipboard
          * @extends mindplot.Command
          */
-        initialize: function (models, parentTopicsId) {
+    initialize(models, parentTopicsId) {
       $assert(models, 'models can not be null');
       $assert(
         parentTopicsId == null || parentTopicsId.length == models.length,
-                'parents and models must have the same size'
+        'parents and models must have the same size',
       );
 
       this.parent();
@@ -44,17 +44,17 @@ const AddTopicCommand = new Class(
     /**
          * Overrides abstract parent method
          */
-        execute: function (commandContext) {
-            var me = this;
-            _.each(this._models, function (model, index) {
+    execute(commandContext) {
+      const me = this;
+      _.each(this._models, (model, index) => {
         // Add a new topic ...
-                var topic = commandContext.createTopic(model);
+        const topic = commandContext.createTopic(model);
 
         // Connect to topic ...
         if (me._parentsIds) {
-                    var parentId = me._parentsIds[index];
+          const parentId = me._parentsIds[index];
           if ($defined(parentId)) {
-                        var parentTopic = commandContext.findTopics(parentId)[0];
+            const parentTopic = commandContext.findTopics(parentId)[0];
             commandContext.connect(topic, parentTopic);
           }
         } else {
@@ -62,7 +62,7 @@ const AddTopicCommand = new Class(
         }
 
         // Select just created node ...
-                var designer = commandContext._designer;
+        const designer = commandContext._designer;
         designer.onObjectFocusEvent(topic);
         topic.setOnFocus(true);
 
@@ -75,23 +75,23 @@ const AddTopicCommand = new Class(
          * Overrides abstract parent method
          * @see {@link mindplot.Command.undoExecute}
          */
-        undoExecute: function (commandContext) {
+    undoExecute(commandContext) {
       // Delete disconnected the nodes. Create a copy of the topics ...
-            var clonedModel = [];
-            _.each(this._models, function (model) {
+      const clonedModel = [];
+      _.each(this._models, (model) => {
         clonedModel.push(model.clone());
       });
 
       // Finally, remove the nodes ...
-            _.each(this._models, function (model) {
-                var topicId = model.getId();
-                var topic = commandContext.findTopics(topicId)[0];
+      _.each(this._models, (model) => {
+        const topicId = model.getId();
+        const topic = commandContext.findTopics(topicId)[0];
         commandContext.deleteTopic(topic);
       });
 
       this._models = clonedModel;
     },
-    }
+  },
 );
 
 export default AddTopicCommand;

packages/mindplot/lib/components/commands/ChangeFeatureToTopicCommand.js

@@ -15,7 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const Command = require('../Command').default
+const Command = require('../Command').default;
 
 const ChangeFeatureToTopicCommand = new Class(/** @lends ChangeFeatureToTopicCommand */{
   Extends: Command,
@@ -29,7 +29,7 @@ const ChangeFeatureToTopicCommand = new Class(/** @lends ChangeFeatureToTopicCom
      * @throws will throw an error if featureId is null or undefined
      * @throws will throw an error if attributes is null or undefined
      */
-    initialize: function(topicId, featureId, attributes) {
+  initialize(topicId, featureId, attributes) {
     $assert($defined(topicId), 'topicId can not be null');
     $assert($defined(featureId), 'featureId can not be null');
     $assert($defined(attributes), 'attributes can not be null');
@@ -43,11 +43,11 @@ const ChangeFeatureToTopicCommand = new Class(/** @lends ChangeFeatureToTopicCom
   /**
      * Overrides abstract parent method
      */
-    execute: function(commandContext) {
-        var topic = commandContext.findTopics(this._topicId)[0];
-        var feature = topic.findFeatureById(this._featureId);
+  execute(commandContext) {
+    const topic = commandContext.findTopics(this._topicId)[0];
+    const feature = topic.findFeatureById(this._featureId);
 
-        var oldAttributes = feature.getAttributes();
+    const oldAttributes = feature.getAttributes();
     feature.setAttributes(this._attributes);
     this._attributes = oldAttributes;
   },
@@ -56,9 +56,9 @@ const ChangeFeatureToTopicCommand = new Class(/** @lends ChangeFeatureToTopicCom
      * Overrides abstract parent method
      * @see {@link mindplot.Command.undoExecute}
      */
-    undoExecute: function(commandContext) {
+  undoExecute(commandContext) {
     this.execute(commandContext);
-    }
+  },
 });
 
 export default ChangeFeatureToTopicCommand;

packages/mindplot/lib/components/commands/DeleteCommand.js

@@ -26,7 +26,7 @@ const DeleteCommand = new Class(/** @lends mindplot.commands.DeleteCommand */{
      * @param {Array<String>} relIds ids of the relationships connected to the topics
      * @extends mindplot.Command
      */
-    initialize:function (topicIds, relIds) {
+  initialize(topicIds, relIds) {
     $assert($defined(relIds), 'topicIds can not be null');
 
     this.parent();
@@ -40,33 +40,30 @@ const DeleteCommand = new Class(/** @lends mindplot.commands.DeleteCommand */{
   /**
      * Overrides abstract parent method
      */
-    execute:function (commandContext) {
-
+  execute(commandContext) {
     // If a parent has been selected for deletion, the children must be excluded from the delete ...
-        var topics = this._filterChildren(this._topicIds, commandContext);
+    const topics = this._filterChildren(this._topicIds, commandContext);
 
     if (topics.length > 0) {
       _.each(topics, function (topic) {
         // In case that it's editing text node, force close without update ...
         topic.closeEditors();
 
-                var model = topic.getModel();
+        const model = topic.getModel();
 
         // Delete relationships
-                var relationships = this._collectInDepthRelationships(topic);
-                this._deletedRelModel.append(relationships.map(function (rel) {
-                    return rel.getModel().clone();
-                }));
+        const relationships = this._collectInDepthRelationships(topic);
+        this._deletedRelModel.append(relationships.map((rel) => rel.getModel().clone()));
 
-                _.each(relationships, function (relationship) {
+        _.each(relationships, (relationship) => {
           commandContext.deleteRelationship(relationship);
         });
 
         // Store information for undo ...
-                var clonedModel = model.clone();
+        const clonedModel = model.clone();
         this._deletedTopicModels.push(clonedModel);
-                var outTopic = topic.getOutgoingConnectedTopic();
-                var outTopicId = null;
+        const outTopic = topic.getOutgoingConnectedTopic();
+        let outTopicId = null;
         if (outTopic != null) {
           outTopicId = outTopic.getId();
         }
@@ -74,11 +71,10 @@ const DeleteCommand = new Class(/** @lends mindplot.commands.DeleteCommand */{
 
         // Finally, delete the topic from the workspace...
         commandContext.deleteTopic(topic);
-
       }, this);
     }
 
-        var rels = commandContext.findRelationships(this._relIds);
+    const rels = commandContext.findRelationships(this._relIds);
     if (rels.length > 0) {
       _.each(rels, function (rel) {
         this._deletedRelModel.push(rel.getModel().clone());
@@ -91,39 +87,38 @@ const DeleteCommand = new Class(/** @lends mindplot.commands.DeleteCommand */{
      * Overrides abstract parent method
      * @see {@link mindplot.Command.undoExecute}
      */
-    undoExecute:function (commandContext) {
-
+  undoExecute(commandContext) {
     // Add all the topics ...
-        _.each(this._deletedTopicModels, function (model) {
+    _.each(this._deletedTopicModels, (model) => {
       commandContext.createTopic(model);
     }, this);
 
     // Do they need to be connected ?
     _.each(this._deletedTopicModels, function (topicModel, index) {
-            var topics = commandContext.findTopics(topicModel.getId());
+      const topics = commandContext.findTopics(topicModel.getId());
 
-            var parentId = this._parentTopicIds[index];
+      const parentId = this._parentTopicIds[index];
       if (parentId) {
-                var parentTopics = commandContext.findTopics(parentId);
+        const parentTopics = commandContext.findTopics(parentId);
         commandContext.connect(topics[0], parentTopics[0]);
       }
     }, this);
 
     // Add rebuild relationships ...
-        _.each(this._deletedRelModel, function (model) {
+    _.each(this._deletedRelModel, (model) => {
       commandContext.addRelationship(model);
     });
 
     // Finally display the topics ...
-        _.each(this._deletedTopicModels, function (topicModel) {
-            var topics = commandContext.findTopics(topicModel.getId());
+    _.each(this._deletedTopicModels, (topicModel) => {
+      const topics = commandContext.findTopics(topicModel.getId());
       topics[0].setBranchVisibility(true);
     }, this);
 
     // Focus on last recovered topic ..
     if (this._deletedTopicModels.length > 0) {
-            var firstTopic = this._deletedTopicModels[0];
-            var topic = commandContext.findTopics(firstTopic.getId())[0];
+      const firstTopic = this._deletedTopicModels[0];
+      const topic = commandContext.findTopics(firstTopic.getId())[0];
       topic.setOnFocus(true);
     }
 
@@ -132,13 +127,13 @@ const DeleteCommand = new Class(/** @lends mindplot.commands.DeleteCommand */{
     this._deletedRelModel = [];
   },
 
-    _filterChildren:function (topicIds, commandContext) {
-        var topics = commandContext.findTopics(topicIds);
+  _filterChildren(topicIds, commandContext) {
+    const topics = commandContext.findTopics(topicIds);
 
-        var result = [];
-        _.each(topics, function (topic) {
-            var parent = topic.getParent();
-            var found = false;
+    const result = [];
+    _.each(topics, (topic) => {
+      let parent = topic.getParent();
+      let found = false;
       while (parent != null && !found) {
         found = topicIds.contains(parent.getId());
         if (found) {
@@ -155,23 +150,21 @@ const DeleteCommand = new Class(/** @lends mindplot.commands.DeleteCommand */{
     return result;
   },
 
-    _collectInDepthRelationships:function (topic) {
-        var result = [];
+  _collectInDepthRelationships(topic) {
+    let result = [];
     result.append(topic.getRelationships());
 
-        var children = topic.getChildren();
-        var rels = children.map(function (topic) {
+    const children = topic.getChildren();
+    const rels = children.map(function (topic) {
       return this._collectInDepthRelationships(topic);
     }, this);
     result.append(rels.flatten());
 
     if (result.length > 0) {
       // Filter for unique ...
-            result = result.sort(function (a, b) {
-                return a.getModel().getId() - b.getModel().getId();
-            });
-            var ret = [result[0]];
-            for (var i = 1; i < result.length; i++) { // start loop at 1 as element 0 can never be a duplicate
+      result = result.sort((a, b) => a.getModel().getId() - b.getModel().getId());
+      const ret = [result[0]];
+      for (let i = 1; i < result.length; i++) { // start loop at 1 as element 0 can never be a duplicate
         if (result[i - 1] !== result[i]) {
           ret.push(result[i]);
         }
@@ -179,7 +172,7 @@ const DeleteCommand = new Class(/** @lends mindplot.commands.DeleteCommand */{
       result = ret;
     }
     return result;
-    }
+  },
 
 });
 

packages/mindplot/lib/components/commands/DragTopicCommand.js

@@ -15,7 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const Command = require('../Command').default
+const Command = require('../Command').default;
 
 const DragTopicCommand = new Class(/** @lends DragTopicCommand */{
   Extends: Command,
@@ -28,12 +28,11 @@ const DragTopicCommand = new Class(/** @lends DragTopicCommand */{
      * @param {mindplot.Topic} parentTopic the topic to be made the dragged topic's new parent
      * @extends mindplot.Command
      */
-    initialize:function (topicId, position, order, parentTopic) {
-        $assert(topicId, "topicId must be defined");
+  initialize(topicId, position, order, parentTopic) {
+    $assert(topicId, 'topicId must be defined');
 
     this._topicsId = topicId;
-        if ($defined(parentTopic))
-            this._parentId = parentTopic.getId();
+    if ($defined(parentTopic)) this._parentId = parentTopic.getId();
 
     this.parent();
     this._position = position;
@@ -43,17 +42,16 @@ const DragTopicCommand = new Class(/** @lends DragTopicCommand */{
   /**
      * Overrides abstract parent method
      */
-    execute:function (commandContext) {
-
-        var topic = commandContext.findTopics(this._topicsId)[0];
+  execute(commandContext) {
+    const topic = commandContext.findTopics(this._topicsId)[0];
     topic.setVisibility(false);
 
     // Save old position ...
-        var origParentTopic = topic.getOutgoingConnectedTopic();
+    const origParentTopic = topic.getOutgoingConnectedTopic();
 
     // In this case, topics are positioned using order ...
-        var origOrder = topic.getOrder();
-        var origPosition = topic.getPosition();
+    const origOrder = topic.getOrder();
+    const origPosition = topic.getPosition();
 
     // Disconnect topic ..
     if ($defined(origParentTopic) && origParentTopic != this._parentId) {
@@ -66,14 +64,13 @@ const DragTopicCommand = new Class(/** @lends DragTopicCommand */{
     } else if (this._position != null) {
       commandContext.moveTopic(topic, this._position);
     } else {
-            $assert("Illegal command state exception.");
+      $assert('Illegal command state exception.');
     }
 
     // Finally, connect topic ...
     if (origParentTopic != this._parentId) {
-
       if ($defined(this._parentId)) {
-                var parentTopic = commandContext.findTopics(this._parentId)[0];
+        const parentTopic = commandContext.findTopics(this._parentId)[0];
         commandContext.connect(topic, parentTopic);
       }
 
@@ -88,16 +85,15 @@ const DragTopicCommand = new Class(/** @lends DragTopicCommand */{
     // Store for undo ...
     this._order = origOrder;
     this._position = origPosition;
-
   },
 
   /**
      * Overrides abstract parent method
      * @see {@link mindplot.Command.undoExecute}
      */
-    undoExecute:function (commandContext) {
+  undoExecute(commandContext) {
     this.execute(commandContext);
-    }
+  },
 });
 
 export default DragTopicCommand;

packages/mindplot/lib/components/commands/GenericFunctionCommand.js

@@ -15,7 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const Command = require('../Command').default
+const Command = require('../Command').default;
 
 const GenericFunctionCommand = new Class(/** @lends GenericFunctionCommand */{
   Extends: Command,
@@ -30,9 +30,9 @@ const GenericFunctionCommand = new Class(/** @lends GenericFunctionCommand */{
      * e.g. color, font family or text
      * @extends mindplot.Command
      */
-    initialize:function (commandFunc, topicsIds, value) {
-        $assert(commandFunc, "commandFunc must be defined");
-        $assert($defined(topicsIds), "topicsIds must be defined");
+  initialize(commandFunc, topicsIds, value) {
+    $assert(commandFunc, 'commandFunc must be defined');
+    $assert($defined(topicsIds), 'topicsIds must be defined');
 
     this.parent();
     this._value = value;
@@ -44,14 +44,13 @@ const GenericFunctionCommand = new Class(/** @lends GenericFunctionCommand */{
   /**
      * Overrides abstract parent method
      */
-    execute:function (commandContext) {
+  execute(commandContext) {
     if (!this.applied) {
-
-            var topics = null;
+      let topics = null;
       try {
         topics = commandContext.findTopics(this._topicsId);
       } catch (e) {
-                if (this._commandFunc.commandType != "changeTextToTopic") {
+        if (this._commandFunc.commandType != 'changeTextToTopic') {
           // Workaround: For some reason, there is a combination of events that involves
           // making some modification and firing out of focus event. This is causing
           // that a remove node try to be removed.  In some other life, I will come with the solution.
@@ -61,39 +60,36 @@ const GenericFunctionCommand = new Class(/** @lends GenericFunctionCommand */{
       }
 
       if (topics != null) {
-                var me = this;
-                _.each(topics, function (topic) {
-                    var oldValue = me._commandFunc(topic, me._value);
+        const me = this;
+        _.each(topics, (topic) => {
+          const oldValue = me._commandFunc(topic, me._value);
           me._oldValues.push(oldValue);
         });
       }
       this.applied = true;
-
     } else {
-            throw "Command can not be applied two times in a row.";
+      throw 'Command can not be applied two times in a row.';
     }
-
   },
 
   /**
      * Overrides abstract parent method
      * @see {@link mindplot.Command.undoExecute}
      */
-    undoExecute:function (commandContext) {
+  undoExecute(commandContext) {
     if (this.applied) {
-            var topics = commandContext.findTopics(this._topicsId);
-            var me = this;
-            _.each(topics, function (topic, index) {
+      const topics = commandContext.findTopics(this._topicsId);
+      const me = this;
+      _.each(topics, (topic, index) => {
         me._commandFunc(topic, me._oldValues[index]);
-
       });
 
       this.applied = false;
       this._oldValues = [];
     } else {
-            throw "undo can not be applied.";
-        }
+      throw 'undo can not be applied.';
     }
+  },
 });
 
-export default GenericFunctionCommand
+export default GenericFunctionCommand;

packages/mindplot/lib/components/commands/MoveControlPointCommand.js

@@ -31,7 +31,7 @@ const MoveControlPointCommand = new Class(
          * @param ctrlPointController {ControlPoint}
          * @param point {Number} 0 for the destination control point, 1 for the source control point
          */
-        initialize: function (ctrlPointController, point) {
+    initialize(ctrlPointController, point) {
       $assert(ctrlPointController, 'line can not be null');
       $assert($defined(point), 'point can not be null');
 
@@ -57,8 +57,8 @@ const MoveControlPointCommand = new Class(
     /**
          * Overrides abstract parent method
          */
-        execute: function (commandContext) {
-            var model = this._line.getModel();
+    execute(commandContext) {
+      const model = this._line.getModel();
       switch (this._point) {
         case 0:
           model.setSrcCtrlPoint(this._controlPoint.clone());
@@ -85,9 +85,9 @@ const MoveControlPointCommand = new Class(
          * Overrides abstract parent method
          * @see {@link mindplot.Command.undoExecute}
          */
-        undoExecute: function (commandContext) {
-            var line = this._line;
-            var model = line.getModel();
+    undoExecute(commandContext) {
+      const line = this._line;
+      const model = line.getModel();
       switch (this._point) {
         case 0:
           if ($defined(this._oldControlPoint)) {
@@ -112,8 +112,7 @@ const MoveControlPointCommand = new Class(
         line._refreshShape();
       }
     },
-    }
+  },
 );
 
 export default MoveControlPointCommand;
-

packages/mindplot/lib/components/commands/RemoveFeatureFromTopicCommand.js

@@ -27,7 +27,7 @@ const RemoveFeatureFromTopicCommand = new Class(/**@lends RemoveFeatureFromTopic
      * @param {String} featureId id of the feature to remove
      * @extends mindplot.Command
      */
-    initialize:function (topicId, featureId) {
+  initialize(topicId, featureId) {
     $assert($defined(topicId), 'topicId can not be null');
     $assert(featureId, 'iconModel can not be null');
 
@@ -40,9 +40,9 @@ const RemoveFeatureFromTopicCommand = new Class(/**@lends RemoveFeatureFromTopic
   /**
      * Overrides abstract parent method
      */
-    execute:function (commandContext) {
-        var topic = commandContext.findTopics(this._topicId)[0];
-        var feature = topic.findFeatureById(this._featureId);
+  execute(commandContext) {
+    const topic = commandContext.findTopics(this._topicId)[0];
+    const feature = topic.findFeatureById(this._featureId);
     topic.removeFeature(feature);
     this._oldFeature = feature;
   },
@@ -51,11 +51,11 @@ const RemoveFeatureFromTopicCommand = new Class(/**@lends RemoveFeatureFromTopic
      * Overrides abstract parent method
      * @see {@link mindplot.Command.undoExecute}
      */
-    undoExecute:function (commandContext) {
-        var topic = commandContext.findTopics(this._topicId)[0];
+  undoExecute(commandContext) {
+    const topic = commandContext.findTopics(this._topicId)[0];
     topic.addFeature(this._oldFeature);
     this._oldFeature = null;
-    }
+  },
 });
 
 export default RemoveFeatureFromTopicCommand;

packages/mindplot/lib/components/header.js

@@ -16,7 +16,7 @@
  *   limitations under the License.
  */
 
-var mindplot = {};
+const mindplot = {};
 mindplot.util = {};
 mindplot.commands = {};
 mindplot.layout = {};

packages/mindplot/lib/components/index.js

@@ -72,8 +72,8 @@ export const Components = {
   EditorProperties: editorProperties,
   Events: events,
 
-    footer: footer,
-    header: header,
+  footer,
+  header,
 
   Icon: icon,
   IconGroup: iconGroup,
@@ -81,7 +81,7 @@ export const Components = {
   Keyboard: keyboard,
   LinkIcon: linkIcon,
 
-    localSorageManager: localSorageManager,
+  localSorageManager,
   MainTopic: mainTopic,
 
   Messages: messages,

packages/mindplot/lib/components/layout/AbstractBasicSorter.js

@@ -30,31 +30,31 @@ const AbstractBasicSorter = new Class(
          * @param {} node
          * @return the height of a node and its children if existing and not shrunken
          */
-        computeChildrenIdByHeights: function (treeSet, node) {
-            var result = {};
+    computeChildrenIdByHeights(treeSet, node) {
+      const result = {};
       this._computeChildrenHeight(treeSet, node, result);
       return result;
     },
 
-        _getVerticalPadding: function () {
+    _getVerticalPadding() {
       return AbstractBasicSorter.INTERNODE_VERTICAL_PADDING;
     },
 
-        _computeChildrenHeight: function (treeSet, node, heightCache) {
-            var height = node.getSize().height + this._getVerticalPadding() * 2; // 2* Top and down padding;
+    _computeChildrenHeight(treeSet, node, heightCache) {
+      const height = node.getSize().height + this._getVerticalPadding() * 2; // 2* Top and down padding;
 
-            var result;
-            var children = treeSet.getChildren(node);
+      let result;
+      const children = treeSet.getChildren(node);
       if (children.length == 0 || node.areChildrenShrunken()) {
         result = height;
       } else {
-                var childrenHeight = 0;
+        let childrenHeight = 0;
         _.each(
           children,
           function (child) {
             childrenHeight += this._computeChildrenHeight(treeSet, child, heightCache);
           },
-                    this
+          this,
         );
 
         result = Math.max(height, childrenHeight);
@@ -67,19 +67,17 @@ const AbstractBasicSorter = new Class(
       return result;
     },
 
-        _getSortedChildren: function (treeSet, node) {
-            var result = treeSet.getChildren(node);
-            result.sort(function (a, b) {
-                return a.getOrder() - b.getOrder();
-            });
+    _getSortedChildren(treeSet, node) {
+      const result = treeSet.getChildren(node);
+      result.sort((a, b) => a.getOrder() - b.getOrder());
       return result;
     },
 
-        _getRelativeDirection: function (reference, position) {
-            var offset = position.x - reference.x;
+    _getRelativeDirection(reference, position) {
+      const offset = position.x - reference.x;
       return offset >= 0 ? 1 : -1;
     },
-    }
+  },
 );
 
 /**

packages/mindplot/lib/components/layout/BalancedSorter.js

@@ -24,7 +24,7 @@ const BalancedSorter = new Class(
          * @constructs
          * @extends mindplot.layout.AbstractBasicSorter
          */
-        initialize: function () {},
+    initialize() {},
 
     /**
          * @param {} graph
@@ -34,30 +34,28 @@ const BalancedSorter = new Class(
          * @param {Boolean} free
          * @return an array with order and position
          */
-        predict: function (graph, parent, node, position, free) {
+    predict(graph, parent, node, position, free) {
       // If its a free node...
       if (free) {
         $assert(
           $defined(position),
-                    'position cannot be null for predict in free positioning'
+          'position cannot be null for predict in free positioning',
         );
         $assert($defined(node), 'node cannot be null for predict in free positioning');
 
         var rootNode = graph.getRootNode(parent);
         var direction = this._getRelativeDirection(
           rootNode.getPosition(),
-                    node.getPosition()
+          node.getPosition(),
         );
 
-                var limitXPos =
-                    parent.getPosition().x +
-                    direction *
-                        (parent.getSize().width / 2 +
-                            node.getSize().width / 2 +
-                            BalancedSorter.INTERNODE_HORIZONTAL_PADDING);
+        const limitXPos = parent.getPosition().x
+                    + direction
+                        * (parent.getSize().width / 2
+                            + node.getSize().width / 2
+                            + BalancedSorter.INTERNODE_HORIZONTAL_PADDING);
 
-                var xPos =
-                    direction > 0
+        const xPos = direction > 0
           ? position.x >= limitXPos
             ? position.x
             : limitXPos
@@ -73,17 +71,17 @@ const BalancedSorter = new Class(
       // If it is a dragged node...
       if (node) {
         $assert($defined(position), 'position cannot be null for predict in dragging');
-                var nodeDirection = this._getRelativeDirection(
+        const nodeDirection = this._getRelativeDirection(
           rootNode.getPosition(),
-                    node.getPosition()
+          node.getPosition(),
         );
-                var positionDirection = this._getRelativeDirection(
+        const positionDirection = this._getRelativeDirection(
           rootNode.getPosition(),
-                    position
+          position,
         );
-                var siblings = graph.getSiblings(node);
+        const siblings = graph.getSiblings(node);
 
-                var sameParent = parent == graph.getParent(node);
+        const sameParent = parent == graph.getParent(node);
         if (siblings.length == 0 && nodeDirection == positionDirection && sameParent) {
           return [node.getOrder(), node.getPosition()];
         }
@@ -94,7 +92,7 @@ const BalancedSorter = new Class(
         var left = this._getChildrenForOrder(parent, graph, 1);
       }
       // Filter nodes on one side..
-            var order = position
+      const order = position
         ? position.x > rootNode.getPosition().x
           ? 0
           : 1
@@ -104,9 +102,7 @@ const BalancedSorter = new Class(
       var direction = order % 2 == 0 ? 1 : -1;
 
       // Exclude the dragged node (if set)
-            var children = this._getChildrenForOrder(parent, graph, order).filter(function (child) {
-                return child != node;
-            });
+      const children = this._getChildrenForOrder(parent, graph, order).filter((child) => child != node);
 
       // No children?
       if (children.length == 0) {
@@ -114,24 +110,23 @@ const BalancedSorter = new Class(
           order,
           {
             x:
-                            parent.getPosition().x +
-                            direction *
-                                (parent.getSize().width / 2 +
-                                    BalancedSorter.INTERNODE_HORIZONTAL_PADDING * 2),
+                            parent.getPosition().x
+                            + direction
+                                * (parent.getSize().width / 2
+                                    + BalancedSorter.INTERNODE_HORIZONTAL_PADDING * 2),
             y: parent.getPosition().y,
           },
         ];
       }
 
       // Try to fit within ...
-            var result = null;
-            var last = children.getLast();
+      let result = null;
+      const last = children.getLast();
       position = position || { x: last.getPosition().x, y: last.getPosition().y + 1 };
-            _.each(children, function (child, index) {
-                var cpos = child.getPosition();
+      _.each(children, (child, index) => {
+        const cpos = child.getPosition();
         if (position.y > cpos.y) {
-                    let yOffset =
-                        child == last
+          const yOffset = child == last
             ? child.getSize().height + BalancedSorter.INTERNODE_VERTICAL_PADDING * 2
             : (children[index + 1].getPosition().y - child.getPosition().y) / 2;
           result = [child.getOrder() + 2, { x: cpos.x, y: cpos.y + yOffset }];
@@ -140,15 +135,15 @@ const BalancedSorter = new Class(
 
       // Position wasn't below any node, so it must be inserted above
       if (!result) {
-                var first = children[0];
+        const first = children[0];
         result = [
           position.x > 0 ? 0 : 1,
           {
             x: first.getPosition().x,
             y:
-                            first.getPosition().y -
-                            first.getSize().height -
-                            BalancedSorter.INTERNODE_VERTICAL_PADDING * 2,
+                            first.getPosition().y
+                            - first.getSize().height
+                            - BalancedSorter.INTERNODE_VERTICAL_PADDING * 2,
           },
         ];
       }
@@ -162,8 +157,8 @@ const BalancedSorter = new Class(
          * @param {} child
          * @param {} order
          */
-        insert: function (treeSet, parent, child, order) {
-            var children = this._getChildrenForOrder(parent, treeSet, order);
+    insert(treeSet, parent, child, order) {
+      const children = this._getChildrenForOrder(parent, treeSet, order);
 
       // If no children, return 0 or 1 depending on the side
       if (children.length == 0) {
@@ -173,9 +168,9 @@ const BalancedSorter = new Class(
 
       // Shift all the elements by two, so side is the same.
       // In case of balanced sorter, order don't need to be continuous...
-            var max = 0;
-            for (var i = 0; i < children.length; i++) {
-                var node = children[i];
+      let max = 0;
+      for (let i = 0; i < children.length; i++) {
+        const node = children[i];
         max = Math.max(max, node.getOrder());
         if (node.getOrder() >= order) {
           max = Math.max(max, node.getOrder() + 2);
@@ -183,7 +178,7 @@ const BalancedSorter = new Class(
         }
       }
 
-            var newOrder = order > max + 1 ? max + 2 : order;
+      const newOrder = order > max + 1 ? max + 2 : order;
       child.setOrder(newOrder);
     },
 
@@ -191,12 +186,12 @@ const BalancedSorter = new Class(
          * @param {} treeSet
          * @param {} node
          */
-        detach: function (treeSet, node) {
-            var parent = treeSet.getParent(node);
+    detach(treeSet, node) {
+      const parent = treeSet.getParent(node);
       // Filter nodes on one side..
-            var children = this._getChildrenForOrder(parent, treeSet, node.getOrder());
+      const children = this._getChildrenForOrder(parent, treeSet, node.getOrder());
 
-            _.each(children, function (child, index) {
+      _.each(children, (child, index) => {
         if (child.getOrder() > node.getOrder()) {
           child.setOrder(child.getOrder() - 2);
         }
@@ -209,14 +204,14 @@ const BalancedSorter = new Class(
          * @param {} node
          * @return offsets
          */
-        computeOffsets: function (treeSet, node) {
+    computeOffsets(treeSet, node) {
       $assert(treeSet, 'treeSet can no be null.');
       $assert(node, 'node can no be null.');
 
-            var children = this._getSortedChildren(treeSet, node);
+      const children = this._getSortedChildren(treeSet, node);
 
       // Compute heights ...
-            var heights = children
+      const heights = children
         .map(function (child) {
           return {
             id: child.getId(),
@@ -228,39 +223,38 @@ const BalancedSorter = new Class(
         .reverse();
 
       // Compute the center of the branch ...
-            var totalPHeight = 0;
-            var totalNHeight = 0;
+      let totalPHeight = 0;
+      let totalNHeight = 0;
 
-            _.each(heights, function (elem) {
+      _.each(heights, (elem) => {
         if (elem.order % 2 == 0) {
           totalPHeight += elem.height;
         } else {
           totalNHeight += elem.height;
         }
       });
-            var psum = totalPHeight / 2;
-            var nsum = totalNHeight / 2;
-            var ysum = 0;
+      let psum = totalPHeight / 2;
+      let nsum = totalNHeight / 2;
+      let ysum = 0;
 
       // Calculate the offsets ...
-            var result = {};
-            for (var i = 0; i < heights.length; i++) {
-                var direction = heights[i].order % 2 ? -1 : 1;
+      const result = {};
+      for (let i = 0; i < heights.length; i++) {
+        const direction = heights[i].order % 2 ? -1 : 1;
 
         if (direction > 0) {
-                    psum = psum - heights[i].height;
+          psum -= heights[i].height;
           ysum = psum;
         } else {
-                    nsum = nsum - heights[i].height;
+          nsum -= heights[i].height;
           ysum = nsum;
         }
 
-                var yOffset = ysum + heights[i].height / 2;
-                var xOffset =
-                    direction *
-                    (node.getSize().width / 2 +
-                        heights[i].width / 2 +
-                        +BalancedSorter.INTERNODE_HORIZONTAL_PADDING);
+        const yOffset = ysum + heights[i].height / 2;
+        const xOffset = direction
+                    * (node.getSize().width / 2
+                        + heights[i].width / 2
+                        + +BalancedSorter.INTERNODE_HORIZONTAL_PADDING);
 
         $assert(!isNaN(xOffset), 'xOffset can not be null');
         $assert(!isNaN(yOffset), 'yOffset can not be null');
@@ -275,23 +269,23 @@ const BalancedSorter = new Class(
          * @param {} node
          * @throw will throw an error if order elements are missing
          */
-        verify: function (treeSet, node) {
+    verify(treeSet, node) {
       // Check that all is consistent ...
-            var children = this._getChildrenForOrder(node, treeSet, node.getOrder());
+      const children = this._getChildrenForOrder(node, treeSet, node.getOrder());
 
       // All odd ordered nodes should be "continuous" by themselves
       // All even numbered nodes should be "continuous" by themselves
-            var factor = node.getOrder() % 2 == 0 ? 2 : 1;
-            for (var i = 0; i < children.length; i++) {
-                var order = i == 0 && factor == 1 ? 1 : factor * i;
+      const factor = node.getOrder() % 2 == 0 ? 2 : 1;
+      for (let i = 0; i < children.length; i++) {
+        const order = i == 0 && factor == 1 ? 1 : factor * i;
         $assert(
           children[i].getOrder() == order,
-                    'Missing order elements. Missing order: ' +
-                        i * factor +
-                        '. Parent:' +
-                        node.getId() +
-                        ',Node:' +
-                        children[i].getId()
+          `Missing order elements. Missing order: ${
+            i * factor
+          }. Parent:${
+            node.getId()
+          },Node:${
+            children[i].getId()}`,
         );
       }
     },
@@ -301,27 +295,25 @@ const BalancedSorter = new Class(
          * @param {} child
          * @return the direction of the child within the treeSet
          */
-        getChildDirection: function (treeSet, child) {
+    getChildDirection(treeSet, child) {
       return child.getOrder() % 2 == 0 ? 1 : -1;
     },
 
     /**
          * @return {String} the print name of this class
          */
-        toString: function () {
+    toString() {
       return 'Balanced Sorter';
     },
 
-        _getChildrenForOrder: function (parent, graph, order) {
-            return this._getSortedChildren(graph, parent).filter(function (child) {
-                return child.getOrder() % 2 == order % 2;
-            });
+    _getChildrenForOrder(parent, graph, order) {
+      return this._getSortedChildren(graph, parent).filter((child) => child.getOrder() % 2 == order % 2);
     },
 
-        _getVerticalPadding: function () {
+    _getVerticalPadding() {
       return BalancedSorter.INTERNODE_VERTICAL_PADDING;
     },
-    }
+  },
 );
 
 /**

packages/mindplot/lib/components/layout/ChangeEvent.js

@@ -22,25 +22,25 @@ const ChangeEvent = new Class(/** @lends ChangeEvent */{
      * @param {} id
      * @throws will throw an error if the given id is not/cannot be converted to a numerical value
      */
-    initialize:function(id) {
-        $assert(!isNaN(id), "id can not be null");
+  initialize(id) {
+    $assert(!isNaN(id), 'id can not be null');
     this._id = id;
     this._position = null;
     this._order = null;
   },
 
   /** @return id */
-    getId:function() {
+  getId() {
     return this._id;
   },
 
   /** @return order */
-    getOrder: function() {
+  getOrder() {
     return this._order;
   },
 
   /** @return position */
-    getPosition: function() {
+  getPosition() {
     return this._position;
   },
 
@@ -49,22 +49,22 @@ const ChangeEvent = new Class(/** @lends ChangeEvent */{
      * @throws will throw an error if the given parameter is not/cannot be converted to a numerical
      * value
      */
-    setOrder: function(value) {
-        $assert(!isNaN(value), "value can not be null");
+  setOrder(value) {
+    $assert(!isNaN(value), 'value can not be null');
     this._order = value;
   },
 
   /** @param {} value
      *  @throws will throw an error if the value is null or undefined */
-    setPosition: function(value) {
-        $assert(value, "value can not be null");
+  setPosition(value) {
+    $assert(value, 'value can not be null');
     this._position = value;
   },
 
   /** @return {String} order and position */
-    toString: function() {
-        return "[order:" + this.getOrder() + ", position: {" + this.getPosition().x + "," + this.getPosition().y + "}]";
-    }
+  toString() {
+    return `[order:${this.getOrder()}, position: {${this.getPosition().x},${this.getPosition().y}}]`;
+  },
 });
 
 export default ChangeEvent;

packages/mindplot/lib/components/layout/ChildrenSorterStrategy.js

@@ -20,50 +20,50 @@ const ChildrenSorterStrategy = new Class(/** @lends ChildrenSorterStrategy */{
   /**
      * @constructs
      */
-    initialize:function() {
+  initialize() {
 
   },
 
   /** @abstract */
-    computeChildrenIdByHeights: function(treeSet, node) {
-        throw "Method must be implemented";
+  computeChildrenIdByHeights(treeSet, node) {
+    throw 'Method must be implemented';
   },
 
   /** @abstract */
-    computeOffsets:function(treeSet, node) {
-        throw "Method must be implemented";
+  computeOffsets(treeSet, node) {
+    throw 'Method must be implemented';
   },
 
   /** @abstract */
-    insert: function(treeSet, parent, child, order) {
-        throw "Method must be implemented";
+  insert(treeSet, parent, child, order) {
+    throw 'Method must be implemented';
   },
 
   /** @abstract */
-    detach:function(treeSet, node) {
-        throw "Method must be implemented";
+  detach(treeSet, node) {
+    throw 'Method must be implemented';
   },
 
   /** @abstract */
-    predict:function(treeSet, parent, node, position, free) {
-        throw "Method must be implemented";
+  predict(treeSet, parent, node, position, free) {
+    throw 'Method must be implemented';
   },
 
   /** @abstract */
-    verify:function(treeSet, node) {
-        throw "Method must be implemented";
+  verify(treeSet, node) {
+    throw 'Method must be implemented';
   },
 
   /** @abstract */
-    getChildDirection: function(treeSet, node) {
-        throw "Method must be implemented";
+  getChildDirection(treeSet, node) {
+    throw 'Method must be implemented';
   },
 
   /** @abstract */
-    toString:function() {
-        throw "Method must be implemented: print name";
-    }
+  toString() {
+    throw 'Method must be implemented: print name';
+  },
 
 });
 
-export default ChildrenSorterStrategy
+export default ChildrenSorterStrategy;

packages/mindplot/lib/components/layout/EventBus.js

@@ -23,8 +23,8 @@ const EventBus = new Class(/** @lends EventBus */{
      * @constructs
      * @implements mindplot.Events
      */
-    initialize: function() {
-    }
+  initialize() {
+  },
 });
 
 /**
@@ -39,7 +39,7 @@ EventBus.events = {
   NodeDisconnectEvent: 'NodeDisconnectEvent',
   NodeAdded: 'NodeAdded',
   NodeRemoved: 'NodeRemoved',
-    DoLayout:'DoLayout'
+  DoLayout: 'DoLayout',
 };
 
 /** instance */

packages/mindplot/lib/components/layout/EventBusDispatcher.js

@@ -15,27 +15,27 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const EventBus = require('./EventBus').default
+const EventBus = require('./EventBus').default;
 
 const EventBusDispatcher = new Class(/** @lends EventBusDispatcher */{
   /**
      * @constructs
      */
-    initialize:function() {
+  initialize() {
     this.registerBusEvents();
   },
 
   /**
      * @param {mindplot.layout.LayoutManager} layoutManager
      */
-    setLayoutManager : function(layoutManager) {
+  setLayoutManager(layoutManager) {
     this._layoutManager = layoutManager;
   },
 
   /**
      * register bus events
      */
-    registerBusEvents:function () {
+  registerBusEvents() {
     EventBus.instance.addEvent(EventBus.events.NodeAdded, this._nodeAdded.bind(this));
     EventBus.instance.addEvent(EventBus.events.NodeRemoved, this._nodeRemoved.bind(this));
     EventBus.instance.addEvent(EventBus.events.NodeResizeEvent, this._nodeResizeEvent.bind(this));
@@ -46,28 +46,27 @@ const EventBusDispatcher = new Class(/** @lends EventBusDispatcher */{
     EventBus.instance.addEvent(EventBus.events.DoLayout, this._doLayout.bind(this));
   },
 
-    _nodeResizeEvent: function(args) {
+  _nodeResizeEvent(args) {
     this._layoutManager.updateNodeSize(args.node.getId(), args.size);
   },
 
-    _nodeMoveEvent: function(args) {
+  _nodeMoveEvent(args) {
     this._layoutManager.moveNode(args.node.getId(), args.position);
   },
 
-    _nodeDisconnectEvent: function(node) {
+  _nodeDisconnectEvent(node) {
     this._layoutManager.disconnectNode(node.getId());
   },
 
-    _nodeConnectEvent: function(args) {
+  _nodeConnectEvent(args) {
     this._layoutManager.connectNode(args.parentNode.getId(), args.childNode.getId(), args.childNode.getOrder());
-
   },
 
-    _nodeShrinkEvent: function(node) {
+  _nodeShrinkEvent(node) {
     this._layoutManager.updateShrinkState(node.getId(), node.areChildrenShrunken());
   },
 
-    _nodeAdded: function(node) {
+  _nodeAdded(node) {
     // Central topic must not be added twice ...
     if (node.getId() != 0) {
       this._layoutManager.addNode(node.getId(), { width: 10, height: 10 }, node.getPosition());
@@ -75,11 +74,11 @@ const EventBusDispatcher = new Class(/** @lends EventBusDispatcher */{
     }
   },
 
-    _nodeRemoved: function(node) {
+  _nodeRemoved(node) {
     this._layoutManager.removeNode(node.getId());
   },
 
-    _doLayout: function() {
+  _doLayout() {
     //        (function() {
     this._layoutManager.layout(true);
     //        console.log("---------");
@@ -90,10 +89,10 @@ const EventBusDispatcher = new Class(/** @lends EventBusDispatcher */{
   },
 
   /** @return layout manager */
-    getLayoutManager: function() {
+  getLayoutManager() {
     return this._layoutManager;
-    }
+  },
 
 });
 
-export default EventBusDispatcher
+export default EventBusDispatcher;

packages/mindplot/lib/components/layout/GridSorter.js

@@ -15,7 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const AbstractBasicSorter = require('./AbstractBasicSorter').default
+const AbstractBasicSorter = require('./AbstractBasicSorter').default;
 
 /**
  * @class
@@ -29,42 +29,39 @@ const GridSorter = new Class(/** @lends GridSorter */{
      * @param {} node
      * @return offsets
      */
-    computeOffsets: function(treeSet, node) {
-        $assert(treeSet, "treeSet can no be null.");
-        $assert(node, "node can no be null.");
-        $assert("order can no be null.");
+  computeOffsets(treeSet, node) {
+    $assert(treeSet, 'treeSet can no be null.');
+    $assert(node, 'node can no be null.');
+    $assert('order can no be null.');
 
-        var children = this._getSortedChildren(treeSet, node);
+    const children = this._getSortedChildren(treeSet, node);
 
     // Compute heights ...
-        var me = this;
-        var heights = children.map(function(child) {
-            return {
+    const me = this;
+    const heights = children.map((child) => ({
       id: child.getId(),
-                height: me._computeChildrenHeight(treeSet, child)
-            };
-        });
+      height: me._computeChildrenHeight(treeSet, child),
+    }));
 
     // Calculate the offsets ...
-        var result = {};
-        for (var i = 0; i < heights.length; i++) {
-            var even = i%2 == 0 ? 1 : -1;
+    const result = {};
+    for (let i = 0; i < heights.length; i++) {
+      const even = i % 2 == 0 ? 1 : -1;
 
-            var zeroHeight = i == 0 ? 0 : heights[0].height/2 * even;
-            var middleHeight = 0;
-            for (var j=i-2; j>0; j=j-2) {
+      const zeroHeight = i == 0 ? 0 : heights[0].height / 2 * even;
+      let middleHeight = 0;
+      for (let j = i - 2; j > 0; j -= 2) {
         middleHeight += heights[j].height * even;
       }
-            var finalHeight = i == 0 ? 0 : heights[i].height/2 * even;
+      const finalHeight = i == 0 ? 0 : heights[i].height / 2 * even;
 
-            var yOffset = zeroHeight + middleHeight +finalHeight;
-            var xOffset = node.getSize().width + GridSorter.GRID_HORIZONTAR_SIZE;
+      const yOffset = zeroHeight + middleHeight + finalHeight;
+      const xOffset = node.getSize().width + GridSorter.GRID_HORIZONTAR_SIZE;
 
-            $assert(!isNaN(xOffset), "xOffset can not be null");
-            $assert(!isNaN(yOffset), "yOffset can not be null");
+      $assert(!isNaN(xOffset), 'xOffset can not be null');
+      $assert(!isNaN(yOffset), 'yOffset can not be null');
 
       result[heights[i].id] = { x: xOffset, y: yOffset };
-
     }
     return result;
   },
@@ -72,9 +69,9 @@ const GridSorter = new Class(/** @lends GridSorter */{
   /**
      * @return {String} the print name of this class
      */
-    toString:function() {
-        return "Grid Sorter";
-    }
+  toString() {
+    return 'Grid Sorter';
+  },
 
 });
 

packages/mindplot/lib/components/layout/LayoutManager.js

@@ -31,7 +31,7 @@ const LayoutManager = new Class(
          * @throws will throw an error if the root node id is null or undefined
          * @throws will throw an error if the root size is null
          */
-        initialize: function (rootNodeId, rootSize) {
+    initialize(rootNodeId, rootSize) {
       $assert($defined(rootNodeId), 'rootNodeId can not be null');
       $assert(rootSize, 'rootSize can not be null');
       var position = position || { x: 0, y: 0 };
@@ -39,7 +39,7 @@ const LayoutManager = new Class(
       this._treeSet = new RootedTreeSet();
       this._layout = new OriginalLayout(this._treeSet);
 
-            var rootNode = this._layout.createNode(rootNodeId, rootSize, position, 'root');
+      const rootNode = this._layout.createNode(rootNodeId, rootSize, position, 'root');
       this._treeSet.setRoot(rootNode);
       this._events = [];
     },
@@ -49,10 +49,10 @@ const LayoutManager = new Class(
          * @param size
          * @throws will throw an error if id is null or undefined
          */
-        updateNodeSize: function (id, size) {
+    updateNodeSize(id, size) {
       $assert($defined(id), 'id can not be null');
 
-            var node = this._treeSet.find(id);
+      const node = this._treeSet.find(id);
       node.setSize(size);
     },
 
@@ -63,11 +63,11 @@ const LayoutManager = new Class(
          * @throws will throw an error if value is null or undefined
          * @return this
          */
-        updateShrinkState: function (id, value) {
+    updateShrinkState(id, value) {
       $assert($defined(id), 'id can not be null');
       $assert($defined(value), 'value can not be null');
 
-            var node = this._treeSet.find(id);
+      const node = this._treeSet.find(id);
       node.setShrunken(value);
 
       return this;
@@ -77,7 +77,7 @@ const LayoutManager = new Class(
          * @param id
          * @return {@link RootedTreeSet}.find(id)
          */
-        find: function (id) {
+    find(id) {
       return this._treeSet.find(id);
     },
 
@@ -89,13 +89,13 @@ const LayoutManager = new Class(
          * @throws will throw an error if the position's x property is null or undefined
          * @throws will throw an error if the position's y property is null or undefined
          */
-        moveNode: function (id, position) {
+    moveNode(id, position) {
       $assert($defined(id), 'id cannot be null');
       $assert($defined(position), 'position cannot be null');
       $assert($defined(position.x), 'x can not be null');
       $assert($defined(position.y), 'y can not be null');
 
-            var node = this._treeSet.find(id);
+      const node = this._treeSet.find(id);
       // @Todo: this should not be here. This is broking the isolated node support...
       //        node.setFree(true);
       //        node.setFreeDisplacement({x:position.x - node.getPosition().x, y:position.y - node.getPosition().y});
@@ -111,7 +111,7 @@ const LayoutManager = new Class(
          * @throws will throw an error if order is null or undefined
          * @return this
          */
-        connectNode: function (parentId, childId, order) {
+    connectNode(parentId, childId, order) {
       $assert($defined(parentId), 'parentId cannot be null');
       $assert($defined(childId), 'childId cannot be null');
       $assert($defined(order), 'order cannot be null');
@@ -126,7 +126,7 @@ const LayoutManager = new Class(
          * @throws will throw an error if id is null or undefined
          * @return this
          */
-        disconnectNode: function (id) {
+    disconnectNode(id) {
       $assert($defined(id), 'id can not be null');
       this._layout.disconnectNode(id);
 
@@ -140,9 +140,9 @@ const LayoutManager = new Class(
          * @throws will throw an error if id is null or undefined
          * @return this
          */
-        addNode: function (id, size, position) {
+    addNode(id, size, position) {
       $assert($defined(id), 'id can not be null');
-            var result = this._layout.createNode(id, size, position, 'topic');
+      const result = this._layout.createNode(id, size, position, 'topic');
       this._treeSet.add(result);
 
       return this;
@@ -154,9 +154,9 @@ const LayoutManager = new Class(
          * @throws will throw an error if id is null or undefined
          * @return this
          */
-        removeNode: function (id) {
+    removeNode(id) {
       $assert($defined(id), 'id can not be null');
-            var node = this._treeSet.find(id);
+      const node = this._treeSet.find(id);
 
       // Is It connected ?
       if (this._treeSet.getParent(node)) {
@@ -177,21 +177,21 @@ const LayoutManager = new Class(
          * @param {Boolean=} free true specifies free node positioning
          * @throws will throw an error if parentId is null or undefined
          */
-        predict: function (parentId, nodeId, position, free) {
+    predict(parentId, nodeId, position, free) {
       $assert($defined(parentId), 'parentId can not be null');
 
-            var parent = this._treeSet.find(parentId);
-            var node = nodeId ? this._treeSet.find(nodeId) : null;
-            var sorter = parent.getSorter();
+      const parent = this._treeSet.find(parentId);
+      const node = nodeId ? this._treeSet.find(nodeId) : null;
+      const sorter = parent.getSorter();
 
-            var result = sorter.predict(this._treeSet, parent, node, position, free);
+      const result = sorter.predict(this._treeSet, parent, node, position, free);
       return { order: result[0], position: result[1] };
     },
 
     /**
          * logs dump to console
          */
-        dump: function () {
+    dump() {
       console.log(this._treeSet.dump());
     },
 
@@ -201,18 +201,18 @@ const LayoutManager = new Class(
          * @throws will throw an error if containerId is null or undefined
          * @return canvas
          */
-        plot: function (containerId, size) {
+    plot(containerId, size) {
       $assert(containerId, 'containerId cannot be null');
       size = size || { width: 200, height: 200 };
-            var squaresize = 10;
-            var canvas = Raphael(containerId, size.width, size.height);
+      const squaresize = 10;
+      const canvas = Raphael(containerId, size.width, size.height);
       canvas.drawGrid(
         0,
         0,
         size.width,
         size.height,
         size.width / squaresize,
-                size.height / squaresize
+        size.height / squaresize,
       );
       this._treeSet.plot(canvas);
 
@@ -224,7 +224,7 @@ const LayoutManager = new Class(
          * @param fireEvents
          * @return this
          */
-        layout: function (fireEvents) {
+    layout(fireEvents) {
       // File repositioning ...
       this._layout.layout();
 
@@ -238,18 +238,18 @@ const LayoutManager = new Class(
       return this;
     },
 
-        _flushEvents: function () {
+    _flushEvents() {
       _.each(
         this._events,
         function (event) {
           this.fireEvent('change', event);
         },
-                this
+        this,
       );
       this._events = [];
     },
 
-        _collectChanges: function (nodes) {
+    _collectChanges(nodes) {
       if (!nodes) nodes = this._treeSet.getTreeRoots();
 
       _.each(
@@ -257,10 +257,8 @@ const LayoutManager = new Class(
         function (node) {
           if (node.hasOrderChanged() || node.hasPositionChanged()) {
             // Find or create a event ...
-                        var id = node.getId();
-                        var event = this._events.some(function (event) {
-                            return event.id == id;
-                        });
+            const id = node.getId();
+            let event = this._events.some((event) => event.id == id);
             if (!event) {
               event = new ChangeEvent(id);
             }
@@ -276,10 +274,10 @@ const LayoutManager = new Class(
           }
           this._collectChanges(this._treeSet.getChildren(node));
         },
-                this
+        this,
       );
     },
-    }
+  },
 );
 
 export default LayoutManager;

packages/mindplot/lib/components/layout/Node.js

@@ -29,7 +29,7 @@ const Node = new Class(
          * @throws will throw an error if position is null or undefined
          * @throws will throw an error if sorter is null or undefined
          */
-        initialize: function (id, size, position, sorter) {
+    initialize(id, size, position, sorter) {
       $assert(typeof id === 'number' && isFinite(id), 'id can not be null');
       $assert(size, 'size can not be null');
       $assert(position, 'position can not be null');
@@ -45,116 +45,116 @@ const Node = new Class(
     },
 
     /** */
-        getId: function () {
+    getId() {
       return this._id;
     },
 
     /** */
-        setFree: function (value) {
+    setFree(value) {
       this._setProperty('free', value);
     },
 
     /** */
-        isFree: function () {
+    isFree() {
       return this._getProperty('free');
     },
 
     /** */
-        hasFreeChanged: function () {
+    hasFreeChanged() {
       return this._isPropertyChanged('free');
     },
 
     /** */
-        hasFreeDisplacementChanged: function () {
+    hasFreeDisplacementChanged() {
       return this._isPropertyChanged('freeDisplacement');
     },
 
     /** */
-        setShrunken: function (value) {
+    setShrunken(value) {
       this._setProperty('shrink', value);
     },
 
     /** */
-        areChildrenShrunken: function () {
+    areChildrenShrunken() {
       return this._getProperty('shrink');
     },
 
     /** */
-        setOrder: function (order) {
+    setOrder(order) {
       $assert(
         typeof order === 'number' && isFinite(order),
-                'Order can not be null. Value:' + order
+        `Order can not be null. Value:${order}`,
       );
       this._setProperty('order', order);
     },
 
     /** */
-        resetPositionState: function () {
-            var prop = this._properties['position'];
+    resetPositionState() {
+      const prop = this._properties.position;
       if (prop) {
         prop.hasChanged = false;
       }
     },
 
     /** */
-        resetOrderState: function () {
-            var prop = this._properties['order'];
+    resetOrderState() {
+      const prop = this._properties.order;
       if (prop) {
         prop.hasChanged = false;
       }
     },
 
     /** */
-        resetFreeState: function () {
-            var prop = this._properties['freeDisplacement'];
+    resetFreeState() {
+      const prop = this._properties.freeDisplacement;
       if (prop) {
         prop.hasChanged = false;
       }
     },
 
     /** */
-        getOrder: function () {
+    getOrder() {
       return this._getProperty('order');
     },
 
     /** */
-        hasOrderChanged: function () {
+    hasOrderChanged() {
       return this._isPropertyChanged('order');
     },
 
     /** */
-        hasPositionChanged: function () {
+    hasPositionChanged() {
       return this._isPropertyChanged('position');
     },
 
     /** */
-        hasSizeChanged: function () {
+    hasSizeChanged() {
       return this._isPropertyChanged('size');
     },
 
     /** */
-        getPosition: function () {
+    getPosition() {
       return this._getProperty('position');
     },
 
     /** */
-        setSize: function (size) {
+    setSize(size) {
       $assert($defined(size), 'Size can not be null');
       this._setProperty('size', Object.clone(size));
     },
 
     /** */
-        getSize: function () {
+    getSize() {
       return this._getProperty('size');
     },
 
     /** */
-        setFreeDisplacement: function (displacement) {
+    setFreeDisplacement(displacement) {
       $assert($defined(displacement), 'Position can not be null');
       $assert($defined(displacement.x), 'x can not be null');
       $assert($defined(displacement.y), 'y can not be null');
-            var oldDisplacement = this.getFreeDisplacement();
-            var newDisplacement = {
+      const oldDisplacement = this.getFreeDisplacement();
+      const newDisplacement = {
         x: oldDisplacement.x + displacement.x,
         y: oldDisplacement.y + displacement.y,
       };
@@ -163,34 +163,33 @@ const Node = new Class(
     },
 
     /** */
-        resetFreeDisplacement: function () {
+    resetFreeDisplacement() {
       this._setProperty('freeDisplacement', { x: 0, y: 0 });
     },
 
     /** */
-        getFreeDisplacement: function () {
-            var freeDisplacement = this._getProperty('freeDisplacement');
+    getFreeDisplacement() {
+      const freeDisplacement = this._getProperty('freeDisplacement');
       return freeDisplacement || { x: 0, y: 0 };
     },
 
     /** */
-        setPosition: function (position) {
+    setPosition(position) {
       $assert($defined(position), 'Position can not be null');
       $assert($defined(position.x), 'x can not be null');
       $assert($defined(position.y), 'y can not be null');
 
       // This is a performance improvement to avoid movements that really could be avoided.
-            var currentPos = this.getPosition();
+      const currentPos = this.getPosition();
       if (
-                currentPos == null ||
-                Math.abs(currentPos.x - position.x) > 2 ||
-                Math.abs(currentPos.y - position.y) > 2
-            )
-                this._setProperty('position', position);
+        currentPos == null
+                || Math.abs(currentPos.x - position.x) > 2
+                || Math.abs(currentPos.y - position.y) > 2
+      ) this._setProperty('position', position);
     },
 
-        _setProperty: function (key, value) {
-            var prop = this._properties[key];
+    _setProperty(key, value) {
+      let prop = this._properties[key];
       if (!prop) {
         prop = {
           hasChanged: false,
@@ -208,42 +207,42 @@ const Node = new Class(
       this._properties[key] = prop;
     },
 
-        _getProperty: function (key) {
-            var prop = this._properties[key];
+    _getProperty(key) {
+      const prop = this._properties[key];
       return $defined(prop) ? prop.value : null;
     },
 
-        _isPropertyChanged: function (key) {
-            var prop = this._properties[key];
+    _isPropertyChanged(key) {
+      const prop = this._properties[key];
       return prop ? prop.hasChanged : false;
     },
 
     /** */
-        getSorter: function () {
+    getSorter() {
       return this._sorter;
     },
 
     /** @return {String} returns id, order, position, size and shrink information */
-        toString: function () {
+    toString() {
       return (
-                '[id:' +
-                this.getId() +
-                ', order:' +
-                this.getOrder() +
-                ', position: {' +
-                this.getPosition().x +
-                ',' +
-                this.getPosition().y +
-                '}, size: {' +
-                this.getSize().width +
-                ',' +
-                this.getSize().height +
-                '}, shrink:' +
-                this.areChildrenShrunken() +
-                ']'
+        `[id:${
+          this.getId()
+        }, order:${
+          this.getOrder()
+        }, position: {${
+          this.getPosition().x
+        },${
+          this.getPosition().y
+        }}, size: {${
+          this.getSize().width
+        },${
+          this.getSize().height
+        }}, shrink:${
+          this.areChildrenShrunken()
+        }]`
       );
     },
-    }
+  },
 );
 
 export default Node;

packages/mindplot/lib/components/layout/OriginalLayout.js

@@ -26,29 +26,28 @@ const OriginalLayout = new Class(
          * @constructs
          * @param treeSet
          */
-        initialize: function (treeSet) {
+    initialize(treeSet) {
       this._treeSet = treeSet;
     },
 
     /** */
-        createNode: function (id, size, position, type) {
+    createNode(id, size, position, type) {
       $assert($defined(id), 'id can not be null');
       $assert(size, 'size can not be null');
       $assert(position, 'position can not be null');
       $assert(type, 'type can not be null');
 
-            var strategy =
-                type === 'root' ? OriginalLayout.BALANCED_SORTER : OriginalLayout.SYMMETRIC_SORTER;
+      const strategy = type === 'root' ? OriginalLayout.BALANCED_SORTER : OriginalLayout.SYMMETRIC_SORTER;
       return new Node(id, size, position, strategy);
     },
 
     /** */
-        connectNode: function (parentId, childId, order) {
-            var parent = this._treeSet.find(parentId);
-            var child = this._treeSet.find(childId);
+    connectNode(parentId, childId, order) {
+      const parent = this._treeSet.find(parentId);
+      const child = this._treeSet.find(childId);
 
       // Insert the new node ...
-            var sorter = parent.getSorter();
+      const sorter = parent.getSorter();
       sorter.insert(this._treeSet, parent, child, order);
 
       // Connect the new node ...
@@ -59,9 +58,9 @@ const OriginalLayout = new Class(
     },
 
     /** */
-        disconnectNode: function (nodeId) {
-            var node = this._treeSet.find(nodeId);
-            var parent = this._treeSet.getParent(node);
+    disconnectNode(nodeId) {
+      const node = this._treeSet.find(nodeId);
+      const parent = this._treeSet.getParent(node);
       $assert(parent, 'Node already disconnected');
 
       // Make it fixed
@@ -69,7 +68,7 @@ const OriginalLayout = new Class(
       node.resetFreeDisplacement();
 
       // Remove from children list.
-            var sorter = parent.getSorter();
+      const sorter = parent.getSorter();
       sorter.detach(this._treeSet, node);
 
       // Disconnect the new node ...
@@ -80,57 +79,53 @@ const OriginalLayout = new Class(
     },
 
     /** */
-        layout: function () {
-            var roots = this._treeSet.getTreeRoots();
+    layout() {
+      const roots = this._treeSet.getTreeRoots();
       _.each(
         roots,
         function (node) {
           // Calculate all node heights ...
-                    var sorter = node.getSorter();
+          const sorter = node.getSorter();
 
-                    var heightById = sorter.computeChildrenIdByHeights(this._treeSet, node);
+          const heightById = sorter.computeChildrenIdByHeights(this._treeSet, node);
 
           this._layoutChildren(node, heightById);
 
           this._fixOverlapping(node, heightById);
         },
-                this
+        this,
       );
     },
 
-        _layoutChildren: function (node, heightById) {
-            var nodeId = node.getId();
-            var children = this._treeSet.getChildren(node);
-            var parent = this._treeSet.getParent(node);
-            var childrenOrderMoved = children.some(function (child) {
-                return child.hasOrderChanged();
-            });
-            var childrenSizeChanged = children.some(function (child) {
-                return child.hasSizeChanged();
-            });
+    _layoutChildren(node, heightById) {
+      const nodeId = node.getId();
+      const children = this._treeSet.getChildren(node);
+      const parent = this._treeSet.getParent(node);
+      const childrenOrderMoved = children.some((child) => child.hasOrderChanged());
+      const childrenSizeChanged = children.some((child) => child.hasSizeChanged());
 
       // If ether any of the nodes has been changed of position or the height of the children is not
       // the same, children nodes must be repositioned ....
-            var newBranchHeight = heightById[nodeId];
+      const newBranchHeight = heightById[nodeId];
 
-            var parentHeightChanged = $defined(parent) ? parent._heightChanged : false;
-            var heightChanged = node._branchHeight != newBranchHeight;
+      const parentHeightChanged = $defined(parent) ? parent._heightChanged : false;
+      const heightChanged = node._branchHeight != newBranchHeight;
       node._heightChanged = heightChanged || parentHeightChanged;
 
       if (childrenOrderMoved || childrenSizeChanged || heightChanged || parentHeightChanged) {
-                var sorter = node.getSorter();
-                var offsetById = sorter.computeOffsets(this._treeSet, node);
-                var parentPosition = node.getPosition();
-                var me = this;
-                _.each(children, function (child) {
-                    var offset = offsetById[child.getId()];
+        const sorter = node.getSorter();
+        const offsetById = sorter.computeOffsets(this._treeSet, node);
+        const parentPosition = node.getPosition();
+        const me = this;
+        _.each(children, (child) => {
+          const offset = offsetById[child.getId()];
 
-                    var childFreeDisplacement = child.getFreeDisplacement();
-                    var direction = node.getSorter().getChildDirection(me._treeSet, child);
+          const childFreeDisplacement = child.getFreeDisplacement();
+          const direction = node.getSorter().getChildDirection(me._treeSet, child);
 
           if (
-                        (direction > 0 && childFreeDisplacement.x < 0) ||
-                        (direction < 0 && childFreeDisplacement.x > 0)
+            (direction > 0 && childFreeDisplacement.x < 0)
+                        || (direction < 0 && childFreeDisplacement.x > 0)
           ) {
             child.resetFreeDisplacement();
             child.setFreeDisplacement({
@@ -142,10 +137,10 @@ const OriginalLayout = new Class(
           offset.x += child.getFreeDisplacement().x;
           offset.y += child.getFreeDisplacement().y;
 
-                    var parentX = parentPosition.x;
-                    var parentY = parentPosition.y;
+          const parentX = parentPosition.x;
+          const parentY = parentPosition.y;
 
-                    var newPos = {
+          const newPos = {
             x: parentX + offset.x,
             y: parentY + offset.y + me._calculateAlignOffset(node, child, heightById),
           };
@@ -161,28 +156,27 @@ const OriginalLayout = new Class(
         function (child) {
           this._layoutChildren(child, heightById);
         },
-                this
+        this,
       );
     },
 
-        _calculateAlignOffset: function (node, child, heightById) {
+    _calculateAlignOffset(node, child, heightById) {
       if (child.isFree()) {
         return 0;
       }
 
-            var offset = 0;
+      let offset = 0;
 
-            var nodeHeight = node.getSize().height;
-            var childHeight = child.getSize().height;
+      const nodeHeight = node.getSize().height;
+      const childHeight = child.getSize().height;
 
       if (
-                this._treeSet.isStartOfSubBranch(child) &&
-                this._branchIsTaller(child, heightById)
+        this._treeSet.isStartOfSubBranch(child)
+                && this._branchIsTaller(child, heightById)
       ) {
         if (this._treeSet.hasSinglePathToSingleLeaf(child)) {
-                    offset =
-                        heightById[child.getId()] / 2 -
-                        (childHeight + child.getSorter()._getVerticalPadding() * 2) / 2;
+          offset = heightById[child.getId()] / 2
+                        - (childHeight + child.getSorter()._getVerticalPadding() * 2) / 2;
         } else {
           offset = this._treeSet.isLeaf(child) ? 0 : -(childHeight - nodeHeight) / 2;
         }
@@ -203,15 +197,15 @@ const OriginalLayout = new Class(
       return offset;
     },
 
-        _branchIsTaller: function (node, heightById) {
+    _branchIsTaller(node, heightById) {
       return (
-                heightById[node.getId()] >
-                node.getSize().height + node.getSorter()._getVerticalPadding() * 2
+        heightById[node.getId()]
+                > node.getSize().height + node.getSorter()._getVerticalPadding() * 2
       );
     },
 
-        _fixOverlapping: function (node, heightById) {
-            var children = this._treeSet.getChildren(node);
+    _fixOverlapping(node, heightById) {
+      const children = this._treeSet.getChildren(node);
 
       if (node.isFree()) {
         this._shiftBranches(node, heightById);
@@ -222,66 +216,64 @@ const OriginalLayout = new Class(
         function (child) {
           this._fixOverlapping(child, heightById);
         },
-                this
+        this,
       );
     },
 
-        _shiftBranches: function (node, heightById) {
-            var shiftedBranches = [node];
+    _shiftBranches(node, heightById) {
+      const shiftedBranches = [node];
 
-            var siblingsToShift = this._treeSet.getSiblingsInVerticalDirection(
+      const siblingsToShift = this._treeSet.getSiblingsInVerticalDirection(
         node,
-                node.getFreeDisplacement().y
+        node.getFreeDisplacement().y,
       );
-            var last = node;
+      let last = node;
       _.each(
         siblingsToShift,
         function (sibling) {
-                    var overlappingOccurs = shiftedBranches.some(function (shiftedBranch) {
+          const overlappingOccurs = shiftedBranches.some(function (shiftedBranch) {
             return this._branchesOverlap(shiftedBranch, sibling, heightById);
           }, this);
 
           if (!sibling.isFree() || overlappingOccurs) {
-                        var sAmount = node.getFreeDisplacement().y;
+            const sAmount = node.getFreeDisplacement().y;
             this._treeSet.shiftBranchPosition(sibling, 0, sAmount);
             shiftedBranches.push(sibling);
           }
         },
-                this
+        this,
       );
 
-            var branchesToShift = this._treeSet
+      const branchesToShift = this._treeSet
         .getBranchesInVerticalDirection(node, node.getFreeDisplacement().y)
-                .filter(function (branch) {
-                    return !shiftedBranches.contains(branch);
-                });
+        .filter((branch) => !shiftedBranches.contains(branch));
 
       _.each(
         branchesToShift,
         function (branch) {
-                    var bAmount = node.getFreeDisplacement().y;
+          const bAmount = node.getFreeDisplacement().y;
           this._treeSet.shiftBranchPosition(branch, 0, bAmount);
           shiftedBranches.push(branch);
           last = branch;
         },
-                this
+        this,
       );
     },
 
-        _branchesOverlap: function (branchA, branchB, heightById) {
+    _branchesOverlap(branchA, branchB, heightById) {
       // a branch doesn't really overlap with itself
       if (branchA == branchB) {
         return false;
       }
 
-            var topA = branchA.getPosition().y - heightById[branchA.getId()] / 2;
-            var bottomA = branchA.getPosition().y + heightById[branchA.getId()] / 2;
-            var topB = branchB.getPosition().y - heightById[branchB.getId()] / 2;
-            var bottomB = branchB.getPosition().y + heightById[branchB.getId()] / 2;
+      const topA = branchA.getPosition().y - heightById[branchA.getId()] / 2;
+      const bottomA = branchA.getPosition().y + heightById[branchA.getId()] / 2;
+      const topB = branchB.getPosition().y - heightById[branchB.getId()] / 2;
+      const bottomB = branchB.getPosition().y + heightById[branchB.getId()] / 2;
 
       return !(topA >= bottomB || bottomA <= topB);
     },
-    }
+  },
 );
 
 /**

packages/mindplot/lib/components/layout/RootedTreeSet.js

@@ -19,7 +19,7 @@
 const RootedTreeSet = new Class(
   /** @lends RootedTreeSet */ {
     /** @constructs */
-        initialize: function () {
+    initialize() {
       this._rootNodes = [];
     },
 
@@ -27,17 +27,17 @@ const RootedTreeSet = new Class(
          * @param root
          * @throws will throw an error if root is null or undefined
          */
-        setRoot: function (root) {
+    setRoot(root) {
       $assert(root, 'root can not be null');
       this._rootNodes.push(this._decodate(root));
     },
 
     /** getter */
-        getTreeRoots: function () {
+    getTreeRoots() {
       return this._rootNodes;
     },
 
-        _decodate: function (node) {
+    _decodate(node) {
       node._children = [];
       return node;
     },
@@ -48,11 +48,11 @@ const RootedTreeSet = new Class(
          * @throws will throw an error if node with id already exists
          * @throws will throw an error if node has been added already
          */
-        add: function (node) {
+    add(node) {
       $assert(node, 'node can not be null');
       $assert(
         !this.find(node.getId(), false),
-                'node already exits with this id. Id:' + node.getId()
+        `node already exits with this id. Id:${node.getId()}`,
       );
       $assert(!node._children, 'node already added');
       this._rootNodes.push(this._decodate(node));
@@ -62,9 +62,9 @@ const RootedTreeSet = new Class(
          * @param nodeId
          * @throws will throw an error if nodeId is null or undefined
          */
-        remove: function (nodeId) {
+    remove(nodeId) {
       $assert($defined(nodeId), 'nodeId can not be null');
-            var node = this.find(nodeId);
+      const node = this.find(nodeId);
       this._rootNodes.erase(node);
     },
 
@@ -75,15 +75,15 @@ const RootedTreeSet = new Class(
          * @throws will throw an error if childId is null or undefined
          * @throws will throw an error if node with id childId is already a child of parent
          */
-        connect: function (parentId, childId) {
+    connect(parentId, childId) {
       $assert($defined(parentId), 'parent can not be null');
       $assert($defined(childId), 'child can not be null');
 
-            var parent = this.find(parentId);
-            var child = this.find(childId, true);
+      const parent = this.find(parentId);
+      const child = this.find(childId, true);
       $assert(
         !child._parent,
-                'node already connected. Id:' + child.getId() + ',previous:' + child._parent
+        `node already connected. Id:${child.getId()},previous:${child._parent}`,
       );
 
       parent._children.push(child);
@@ -96,9 +96,9 @@ const RootedTreeSet = new Class(
          * @throws will throw an error if nodeId is null or undefined
          * @throws will throw an error if node is not connected
          */
-        disconnect: function (nodeId) {
+    disconnect(nodeId) {
       $assert($defined(nodeId), 'nodeId can not be null');
-            var node = this.find(nodeId);
+      const node = this.find(nodeId);
       $assert(node._parent, 'Node is not connected');
 
       node._parent._children.erase(node);
@@ -113,13 +113,13 @@ const RootedTreeSet = new Class(
          * @throws will throw an error if node cannot be found
          * @return node
          */
-        find: function (id, validate) {
+    find(id, validate) {
       $assert($defined(id), 'id can not be null');
 
-            var graphs = this._rootNodes;
-            var result = null;
-            for (var i = 0; i < graphs.length; i++) {
-                var node = graphs[i];
+      const graphs = this._rootNodes;
+      let result = null;
+      for (let i = 0; i < graphs.length; i++) {
+        const node = graphs[i];
         result = this._find(id, node);
         if (result) {
           break;
@@ -128,20 +128,20 @@ const RootedTreeSet = new Class(
       validate = !$defined(validate) ? true : validate;
       $assert(
         validate ? result : true,
-                'node could not be found id:' + id + '\n,RootedTreeSet' + this.dump()
+        `node could not be found id:${id}\n,RootedTreeSet${this.dump()}`,
       );
       return result;
     },
 
-        _find: function (id, parent) {
+    _find(id, parent) {
       if (parent.getId() == id) {
         return parent;
       }
 
-            var result = null;
-            var children = parent._children;
-            for (var i = 0; i < children.length; i++) {
-                var child = children[i];
+      let result = null;
+      const children = parent._children;
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
         result = this._find(id, child);
         if (result) break;
       }
@@ -154,7 +154,7 @@ const RootedTreeSet = new Class(
          * @throws will throw an error if nodeId is null or undefined
          * @return children
          */
-        getChildren: function (node) {
+    getChildren(node) {
       $assert(node, 'node cannot be null');
       return node._children;
     },
@@ -164,9 +164,9 @@ const RootedTreeSet = new Class(
          * @throws will throw an error if node is null or undefined
          * @return root node or the provided node, if it has no parent
          */
-        getRootNode: function (node) {
+    getRootNode(node) {
       $assert(node, 'node cannot be null');
-            var parent = this.getParent(node);
+      const parent = this.getParent(node);
       if ($defined(parent)) {
         return this.getRootNode(parent);
       }
@@ -178,13 +178,13 @@ const RootedTreeSet = new Class(
          * @param node
          * @throws will throw an error if node is null or undefined
          * @return {Array} ancestors */
-        getAncestors: function (node) {
+    getAncestors(node) {
       $assert(node, 'node cannot be null');
       return this._getAncestors(this.getParent(node), []);
     },
 
-        _getAncestors: function (node, ancestors) {
-            var result = ancestors;
+    _getAncestors(node, ancestors) {
+      const result = ancestors;
       if (node) {
         result.push(node);
         this._getAncestors(this.getParent(node), result);
@@ -197,14 +197,12 @@ const RootedTreeSet = new Class(
          * @throws will throw an error if node is null or undefined
          * @return {Array} siblings
          */
-        getSiblings: function (node) {
+    getSiblings(node) {
       $assert(node, 'node cannot be null');
       if (!$defined(node._parent)) {
         return [];
       }
-            var siblings = node._parent._children.filter(function (child) {
-                return child != node;
-            });
+      const siblings = node._parent._children.filter((child) => child != node);
       return siblings;
     },
 
@@ -213,13 +211,13 @@ const RootedTreeSet = new Class(
          * @throws will throw an error if node is null or undefined
          * @return {Boolean} whether the node has a single path to a single leaf (no branching)
          */
-        hasSinglePathToSingleLeaf: function (node) {
+    hasSinglePathToSingleLeaf(node) {
       $assert(node, 'node cannot be null');
       return this._hasSinglePathToSingleLeaf(node);
     },
 
-        _hasSinglePathToSingleLeaf: function (node) {
-            var children = this.getChildren(node);
+    _hasSinglePathToSingleLeaf(node) {
+      const children = this.getChildren(node);
 
       if (children.length == 1) {
         return this._hasSinglePathToSingleLeaf(children[0]);
@@ -231,7 +229,7 @@ const RootedTreeSet = new Class(
     /**
          * @param node
          * @return {Boolean} whether the node is the start of a subbranch */
-        isStartOfSubBranch: function (node) {
+    isStartOfSubBranch(node) {
       return this.getSiblings(node).length > 0 && this.getChildren(node).length == 1;
     },
 
@@ -240,7 +238,7 @@ const RootedTreeSet = new Class(
          * @throws will throw an error if node is null or undefined
          * @return {Boolean} whether the node is a leaf
          */
-        isLeaf: function (node) {
+    isLeaf(node) {
       $assert(node, 'node cannot be null');
       return this.getChildren(node).length == 0;
     },
@@ -250,7 +248,7 @@ const RootedTreeSet = new Class(
          * @throws will throw an error if node is null or undefined
          * @return parent
          */
-        getParent: function (node) {
+    getParent(node) {
       $assert(node, 'node cannot be null');
       return node._parent;
     },
@@ -258,22 +256,22 @@ const RootedTreeSet = new Class(
     /**
          * @return result
          */
-        dump: function () {
-            var branches = this._rootNodes;
-            var result = '';
-            for (var i = 0; i < branches.length; i++) {
-                var branch = branches[i];
+    dump() {
+      const branches = this._rootNodes;
+      let result = '';
+      for (let i = 0; i < branches.length; i++) {
+        const branch = branches[i];
         result += this._dump(branch, '');
       }
       return result;
     },
 
-        _dump: function (node, indent) {
-            var result = indent + node + '\n';
-            var children = this.getChildren(node);
-            for (var i = 0; i < children.length; i++) {
-                var child = children[i];
-                result += this._dump(child, indent + '   ');
+    _dump(node, indent) {
+      let result = `${indent + node}\n`;
+      const children = this.getChildren(node);
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        result += this._dump(child, `${indent}   `);
       }
 
       return result;
@@ -282,83 +280,83 @@ const RootedTreeSet = new Class(
     /**
          * @param canvas
          */
-        plot: function (canvas) {
-            var branches = this._rootNodes;
-            for (var i = 0; i < branches.length; i++) {
-                var branch = branches[i];
+    plot(canvas) {
+      const branches = this._rootNodes;
+      for (let i = 0; i < branches.length; i++) {
+        const branch = branches[i];
         this._plot(canvas, branch);
       }
     },
 
-        _plot: function (canvas, node, root) {
-            var children = this.getChildren(node);
-            var cx = node.getPosition().x + canvas.width / 2 - node.getSize().width / 2;
-            var cy = node.getPosition().y + canvas.height / 2 - node.getSize().height / 2;
-            var rect = canvas.rect(cx, cy, node.getSize().width, node.getSize().height);
-            var order = node.getOrder() == null ? 'r' : node.getOrder();
-            var text = canvas.text(
+    _plot(canvas, node, root) {
+      const children = this.getChildren(node);
+      const cx = node.getPosition().x + canvas.width / 2 - node.getSize().width / 2;
+      const cy = node.getPosition().y + canvas.height / 2 - node.getSize().height / 2;
+      const rect = canvas.rect(cx, cy, node.getSize().width, node.getSize().height);
+      const order = node.getOrder() == null ? 'r' : node.getOrder();
+      const text = canvas.text(
         node.getPosition().x + canvas.width / 2,
         node.getPosition().y + canvas.height / 2,
-                node.getId() + '[' + order + ']'
+        `${node.getId()}[${order}]`,
       );
       text.attr('fill', '#FFF');
-            var fillColor = this._rootNodes.contains(node)
+      const fillColor = this._rootNodes.contains(node)
         ? '#000'
         : node.isFree()
           ? '#abc'
           : '#c00';
       rect.attr('fill', fillColor);
 
-            var rectPosition = {
+      const rectPosition = {
         x: rect.attr('x') - canvas.width / 2 + rect.attr('width') / 2,
         y: rect.attr('y') - canvas.height / 2 + rect.attr('height') / 2,
       };
-            var rectSize = { width: rect.attr('width'), height: rect.attr('height') };
-            rect.click(function () {
+      const rectSize = { width: rect.attr('width'), height: rect.attr('height') };
+      rect.click(() => {
         console.log(
-                    '[id:' +
-                        node.getId() +
-                        ', order:' +
-                        node.getOrder() +
-                        ', position:(' +
-                        rectPosition.x +
-                        ',' +
-                        rectPosition.y +
-                        '), size:' +
-                        rectSize.width +
-                        'x' +
-                        rectSize.height +
-                        ', freeDisplacement:(' +
-                        node.getFreeDisplacement().x +
-                        ',' +
-                        node.getFreeDisplacement().y +
-                        ')]'
+          `[id:${
+            node.getId()
+          }, order:${
+            node.getOrder()
+          }, position:(${
+            rectPosition.x
+          },${
+            rectPosition.y
+          }), size:${
+            rectSize.width
+          }x${
+            rectSize.height
+          }, freeDisplacement:(${
+            node.getFreeDisplacement().x
+          },${
+            node.getFreeDisplacement().y
+          })]`,
         );
       });
-            text.click(function () {
+      text.click(() => {
         console.log(
-                    '[id:' +
-                        node.getId() +
-                        ', order:' +
-                        node.getOrder() +
-                        ', position:(' +
-                        rectPosition.x +
-                        ',' +
-                        rectPosition.y +
-                        '), size:' +
-                        rectSize.width +
-                        'x' +
-                        rectSize.height +
-                        ', freeDisplacement:(' +
-                        node.getFreeDisplacement().x +
-                        ',' +
-                        node.getFreeDisplacement().y +
-                        ')]'
+          `[id:${
+            node.getId()
+          }, order:${
+            node.getOrder()
+          }, position:(${
+            rectPosition.x
+          },${
+            rectPosition.y
+          }), size:${
+            rectSize.width
+          }x${
+            rectSize.height
+          }, freeDisplacement:(${
+            node.getFreeDisplacement().x
+          },${
+            node.getFreeDisplacement().y
+          })]`,
         );
       });
 
-            for (var i = 0; i < children.length; i++) {
-                var child = children[i];
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
         this._plot(canvas, child);
       }
     },
@@ -367,16 +365,16 @@ const RootedTreeSet = new Class(
          * @param node
          * @param position
          */
-        updateBranchPosition: function (node, position) {
-            var oldPos = node.getPosition();
+    updateBranchPosition(node, position) {
+      const oldPos = node.getPosition();
       node.setPosition(position);
 
-            var xOffset = oldPos.x - position.x;
-            var yOffset = oldPos.y - position.y;
+      const xOffset = oldPos.x - position.x;
+      const yOffset = oldPos.y - position.y;
 
-            var children = this.getChildren(node);
-            var me = this;
-            _.each(children, function (child) {
+      const children = this.getChildren(node);
+      const me = this;
+      _.each(children, (child) => {
         me.shiftBranchPosition(child, xOffset, yOffset);
       });
     },
@@ -386,13 +384,13 @@ const RootedTreeSet = new Class(
          * @param xOffset
          * @param yOffset
          */
-        shiftBranchPosition: function (node, xOffset, yOffset) {
-            var position = node.getPosition();
+    shiftBranchPosition(node, xOffset, yOffset) {
+      const position = node.getPosition();
       node.setPosition({ x: position.x + xOffset, y: position.y + yOffset });
 
-            var children = this.getChildren(node);
-            var me = this;
-            _.each(children, function (child) {
+      const children = this.getChildren(node);
+      const me = this;
+      _.each(children, (child) => {
         me.shiftBranchPosition(child, xOffset, yOffset);
       });
     },
@@ -402,16 +400,14 @@ const RootedTreeSet = new Class(
          * @param yOffset
          * @return siblings in the offset (vertical) direction, i.e. with lower or higher order, respectively
          */
-        getSiblingsInVerticalDirection: function (node, yOffset) {
+    getSiblingsInVerticalDirection(node, yOffset) {
       // siblings with lower or higher order, depending on the direction of the offset and on the same side as their parent
-            var parent = this.getParent(node);
-            var siblings = this.getSiblings(node).filter(function (sibling) {
-                var sameSide =
-                    node.getPosition().x > parent.getPosition().x
+      const parent = this.getParent(node);
+      const siblings = this.getSiblings(node).filter((sibling) => {
+        const sameSide = node.getPosition().x > parent.getPosition().x
           ? sibling.getPosition().x > parent.getPosition().x
           : sibling.getPosition().x < parent.getPosition().x;
-                var orderOK =
-                    yOffset < 0
+        const orderOK = yOffset < 0
           ? sibling.getOrder() < node.getOrder()
           : sibling.getOrder() > node.getOrder();
         return orderOK && sameSide;
@@ -430,22 +426,20 @@ const RootedTreeSet = new Class(
          * @return branches of the root node on the same side as the given node's, in the given
          * vertical direction
          */
-        getBranchesInVerticalDirection: function (node, yOffset) {
+    getBranchesInVerticalDirection(node, yOffset) {
       // direct descendants of the root that do not contain the node and are on the same side
       // and on the direction of the offset
-            var rootNode = this.getRootNode(node);
-            var branches = this.getChildren(rootNode).filter(function (child) {
+      const rootNode = this.getRootNode(node);
+      const branches = this.getChildren(rootNode).filter(function (child) {
         return this._find(node.getId(), child);
       }, this);
 
-            var branch = branches[0];
-            var rootDescendants = this.getSiblings(branch).filter(function (sibling) {
-                var sameSide =
-                    node.getPosition().x > rootNode.getPosition().x
+      const branch = branches[0];
+      const rootDescendants = this.getSiblings(branch).filter((sibling) => {
+        const sameSide = node.getPosition().x > rootNode.getPosition().x
           ? sibling.getPosition().x > rootNode.getPosition().x
           : sibling.getPosition().x < rootNode.getPosition().x;
-                var sameDirection =
-                    yOffset < 0
+        const sameDirection = yOffset < 0
           ? sibling.getOrder() < branch.getOrder()
           : sibling.getOrder() > branch.getOrder();
         return sameSide && sameDirection;
@@ -453,7 +447,7 @@ const RootedTreeSet = new Class(
 
       return rootDescendants;
     },
-    }
+  },
 );
 
 export default RootedTreeSet;

packages/mindplot/lib/components/layout/SymmetricSorter.js

@@ -24,7 +24,7 @@ const SymmetricSorter = new Class(
          * @constructs
          * @extends mindplot.layout.AbstractBasicSorter
          */
-        initialize: function () {},
+    initialize() {},
 
     /**
          * Predict the order and position of a dragged node.
@@ -36,31 +36,29 @@ const SymmetricSorter = new Class(
          * @param free Free drag or not
          * @return {*}
          */
-        predict: function (graph, parent, node, position, free) {
-            var self = this;
-            var rootNode = graph.getRootNode(parent);
+    predict(graph, parent, node, position, free) {
+      const self = this;
+      const rootNode = graph.getRootNode(parent);
 
       // If its a free node...
       if (free) {
         $assert(
           $defined(position),
-                    'position cannot be null for predict in free positioning'
+          'position cannot be null for predict in free positioning',
         );
         $assert($defined(node), 'node cannot be null for predict in free positioning');
 
-                var direction = this._getRelativeDirection(
+        const direction = this._getRelativeDirection(
           rootNode.getPosition(),
-                    parent.getPosition()
+          parent.getPosition(),
         );
-                var limitXPos =
-                    parent.getPosition().x +
-                    direction *
-                        (parent.getSize().width / 2 +
-                            node.getSize().width / 2 +
-                            SymmetricSorter.INTERNODE_HORIZONTAL_PADDING);
+        const limitXPos = parent.getPosition().x
+                    + direction
+                        * (parent.getSize().width / 2
+                            + node.getSize().width / 2
+                            + SymmetricSorter.INTERNODE_HORIZONTAL_PADDING);
 
-                var xPos =
-                    direction > 0
+        const xPos = direction > 0
           ? position.x >= limitXPos
             ? position.x
             : limitXPos
@@ -73,16 +71,16 @@ const SymmetricSorter = new Class(
 
       // Its not a dragged node (it is being added)
       if (!node) {
-                var parentDirection = self._getRelativeDirection(
+        const parentDirection = self._getRelativeDirection(
           rootNode.getPosition(),
-                    parent.getPosition()
+          parent.getPosition(),
         );
 
         var position = {
           x:
-                        parent.getPosition().x +
-                        parentDirection *
-                            (parent.getSize().width + SymmetricSorter.INTERNODE_HORIZONTAL_PADDING),
+                        parent.getPosition().x
+                        + parentDirection
+                            * (parent.getSize().width + SymmetricSorter.INTERNODE_HORIZONTAL_PADDING),
           y: parent.getPosition().y,
         };
         return [graph.getChildren(parent).length, position];
@@ -90,91 +88,87 @@ const SymmetricSorter = new Class(
 
       // If it is a dragged node...
       $assert($defined(position), 'position cannot be null for predict in dragging');
-            var nodeDirection = this._getRelativeDirection(
+      const nodeDirection = this._getRelativeDirection(
         rootNode.getPosition(),
-                node.getPosition()
+        node.getPosition(),
       );
-            var positionDirection = this._getRelativeDirection(rootNode.getPosition(), position);
-            var siblings = graph.getSiblings(node);
+      const positionDirection = this._getRelativeDirection(rootNode.getPosition(), position);
+      const siblings = graph.getSiblings(node);
 
       // node has no siblings and its trying to reconnect to its own parent
-            var sameParent = parent == graph.getParent(node);
+      const sameParent = parent == graph.getParent(node);
       if (siblings.length == 0 && nodeDirection == positionDirection && sameParent) {
         return [node.getOrder(), node.getPosition()];
       }
 
-            var parentChildren = graph.getChildren(parent);
+      const parentChildren = graph.getChildren(parent);
 
       if (parentChildren.length == 0) {
         // Fit as a child of the parent node...
         var position = {
           x:
-                        parent.getPosition().x +
-                        positionDirection *
-                            (parent.getSize().width + SymmetricSorter.INTERNODE_HORIZONTAL_PADDING),
+                        parent.getPosition().x
+                        + positionDirection
+                            * (parent.getSize().width + SymmetricSorter.INTERNODE_HORIZONTAL_PADDING),
           y: parent.getPosition().y,
         };
         return [0, position];
-            } else {
+      }
       // Try to fit within ...
-                var result = null;
-                var last = parentChildren.getLast();
-                for (var i = 0; i < parentChildren.length; i++) {
-                    var parentChild = parentChildren[i];
-                    var nodeAfter = i + 1 == parentChild.length ? null : parentChildren[i + 1];
+      const result = null;
+      const last = parentChildren.getLast();
+      for (let i = 0; i < parentChildren.length; i++) {
+        const parentChild = parentChildren[i];
+        const nodeAfter = i + 1 == parentChild.length ? null : parentChildren[i + 1];
 
         // Fit at the bottom
         if (!nodeAfter && position.y > parentChild.getPosition().y) {
-                        var order =
-                            graph.getParent(node) && graph.getParent(node).getId() == parent.getId()
+          var order = graph.getParent(node) && graph.getParent(node).getId() == parent.getId()
             ? last.getOrder()
             : last.getOrder() + 1;
           var position = {
             x: parentChild.getPosition().x,
             y:
-                                parentChild.getPosition().y +
-                                parentChild.getSize().height +
-                                SymmetricSorter.INTERNODE_VERTICAL_PADDING * 2,
+                                parentChild.getPosition().y
+                                + parentChild.getSize().height
+                                + SymmetricSorter.INTERNODE_VERTICAL_PADDING * 2,
           };
           return [order, position];
         }
 
         // Fit after this node
         if (
-                        nodeAfter &&
-                        position.y > parentChild.getPosition().y &&
-                        position.y < nodeAfter.getPosition().y
+          nodeAfter
+                        && position.y > parentChild.getPosition().y
+                        && position.y < nodeAfter.getPosition().y
         ) {
           if (
-                            nodeAfter.getId() == node.getId() ||
-                            parentChild.getId() == node.getId()
+            nodeAfter.getId() == node.getId()
+                            || parentChild.getId() == node.getId()
           ) {
             return [node.getOrder(), node.getPosition()];
-                        } else {
-                            var order =
-                                position.y > node.getPosition().y
+          }
+          var order = position.y > node.getPosition().y
             ? nodeAfter.getOrder() - 1
             : parentChild.getOrder() + 1;
           var position = {
             x: parentChild.getPosition().x,
             y:
-                                    parentChild.getPosition().y +
-                                    (nodeAfter.getPosition().y - parentChild.getPosition().y) / 2,
+                                    parentChild.getPosition().y
+                                    + (nodeAfter.getPosition().y - parentChild.getPosition().y) / 2,
           };
           return [order, position];
         }
       }
-                }
-            }
 
       // Position wasn't below any node, so it must be fitted above the first
-            var first = parentChildren[0];
+      const first = parentChildren[0];
       var position = {
         x: first.getPosition().x,
         y:
-                    first.getPosition().y -
-                    first.getSize().height -
-                    SymmetricSorter.INTERNODE_VERTICAL_PADDING * 2,
+                    first.getPosition().y
+                    - first.getSize().height
+                    - SymmetricSorter.INTERNODE_VERTICAL_PADDING * 2,
       };
       return [0, position];
     },
@@ -186,16 +180,16 @@ const SymmetricSorter = new Class(
          * @param order
          * @throws will throw an error if the order is not strictly continuous
          */
-        insert: function (treeSet, parent, child, order) {
-            var children = this._getSortedChildren(treeSet, parent);
+    insert(treeSet, parent, child, order) {
+      const children = this._getSortedChildren(treeSet, parent);
       $assert(
         order <= children.length,
-                'Order must be continues and can not have holes. Order:' + order
+        `Order must be continues and can not have holes. Order:${order}`,
       );
 
       // Shift all the elements in one .
-            for (var i = order; i < children.length; i++) {
-                var node = children[i];
+      for (let i = order; i < children.length; i++) {
+        const node = children[i];
         node.setOrder(i + 1);
       }
       child.setOrder(order);
@@ -205,15 +199,15 @@ const SymmetricSorter = new Class(
          * @param treeSet
          * @param node
          * @throws will throw an error if the node is in the wrong position */
-        detach: function (treeSet, node) {
-            var parent = treeSet.getParent(node);
-            var children = this._getSortedChildren(treeSet, parent);
-            var order = node.getOrder();
+    detach(treeSet, node) {
+      const parent = treeSet.getParent(node);
+      const children = this._getSortedChildren(treeSet, parent);
+      const order = node.getOrder();
       $assert(children[order] === node, 'Node seems not to be in the right position');
 
       // Shift all the nodes ...
-            for (var i = node.getOrder() + 1; i < children.length; i++) {
-                var child = children[i];
+      for (let i = node.getOrder() + 1; i < children.length; i++) {
+        const child = children[i];
         child.setOrder(child.getOrder() - 1);
       }
       node.setOrder(0);
@@ -230,14 +224,14 @@ const SymmetricSorter = new Class(
          * value, is null or undefined
          * @return offsets
          */
-        computeOffsets: function (treeSet, node) {
+    computeOffsets(treeSet, node) {
       $assert(treeSet, 'treeSet can no be null.');
       $assert(node, 'node can no be null.');
 
-            var children = this._getSortedChildren(treeSet, node);
+      const children = this._getSortedChildren(treeSet, node);
 
       // Compute heights ...
-            var heights = children
+      const heights = children
         .map(function (child) {
           return {
             id: child.getId(),
@@ -250,25 +244,24 @@ const SymmetricSorter = new Class(
         .reverse();
 
       // Compute the center of the branch ...
-            var totalHeight = 0;
-            _.each(heights, function (elem) {
+      let totalHeight = 0;
+      _.each(heights, (elem) => {
         totalHeight += elem.height;
       });
-            var ysum = totalHeight / 2;
+      let ysum = totalHeight / 2;
 
       // Calculate the offsets ...
-            var result = {};
-            for (var i = 0; i < heights.length; i++) {
-                ysum = ysum - heights[i].height;
-                var childNode = treeSet.find(heights[i].id);
-                var direction = this.getChildDirection(treeSet, childNode);
+      const result = {};
+      for (let i = 0; i < heights.length; i++) {
+        ysum -= heights[i].height;
+        const childNode = treeSet.find(heights[i].id);
+        const direction = this.getChildDirection(treeSet, childNode);
 
-                var yOffset = ysum + heights[i].height / 2;
-                var xOffset =
-                    direction *
-                    (heights[i].width / 2 +
-                        node.getSize().width / 2 +
-                        SymmetricSorter.INTERNODE_HORIZONTAL_PADDING);
+        const yOffset = ysum + heights[i].height / 2;
+        const xOffset = direction
+                    * (heights[i].width / 2
+                        + node.getSize().width / 2
+                        + SymmetricSorter.INTERNODE_HORIZONTAL_PADDING);
 
         $assert(!isNaN(xOffset), 'xOffset can not be null');
         $assert(!isNaN(yOffset), 'yOffset can not be null');
@@ -283,11 +276,11 @@ const SymmetricSorter = new Class(
          * @param node
          * @throws will throw an error if order elements are missing
          */
-        verify: function (treeSet, node) {
+    verify(treeSet, node) {
       // Check that all is consistent ...
-            var children = this._getSortedChildren(treeSet, node);
+      const children = this._getSortedChildren(treeSet, node);
 
-            for (var i = 0; i < children.length; i++) {
+      for (let i = 0; i < children.length; i++) {
         $assert(children[i].getOrder() == i, 'missing order elements');
       }
     },
@@ -296,34 +289,34 @@ const SymmetricSorter = new Class(
          * @param treeSet
          * @param child
          * @return direction of the given child from its parent or from the root node, if isolated */
-        getChildDirection: function (treeSet, child) {
+    getChildDirection(treeSet, child) {
       $assert(treeSet, 'treeSet can no be null.');
       $assert(treeSet.getParent(child), 'This should not happen');
 
-            var result;
-            var rootNode = treeSet.getRootNode(child);
+      let result;
+      const rootNode = treeSet.getRootNode(child);
       if (treeSet.getParent(child) == rootNode) {
         // This is the case of a isolated child ... In this case, the directions is based on the root.
         result = Math.sign(rootNode.getPosition().x);
       } else {
         // if this is not the case, honor the direction of the parent ...
-                var parent = treeSet.getParent(child);
-                var grandParent = treeSet.getParent(parent);
-                var sorter = grandParent.getSorter();
+        const parent = treeSet.getParent(child);
+        const grandParent = treeSet.getParent(parent);
+        const sorter = grandParent.getSorter();
         result = sorter.getChildDirection(treeSet, parent);
       }
       return result;
     },
 
     /** @return {String} the print name of this class */
-        toString: function () {
+    toString() {
       return 'Symmetric Sorter';
     },
 
-        _getVerticalPadding: function () {
+    _getVerticalPadding() {
       return SymmetricSorter.INTERNODE_VERTICAL_PADDING;
     },
-    }
+  },
 );
 
 /**

packages/mindplot/lib/components/libraries/bootstrap/BootstrapDialog.Request.js

@@ -1,25 +1,25 @@
-const BootstrapDialog = require('./BootstrapDialog').default
+const BootstrapDialog = require('./BootstrapDialog').default;
 
 BootstrapDialog.Request = new Class({
 
   Extends: BootstrapDialog,
 
-    initialize: function(url, title, options) {
+  initialize(url, title, options) {
     this.parent(title, options);
     this.requestOptions = {};
     this.requestOptions.cache = false;
-        var me = this;
+    const me = this;
     this.requestOptions.fail = function (xhr) {
       // Intercept form requests ...
-            console.log("Failure:");
+      console.log('Failure:');
       console.log(xhr);
     };
 
     this.requestOptions.success = function () {
       // Intercept form requests ...
-            var forms = me._native.find('form');
-            _.each(forms, function(form) {
-                $(form).on('submit', function(event) {
+      const forms = me._native.find('form');
+      _.each(forms, (form) => {
+        $(form).on('submit', (event) => {
           // Intercept form ...
           me.requestOptions.url = form.action;
           me.requestOptions.method = form.method ? form.method : 'post';
@@ -30,8 +30,8 @@ BootstrapDialog.Request = new Class({
       });
     };
 
-        this._native.find('.modal-body').load(url, function () {
-            me.acceptButton.unbind('click').click(function () {
+    this._native.find('.modal-body').load(url, () => {
+      me.acceptButton.unbind('click').click(() => {
         submitDialogForm();
       });
       me._native.on('hidden.bs.modal', function () {
@@ -41,11 +41,10 @@ BootstrapDialog.Request = new Class({
     });
   },
 
-    onDialogShown: function() {
-        if (typeof(onDialogShown) == "function") {
+  onDialogShown() {
+    if (typeof (onDialogShown) === 'function') {
       onDialogShown();
     }
-    }
-
+  },
 
 });

packages/mindplot/lib/components/libraries/bootstrap/BootstrapDialog.js

@@ -9,107 +9,107 @@ const BootstrapDialog = new Class({
     acceptButton: true,
     removeButton: false,
     errorMessage: false,
-        onEventData:{}
+    onEventData: {},
   },
 
-    initialize: function (title, options) {
+  initialize(title, options) {
     this.setOptions(options);
     this.options.onEventData.dialog = this;
     this._native = $('<div class="modal fade" tabindex="-1"></div>').append('<div class="modal-dialog"></div>');
-        var content = $('<div class="modal-content"></div>');
-        var header = this._buildHeader(title);
+    const content = $('<div class="modal-content"></div>');
+    const header = this._buildHeader(title);
     if (header) {
       content.append(header);
     }
-        var body = $('<div class="modal-body"></div>');
+    const body = $('<div class="modal-body"></div>');
     if (this.options.errorMessage) {
-            var error = $('<div class="alert alert-danger"></div>');
+      const error = $('<div class="alert alert-danger"></div>');
       error.hide();
       body.append(error);
     }
     content.append(body);
-        var footer = this._buildFooter();
+    const footer = this._buildFooter();
     if (footer) {
       content.append(footer);
     }
-        this._native.find(".modal-dialog").append(content);
+    this._native.find('.modal-dialog').append(content);
     this._native.on('hidden.bs.modal', function () {
       $(this).remove();
     });
     this._native.on('shown.bs.modal', this.onDialogShown);
   },
 
-    _buildFooter: function() {
-        var footer = null;
+  _buildFooter() {
+    let footer = null;
     if (this.options.acceptButton || this.options.removeButton || this.options.cancelButton) {
       footer = $('<div class="modal-footer" style="paddingTop:5;textAlign:center">');
     }
     if (this.options.acceptButton) {
-            this.acceptButton = $('<button type="button" class="btn btn-primary" id="acceptBtn" data-dismiss="modal">'+ $msg('ACCEPT') + '</button>');
+      this.acceptButton = $(`<button type="button" class="btn btn-primary" id="acceptBtn" data-dismiss="modal">${$msg('ACCEPT')}</button>`);
       footer.append(this.acceptButton);
-            this.acceptButton.unbind('click').on("click",this.options.onEventData, this.onAcceptClick)
+      this.acceptButton.unbind('click').on('click', this.options.onEventData, this.onAcceptClick);
     }
     if (this.options.removeButton) {
-            this.removeButton = $('<button type="button" class="btn btn-secondary" id="removeBtn" data-dismiss="modal">'+ $msg('REMOVE') +'</button>');
+      this.removeButton = $(`<button type="button" class="btn btn-secondary" id="removeBtn" data-dismiss="modal">${$msg('REMOVE')}</button>`);
       footer.append(this.removeButton);
       this.removeButton.on('click', this.options.onEventData, this.onRemoveClick);
     }
     if (this.options.cancelButton) {
-            footer.append('<button type="button" class="btn btn-secondary" data-dismiss="modal">'+ $msg('CANCEL') +'</button>');
+      footer.append(`<button type="button" class="btn btn-secondary" data-dismiss="modal">${$msg('CANCEL')}</button>`);
     }
     return footer;
   },
 
-    _buildHeader: function(title) {
-        var header = null;
+  _buildHeader(title) {
+    let header = null;
     if (this.options.closeButton || title) {
       header = $('<div class="modal-header"></div>');
     }
     if (this.options.closeButton) {
       header.append(
-                '<button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>'
+        '<button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>',
       );
     }
     if (title) {
-            header.append('<h2 class="modal-title">' + title + '</h2>');
+      header.append(`<h2 class="modal-title">${title}</h2>`);
     }
     return header;
   },
 
-    onAcceptClick: function(event) {
-        throw "Unsupported operation";
+  onAcceptClick(event) {
+    throw 'Unsupported operation';
   },
 
-    onDialogShown: function() {},
-    onRemoveClick: function(event) {
-        throw "Unsupported operation";
+  onDialogShown() {},
+  onRemoveClick(event) {
+    throw 'Unsupported operation';
   },
 
-    show: function () {
+  show() {
     this._native.modal();
   },
 
-    setContent: function(content) {
-        var modalBody = this._native.find('.modal-body');
+  setContent(content) {
+    const modalBody = this._native.find('.modal-body');
     modalBody.append(content);
   },
 
-    css: function(options){
+  css(options) {
     this._native.find('.modal-dialog').css(options);
   },
 
-    close: function() {
+  close() {
     this._native.modal('hide');
   },
 
-    alertError: function(message){
+  alertError(message) {
     this._native.find('.alert-danger').text(message);
     this._native.find('.alert-danger').show();
   },
 
-    cleanError: function(){
+  cleanError() {
     this._native.find('.alert-danger').hide();
-    }
+  },
 });
 
 export default BootstrapDialog;

packages/mindplot/lib/components/libraries/hotkeys/jquery.hotkeys.js

@@ -16,69 +16,132 @@
  */
 
 (function (jQuery) {
-	
   jQuery.hotkeys = {
-		version: "0.8",
+    version: '0.8',
 
     specialKeys: {
-			8: "backspace", 9: "tab", 10: "return", 13: "enter", 16: "shift", 17: "ctrl", 18: "alt", 19: "pause",
-			20: "capslock", 27: "esc", 32: "space", 33: "pageup", 34: "pagedown", 35: "end", 36: "home",
-			37: "left", 38: "up", 39: "right", 40: "down", 45: "insert", 46: "del", 
-			96: "0", 97: "1", 98: "2", 99: "3", 100: "4", 101: "5", 102: "6", 103: "7",
-			104: "8", 105: "9", 106: "*", 107: "+", 109: "-", 110: ".", 111 : "/", 
-			112: "f1", 113: "f2", 114: "f3", 115: "f4", 116: "f5", 117: "f6", 118: "f7", 119: "f8", 
-			120: "f9", 121: "f10", 122: "f11", 123: "f12", 144: "numlock", 145: "scroll", 186: ";", 191: "/",
-			220: "\\", 222: "'", 224: "meta"
+      8: 'backspace',
+      9: 'tab',
+      10: 'return',
+      13: 'enter',
+      16: 'shift',
+      17: 'ctrl',
+      18: 'alt',
+      19: 'pause',
+      20: 'capslock',
+      27: 'esc',
+      32: 'space',
+      33: 'pageup',
+      34: 'pagedown',
+      35: 'end',
+      36: 'home',
+      37: 'left',
+      38: 'up',
+      39: 'right',
+      40: 'down',
+      45: 'insert',
+      46: 'del',
+      96: '0',
+      97: '1',
+      98: '2',
+      99: '3',
+      100: '4',
+      101: '5',
+      102: '6',
+      103: '7',
+      104: '8',
+      105: '9',
+      106: '*',
+      107: '+',
+      109: '-',
+      110: '.',
+      111: '/',
+      112: 'f1',
+      113: 'f2',
+      114: 'f3',
+      115: 'f4',
+      116: 'f5',
+      117: 'f6',
+      118: 'f7',
+      119: 'f8',
+      120: 'f9',
+      121: 'f10',
+      122: 'f11',
+      123: 'f12',
+      144: 'numlock',
+      145: 'scroll',
+      186: ';',
+      191: '/',
+      220: '\\',
+      222: "'",
+      224: 'meta',
     },
 
     shiftNums: {
-			"`": "~", "1": "!", "2": "@", "3": "#", "4": "$", "5": "%", "6": "^", "7": "&", 
-			"8": "*", "9": "(", "0": ")", "-": "_", "=": "+", ";": ": ", "'": "\"", ",": "<", 
-			".": ">",  "/": "?",  "\\": "|"
-		}
+      '`': '~',
+      1: '!',
+      2: '@',
+      3: '#',
+      4: '$',
+      5: '%',
+      6: '^',
+      7: '&',
+      8: '*',
+      9: '(',
+      0: ')',
+      '-': '_',
+      '=': '+',
+      ';': ': ',
+      "'": '"',
+      ',': '<',
+      '.': '>',
+      '/': '?',
+      '\\': '|',
+    },
   };
 
   function keyHandler(handleObj) {
-		if ( typeof handleObj.data === "string" ) {
+    if (typeof handleObj.data === 'string') {
       handleObj.data = { keys: handleObj.data };
     }
 
     // Only care when a possible input has been specified
-		if ( !handleObj.data || !handleObj.data.keys || typeof handleObj.data.keys !== "string" ) {
+    if (!handleObj.data || !handleObj.data.keys || typeof handleObj.data.keys !== 'string') {
       return;
     }
 
-		var origHandler = handleObj.handler,
-			keys = handleObj.data.keys.toLowerCase().split(" "),
-			textAcceptingInputTypes = ["text", "password", "number", "email", "url", "range", "date", "month", "week", "time", "datetime", "datetime-local", "search", "color", "tel"];
+    const origHandler = handleObj.handler;
+    const keys = handleObj.data.keys.toLowerCase().split(' ');
+    const textAcceptingInputTypes = ['text', 'password', 'number', 'email', 'url', 'range', 'date', 'month', 'week', 'time', 'datetime', 'datetime-local', 'search', 'color', 'tel'];
 
     handleObj.handler = function (event) {
       // Don't fire in text-accepting inputs that we didn't directly bind to
-			if ( this !== event.target && (/textarea|select/i.test( event.target.nodeName ) ||
-				jQuery.inArray(event.target.type, textAcceptingInputTypes) > -1 ) ) {
+      if (this !== event.target && (/textarea|select/i.test(event.target.nodeName)
+				|| jQuery.inArray(event.target.type, textAcceptingInputTypes) > -1)) {
         return;
       }
 
-			var special = jQuery.hotkeys.specialKeys[ event.keyCode ],
-				character = String.fromCharCode( event.which ).toLowerCase(),
-				modif = "", possible = {};
+      const special = jQuery.hotkeys.specialKeys[event.keyCode];
+      const character = String.fromCharCode(event.which).toLowerCase();
+      let modif = ''; const
+        possible = {};
 
       // check combinations (alt|ctrl|shift+anything)
-			if ( event.altKey && special !== "alt" ) {
-				modif += "alt+";
+      if (event.altKey && special !== 'alt') {
+        modif += 'alt+';
       }
 
-			if ( event.ctrlKey && special !== "ctrl" ) {
-				modif += "ctrl+";
+      if (event.ctrlKey && special !== 'ctrl') {
+        modif += 'ctrl+';
       }
 
       // TODO: Need to make sure this works consistently across platforms
-			if ( event.metaKey && !event.ctrlKey && special !== "meta" ) {
-				modif += "meta+";
+      if (event.metaKey && !event.ctrlKey && special !== 'meta') {
+        modif += 'meta+';
       }
 
-			if ( event.shiftKey && special !== "shift" ) {
-				modif += "shift+";
+      if (event.shiftKey && special !== 'shift') {
+        modif += 'shift+';
       }
 
       if (special) {
@@ -90,12 +153,12 @@
         possible[modif + jQuery.hotkeys.shiftNums[character]] = true;
 
         // "$" can be triggered as "Shift+4" or "Shift+$" or just "$"
-				if ( modif === "shift+" ) {
+        if (modif === 'shift+') {
           possible[jQuery.hotkeys.shiftNums[character]] = true;
         }
       }
 
-			for ( var i = 0, l = keys.length; i < l; i++ ) {
+      for (let i = 0, l = keys.length; i < l; i++) {
         if (possible[keys[i]]) {
           return origHandler.apply(this, arguments);
         }
@@ -103,8 +166,7 @@
     };
   }
 
-	jQuery.each([ "keydown", "keyup", "keypress" ], function() {
+  jQuery.each(['keydown', 'keyup', 'keypress'], function () {
     jQuery.event.special[this] = { add: keyHandler };
   });
-
-})( this.jQuery );
+}(this.jQuery));

packages/mindplot/lib/components/libraries/jquery/jquery.mousewheel.min.js

@@ -5,4 +5,8 @@
  *
  * Requires: jQuery 1.2.2+
  */
-!function(a){"function"==typeof define&&define.amd?define(["jquery"],a):"object"==typeof exports?module.exports=a:a(jQuery)}(function(a){function b(b){var g=b||window.event,h=i.call(arguments,1),j=0,l=0,m=0,n=0,o=0,p=0;if(b=a.event.fix(g),b.type="mousewheel","detail"in g&&(m=-1*g.detail),"wheelDelta"in g&&(m=g.wheelDelta),"wheelDeltaY"in g&&(m=g.wheelDeltaY),"wheelDeltaX"in g&&(l=-1*g.wheelDeltaX),"axis"in g&&g.axis===g.HORIZONTAL_AXIS&&(l=-1*m,m=0),j=0===m?l:m,"deltaY"in g&&(m=-1*g.deltaY,j=m),"deltaX"in g&&(l=g.deltaX,0===m&&(j=-1*l)),0!==m||0!==l){if(1===g.deltaMode){var q=a.data(this,"mousewheel-line-height");j*=q,m*=q,l*=q}else if(2===g.deltaMode){var r=a.data(this,"mousewheel-page-height");j*=r,m*=r,l*=r}if(n=Math.max(Math.abs(m),Math.abs(l)),(!f||f>n)&&(f=n,d(g,n)&&(f/=40)),d(g,n)&&(j/=40,l/=40,m/=40),j=Math[j>=1?"floor":"ceil"](j/f),l=Math[l>=1?"floor":"ceil"](l/f),m=Math[m>=1?"floor":"ceil"](m/f),k.settings.normalizeOffset&&this.getBoundingClientRect){var s=this.getBoundingClientRect();o=b.clientX-s.left,p=b.clientY-s.top}return b.deltaX=l,b.deltaY=m,b.deltaFactor=f,b.offsetX=o,b.offsetY=p,b.deltaMode=0,h.unshift(b,j,l,m),e&&clearTimeout(e),e=setTimeout(c,200),(a.event.dispatch||a.event.handle).apply(this,h)}}function c(){f=null}function d(a,b){return k.settings.adjustOldDeltas&&"mousewheel"===a.type&&b%120===0}var e,f,g=["wheel","mousewheel","DOMMouseScroll","MozMousePixelScroll"],h="onwheel"in document||document.documentMode>=9?["wheel"]:["mousewheel","DomMouseScroll","MozMousePixelScroll"],i=Array.prototype.slice;if(a.event.fixHooks)for(var j=g.length;j;)a.event.fixHooks[g[--j]]=a.event.mouseHooks;var k=a.event.special.mousewheel={version:"3.1.11",setup:function(){if(this.addEventListener)for(var c=h.length;c;)this.addEventListener(h[--c],b,!1);else this.onmousewheel=b;a.data(this,"mousewheel-line-height",k.getLineHeight(this)),a.data(this,"mousewheel-page-height",k.getPageHeight(this))},teardown:function(){if(this.removeEventListener)for(var c=h.length;c;)this.removeEventListener(h[--c],b,!1);else this.onmousewheel=null;a.removeData(this,"mousewheel-line-height"),a.removeData(this,"mousewheel-page-height")},getLineHeight:function(b){var c=a(b)["offsetParent"in a.fn?"offsetParent":"parent"]();return c.length||(c=a("body")),parseInt(c.css("fontSize"),10)},getPageHeight:function(b){return a(b).height()},settings:{adjustOldDeltas:!0,normalizeOffset:!0}};a.fn.extend({mousewheel:function(a){return a?this.bind("mousewheel",a):this.trigger("mousewheel")},unmousewheel:function(a){return this.unbind("mousewheel",a)}})});
+!(function (a) { typeof define === 'function' && define.amd ? define(['jquery'], a) : typeof exports === 'object' ? module.exports = a : a(jQuery); }((a) => {
+  function b(b) { const g = b || window.event; const h = i.call(arguments, 1); let j = 0; let l = 0; let m = 0; let n = 0; let o = 0; let p = 0; if (b = a.event.fix(g), b.type = 'mousewheel', 'detail' in g && (m = -1 * g.detail), 'wheelDelta' in g && (m = g.wheelDelta), 'wheelDeltaY' in g && (m = g.wheelDeltaY), 'wheelDeltaX' in g && (l = -1 * g.wheelDeltaX), 'axis' in g && g.axis === g.HORIZONTAL_AXIS && (l = -1 * m, m = 0), j = m === 0 ? l : m, 'deltaY' in g && (m = -1 * g.deltaY, j = m), 'deltaX' in g && (l = g.deltaX, m === 0 && (j = -1 * l)), m !== 0 || l !== 0) { if (g.deltaMode === 1) { const q = a.data(this, 'mousewheel-line-height'); j *= q, m *= q, l *= q; } else if (g.deltaMode === 2) { const r = a.data(this, 'mousewheel-page-height'); j *= r, m *= r, l *= r; } if (n = Math.max(Math.abs(m), Math.abs(l)), (!f || f > n) && (f = n, d(g, n) && (f /= 40)), d(g, n) && (j /= 40, l /= 40, m /= 40), j = Math[j >= 1 ? 'floor' : 'ceil'](j / f), l = Math[l >= 1 ? 'floor' : 'ceil'](l / f), m = Math[m >= 1 ? 'floor' : 'ceil'](m / f), k.settings.normalizeOffset && this.getBoundingClientRect) { const s = this.getBoundingClientRect(); o = b.clientX - s.left, p = b.clientY - s.top; } return b.deltaX = l, b.deltaY = m, b.deltaFactor = f, b.offsetX = o, b.offsetY = p, b.deltaMode = 0, h.unshift(b, j, l, m), e && clearTimeout(e), e = setTimeout(c, 200), (a.event.dispatch || a.event.handle).apply(this, h); } } function c() { f = null; } function d(a, b) { return k.settings.adjustOldDeltas && a.type === 'mousewheel' && b % 120 === 0; } let e; let f; const g = ['wheel', 'mousewheel', 'DOMMouseScroll', 'MozMousePixelScroll']; const h = 'onwheel' in document || document.documentMode >= 9 ? ['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll']; var i = Array.prototype.slice; if (a.event.fixHooks) for (let j = g.length; j;)a.event.fixHooks[g[--j]] = a.event.mouseHooks; var k = a.event.special.mousewheel = {
+    version: '3.1.11', setup() { if (this.addEventListener) for (let c = h.length; c;) this.addEventListener(h[--c], b, !1); else this.onmousewheel = b; a.data(this, 'mousewheel-line-height', k.getLineHeight(this)), a.data(this, 'mousewheel-page-height', k.getPageHeight(this)); }, teardown() { if (this.removeEventListener) for (let c = h.length; c;) this.removeEventListener(h[--c], b, !1); else this.onmousewheel = null; a.removeData(this, 'mousewheel-line-height'), a.removeData(this, 'mousewheel-page-height'); }, getLineHeight(b) { let c = a(b)['offsetParent' in a.fn ? 'offsetParent' : 'parent'](); return c.length || (c = a('body')), parseInt(c.css('fontSize'), 10); }, getPageHeight(b) { return a(b).height(); }, settings: { adjustOldDeltas: !0, normalizeOffset: !0 },
+  }; a.fn.extend({ mousewheel(a) { return a ? this.bind('mousewheel', a) : this.trigger('mousewheel'); }, unmousewheel(a) { return this.unbind('mousewheel', a); } });
+}));

packages/mindplot/lib/components/libraries/mootools/mootools-core-1.4.5-full-nocompat-yc.js

@@ -17,29 +17,27 @@
  */
 
 (function () {
-    this.MooTools = {version: "1.4.5", build: "ab8ea8824dc3b24b6666867a2c4ed58ebb762cf0"};
-    var o = this.typeOf = function (i) {
+  this.MooTools = { version: '1.4.5', build: 'ab8ea8824dc3b24b6666867a2c4ed58ebb762cf0' };
+  const o = this.typeOf = function (i) {
     if (i == null) {
-            return "null";
+      return 'null';
     }
     if (i.$family != null) {
       return i.$family();
     }
     if (i.nodeName) {
       if (i.nodeType == 1) {
-                return "element";
+        return 'element';
       }
       if (i.nodeType == 3) {
-                return (/\S/).test(i.nodeValue) ? "textnode" : "whitespace";
+        return (/\S/).test(i.nodeValue) ? 'textnode' : 'whitespace';
       }
-        } else {
-            if (typeof i.length == "number") {
+    } else if (typeof i.length === 'number') {
       if (i.callee) {
-                    return "arguments";
-                }
-                if ("item" in i) {
-                    return "collection";
+        return 'arguments';
       }
+      if ('item' in i) {
+        return 'collection';
       }
     }
     return typeof i;
@@ -48,7 +46,7 @@
     if (t == null) {
       return false;
     }
-        var s = t.$constructor || t.constructor;
+    let s = t.$constructor || t.constructor;
     while (s) {
       if (s === i) {
         return true;
@@ -60,26 +58,26 @@
     }
     return t instanceof i;
   };
-    var f = this.Function;
-    var p = true;
-    for (var k in {toString: 1}) {
+  const f = this.Function;
+  let p = true;
+  for (const k in { toString: 1 }) {
     p = null;
   }
   if (p) {
-        p = ["hasOwnProperty", "valueOf", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "constructor"];
+    p = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'constructor'];
   }
   f.prototype.overloadSetter = function (s) {
-        var i = this;
+    const i = this;
     return function (u, t) {
       if (u == null) {
         return this;
       }
-            if (s || typeof u != "string") {
+      if (s || typeof u !== 'string') {
         for (var v in u) {
           i.call(this, v, u[v]);
         }
         if (p) {
-                    for (var w = p.length; w--;) {
+          for (let w = p.length; w--;) {
             v = p[w];
             if (u.hasOwnProperty(v)) {
               i.call(this, v, u[v]);
@@ -98,29 +96,30 @@
   f.prototype.implement = function (i, s) {
     this.prototype[i] = s;
   }.overloadSetter();
-    var n = Array.prototype.slice;
+  const n = Array.prototype.slice;
   Array.from = function (i) {
     if (i == null) {
       return [];
     }
-        return (a.isEnumerable(i) && typeof i != "string") ? (o(i) == "array") ? i : n.call(i) : [i];
+    return (a.isEnumerable(i) && typeof i !== 'string') ? (o(i) == 'array') ? i : n.call(i) : [i];
   };
   f.implement({
-        hide: function () {
+    hide() {
       this.$hidden = true;
       return this;
-        }, protect: function () {
+    },
+    protect() {
       this.$protected = true;
       return this;
-        }
+    },
   });
   var a = this.Type = function (u, t) {
     if (u) {
-            var s = u.toLowerCase();
-            var i = function (v) {
+      const s = u.toLowerCase();
+      const i = function (v) {
         return (o(v) == s);
       };
-            a["is" + u] = i;
+      a[`is${u}`] = i;
       if (t != null) {
         t.prototype.$family = (function () {
           return s;
@@ -135,34 +134,34 @@
     t.prototype.$constructor = t;
     return t;
   };
-    var e = Object.prototype.toString;
+  const e = Object.prototype.toString;
   a.isEnumerable = function (i) {
-        return (i != null && typeof i.length == "number" && e.call(i) != "[object Function]");
+    return (i != null && typeof i.length === 'number' && e.call(i) != '[object Function]');
   };
-    var q = {};
-    var r = function (i) {
-        var s = o(i.prototype);
+  const q = {};
+  const r = function (i) {
+    const s = o(i.prototype);
     return q[s] || (q[s] = []);
   };
   var b = function (t, x) {
     if (x && x.$hidden) {
       return;
     }
-        var s = r(this);
-        for (var u = 0; u < s.length;
+    const s = r(this);
+    for (let u = 0; u < s.length;
       u++) {
-            var w = s[u];
-            if (o(w) == "type") {
+      const w = s[u];
+      if (o(w) == 'type') {
         b.call(w, t, x);
       } else {
         w.call(this, t, x);
       }
     }
-        var v = this.prototype[t];
+    const v = this.prototype[t];
     if (v == null || !v.$protected) {
       this.prototype[t] = x;
     }
-        if (this[t] == null && o(x) == "function") {
+    if (this[t] == null && o(x) == 'function') {
       m.call(this, t, function (i) {
         return x.apply(i, n.call(arguments, 1));
       });
@@ -172,27 +171,32 @@
     if (t && t.$hidden) {
       return;
     }
-        var s = this[i];
+    const s = this[i];
     if (s == null || !s.$protected) {
       this[i] = t;
     }
   };
   a.implement({
-        implement: b.overloadSetter(), extend: m.overloadSetter(), alias: function (i, s) {
+    implement: b.overloadSetter(),
+    extend: m.overloadSetter(),
+    alias: function (i, s) {
       b.call(this, i, this.prototype[s]);
-        }.overloadSetter(), mirror: function (i) {
+    }.overloadSetter(),
+    mirror(i) {
       r(this).push(i);
       return this;
-        }
+    },
   });
-    new a("Type", a);
+  new a('Type', a);
   var d = function (s, x, v) {
-        var u = (x != Object), B = x.prototype;
+    const u = (x != Object); const
+      B = x.prototype;
     if (u) {
       x = new a(s, x);
     }
-        for (var y = 0, w = v.length; y < w; y++) {
-            var C = v[y], A = x[C], z = B[C];
+    for (let y = 0, w = v.length; y < w; y++) {
+      const C = v[y]; const A = x[C]; const
+        z = B[C];
       if (A) {
         A.protect();
       }
@@ -201,35 +205,31 @@
       }
     }
     if (u) {
-            var t = B.propertyIsEnumerable(v[0]);
+      const t = B.propertyIsEnumerable(v[0]);
       x.forEachMethod = function (G) {
         if (!t) {
-                    for (var F = 0, D = v.length; F < D; F++) {
+          for (let F = 0, D = v.length; F < D; F++) {
             G.call(B, B[v[F]], v[F]);
           }
         }
-                for (var E in B) {
+        for (const E in B) {
           G.call(B, B[E], E);
         }
       };
     }
     return d;
   };
-    d("String", String, ["charAt", "charCodeAt", "concat", "indexOf", "lastIndexOf", "match", "quote", "replace", "search", "slice", "split", "substr", "substring", "trim", "toLowerCase", "toUpperCase"])("Array", Array, ["pop", "push", "reverse", "shift", "sort", "splice", "unshift", "concat", "join", "slice", "indexOf", "lastIndexOf", "filter", "forEach", "every", "map", "some", "reduce", "reduceRight"])("Number", Number, ["toExponential", "toFixed", "toLocaleString", "toPrecision"])("Function", f, ["apply", "call", "bind"])("RegExp", RegExp, ["exec", "test"])("Object", Object, ["create", "defineProperty", "defineProperties", "keys", "getPrototypeOf", "getOwnPropertyDescriptor", "getOwnPropertyNames", "preventExtensions", "isExtensible", "seal", "isSealed", "freeze", "isFrozen"])("Date", Date, ["now"]);
+  d('String', String, ['charAt', 'charCodeAt', 'concat', 'indexOf', 'lastIndexOf', 'match', 'quote', 'replace', 'search', 'slice', 'split', 'substr', 'substring', 'trim', 'toLowerCase', 'toUpperCase'])('Array', Array, ['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift', 'concat', 'join', 'slice', 'indexOf', 'lastIndexOf', 'filter', 'forEach', 'every', 'map', 'some', 'reduce', 'reduceRight'])('Number', Number, ['toExponential', 'toFixed', 'toLocaleString', 'toPrecision'])('Function', f, ['apply', 'call', 'bind'])('RegExp', RegExp, ['exec', 'test'])('Object', Object, ['create', 'defineProperty', 'defineProperties', 'keys', 'getPrototypeOf', 'getOwnPropertyDescriptor', 'getOwnPropertyNames', 'preventExtensions', 'isExtensible', 'seal', 'isSealed', 'freeze', 'isFrozen'])('Date', Date, ['now']);
   Object.extend = m.overloadSetter();
-    Date.extend("now", function () {
-        return +(new Date);
-    });
-    new a("Boolean", Boolean);
+  Date.extend('now', () => +(new Date()));
+  new a('Boolean', Boolean);
   Number.prototype.$family = function () {
-        return isFinite(this) ? "number" : "null";
+    return isFinite(this) ? 'number' : 'null';
   }.hide();
-    Number.extend("random", function (s, i) {
-        return Math.floor(Math.random() * (i - s + 1) + s);
-    });
-    var g = Object.prototype.hasOwnProperty;
-    Object.extend("forEach", function (i, t, u) {
-        for (var s in i) {
+  Number.extend('random', (s, i) => Math.floor(Math.random() * (i - s + 1) + s));
+  const g = Object.prototype.hasOwnProperty;
+  Object.extend('forEach', (i, t, u) => {
+    for (const s in i) {
       if (g.call(i, s)) {
         t.call(u, i[s], s, i);
       }
@@ -237,44 +237,46 @@
   });
   Object.each = Object.forEach;
   Array.implement({
-        forEach: function (u, v) {
-            for (var t = 0, s = this.length; t < s; t++) {
+    forEach(u, v) {
+      for (let t = 0, s = this.length; t < s; t++) {
         if (t in this) {
           u.call(v, this[t], t, this);
         }
       }
-        }, each: function (i, s) {
+    },
+    each(i, s) {
       Array.forEach(this, i, s);
       return this;
-        }
+    },
   });
-    var l = function (i) {
+  const l = function (i) {
     switch (o(i)) {
-            case"array":
+      case 'array':
         return i.clone();
-            case"object":
+      case 'object':
         return Object.clone(i);
       default:
         return i;
     }
   };
-    Array.implement("clone", function () {
-        var s = this.length, t = new Array(s);
+  Array.implement('clone', function () {
+    let s = this.length; const
+      t = new Array(s);
     while (s--) {
       t[s] = l(this[s]);
     }
     return t;
   });
-    var h = function (s, i, t) {
+  const h = function (s, i, t) {
     switch (o(t)) {
-            case"object":
-                if (o(s[i]) == "object") {
+      case 'object':
+        if (o(s[i]) == 'object') {
           Object.merge(s[i], t);
         } else {
           s[i] = Object.clone(t);
         }
         break;
-            case"array":
+      case 'array':
         s[i] = t.clone();
         break;
       default:
@@ -283,47 +285,47 @@
     return s;
   };
   Object.extend({
-        merge: function (z, u, t) {
-            if (o(u) == "string") {
+    merge(z, u, t) {
+      if (o(u) == 'string') {
         return h(z, u, t);
       }
-            for (var y = 1, s = arguments.length;
+      for (let y = 1, s = arguments.length;
         y < s; y++) {
-                var w = arguments[y];
-                for (var x in w) {
+        const w = arguments[y];
+        for (const x in w) {
           h(z, x, w[x]);
         }
       }
       return z;
-        }, clone: function (i) {
-            var t = {};
-            for (var s in i) {
+    },
+    clone(i) {
+      const t = {};
+      for (const s in i) {
         t[s] = l(i[s]);
       }
       return t;
-        }, append: function (w) {
-            for (var v = 1, t = arguments.length;
+    },
+    append(w) {
+      for (let v = 1, t = arguments.length;
         v < t; v++) {
-                var s = arguments[v] || {};
-                for (var u in s) {
+        const s = arguments[v] || {};
+        for (const u in s) {
           w[u] = s[u];
         }
       }
       return w;
-        }
+    },
   });
-    ["Object", "WhiteSpace", "TextNode", "Collection", "Arguments"].each(function (i) {
+  ['Object', 'WhiteSpace', 'TextNode', 'Collection', 'Arguments'].each((i) => {
     new a(i);
   });
-    var c = Date.now();
-    String.extend("uniqueID", function () {
-        return (c++).toString(36);
-    });
-})();
+  let c = Date.now();
+  String.extend('uniqueID', () => (c++).toString(36));
+}());
 
 Array.implement({
-    filter: function (d, f) {
-        var c = [];
+  filter(d, f) {
+    const c = [];
     for (var e, b = 0, a = this.length >>> 0; b < a; b++) {
       if (b in this) {
         e = this[b];
@@ -333,133 +335,150 @@ Array.implement({
       }
     }
     return c;
-    }, indexOf: function (c, d) {
-        var b = this.length >>> 0;
-        for (var a = (d < 0) ? Math.max(0, b + d) : d || 0; a < b; a++) {
+  },
+  indexOf(c, d) {
+    const b = this.length >>> 0;
+    for (let a = (d < 0) ? Math.max(0, b + d) : d || 0; a < b; a++) {
       if (this[a] === c) {
         return a;
       }
     }
     return -1;
-    }, map: function (c, e) {
-        var d = this.length >>> 0, b = Array(d);
-        for (var a = 0; a < d; a++) {
+  },
+  map(c, e) {
+    const d = this.length >>> 0; const
+      b = Array(d);
+    for (let a = 0; a < d; a++) {
       if (a in this) {
         b[a] = c.call(e, this[a], a, this);
       }
     }
     return b;
-    }, some: function (c, d) {
-        for (var b = 0, a = this.length >>> 0;
+  },
+  some(c, d) {
+    for (let b = 0, a = this.length >>> 0;
       b < a; b++) {
       if ((b in this) && c.call(d, this[b], b, this)) {
         return true;
       }
     }
     return false;
-    }, clean: function () {
-        return this.filter(function (a) {
-            return a != null;
-        });
-    }, contains: function (a, b) {
+  },
+  clean() {
+    return this.filter((a) => a != null);
+  },
+  contains(a, b) {
     return this.indexOf(a, b) != -1;
-    }, append: function (a) {
+  },
+  append(a) {
     this.push.apply(this, a);
     return this;
-    }, getLast: function () {
+  },
+  getLast() {
     return (this.length) ? this[this.length - 1] : null;
-    }, include: function (a) {
+  },
+  include(a) {
     if (!this.contains(a)) {
       this.push(a);
     }
     return this;
-    }, erase: function (b) {
-        for (var a = this.length; a--;) {
+  },
+  erase(b) {
+    for (let a = this.length; a--;) {
       if (this[a] === b) {
         this.splice(a, 1);
       }
     }
     return this;
-    }, empty: function () {
+  },
+  empty() {
     this.length = 0;
     return this;
-    }, flatten: function () {
-        var d = [];
-        for (var b = 0, a = this.length; b < a; b++) {
-            var c = typeOf(this[b]);
-            if (c == "null") {
+  },
+  flatten() {
+    let d = [];
+    for (let b = 0, a = this.length; b < a; b++) {
+      const c = typeOf(this[b]);
+      if (c == 'null') {
         continue;
       }
-            d = d.concat((c == "array" || c == "collection" || c == "arguments" || instanceOf(this[b], Array)) ? Array.flatten(this[b]) : this[b]);
+      d = d.concat((c == 'array' || c == 'collection' || c == 'arguments' || instanceOf(this[b], Array)) ? Array.flatten(this[b]) : this[b]);
     }
     return d;
-    }, pick: function () {
-        for (var b = 0, a = this.length; b < a; b++) {
+  },
+  pick() {
+    for (let b = 0, a = this.length; b < a; b++) {
       if (this[b] != null) {
         return this[b];
       }
     }
     return null;
-    }, rgbToHex: function (d) {
+  },
+  rgbToHex(d) {
     if (this.length < 3) {
       return null;
     }
     if (this.length == 4 && this[3] == 0 && !d) {
-            return "transparent";
+      return 'transparent';
     }
-        var b = [];
-        for (var a = 0; a < 3; a++) {
-            var c = (this[a] - 0).toString(16);
-            b.push((c.length == 1) ? "0" + c : c);
-        }
-        return (d) ? b : "#" + b.join("");
+    const b = [];
+    for (let a = 0; a < 3; a++) {
+      const c = (this[a] - 0).toString(16);
+      b.push((c.length == 1) ? `0${c}` : c);
     }
+    return (d) ? b : `#${b.join('')}`;
+  },
 });
 String.implement({
-    test: function (a, b) {
-        return ((typeOf(a) == "regexp") ? a : new RegExp("" + a, b)).test(this);
-    }, contains: function (a, b) {
+  test(a, b) {
+    return ((typeOf(a) == 'regexp') ? a : new RegExp(`${a}`, b)).test(this);
+  },
+  contains(a, b) {
     return (b) ? (b + this + b).indexOf(b + a + b) > -1 : String(this).indexOf(a) > -1;
-    }, capitalize: function () {
-        return String(this).replace(/\b[a-z]/g, function (a) {
-            return a.toUpperCase();
-        });
-    }, rgbToHex: function (b) {
-        var a = String(this).match(/\d{1,3}/g);
+  },
+  capitalize() {
+    return String(this).replace(/\b[a-z]/g, (a) => a.toUpperCase());
+  },
+  rgbToHex(b) {
+    const a = String(this).match(/\d{1,3}/g);
     return (a) ? a.rgbToHex(b) : null;
-    }
+  },
 });
 Function.implement({
-    bind: function (e) {
-        var a = this, b = arguments.length > 1 ? Array.slice(arguments, 1) : null, d = function () {
+  bind(e) {
+    const a = this; const b = arguments.length > 1 ? Array.slice(arguments, 1) : null; const
+      d = function () {
       };
     var c = function () {
-            var g = e, h = arguments.length;
+      let g = e; const
+        h = arguments.length;
       if (this instanceof c) {
         d.prototype = a.prototype;
-                g = new d;
+        g = new d();
       }
-            var f = (!b && !h) ? a.call(g) : a.apply(g, b && h ? b.concat(Array.slice(arguments)) : b || arguments);
+      const f = (!b && !h) ? a.call(g) : a.apply(g, b && h ? b.concat(Array.slice(arguments)) : b || arguments);
       return g == e ? f : g;
     };
     return c;
-    }, pass: function (b, c) {
-        var a = this;
+  },
+  pass(b, c) {
+    const a = this;
     if (b != null) {
       b = Array.from(b);
     }
     return function () {
       return a.apply(c, b || arguments);
     };
-    }, delay: function (b, c, a) {
+  },
+  delay(b, c, a) {
     return setTimeout(this.pass((a == null ? [] : a), c), b);
-    }
+  },
 });
 
-Number.alias("each", "times");
+Number.alias('each', 'times');
 (function (b) {
-    var a = {};
-    b.each(function (c) {
+  const a = {};
+  b.each((c) => {
     if (!Number[c]) {
       a[c] = function () {
         return Math[c].apply(null, [this].concat(Array.from(arguments)));
@@ -467,10 +486,10 @@ Number.alias("each", "times");
     }
   });
   Number.implement(a);
-})(["abs", "acos", "asin", "atan", "atan2", "ceil", "cos", "exp", "floor", "log", "max", "min", "pow", "sin", "sqrt", "tan"]);
+}(['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp', 'floor', 'log', 'max', 'min', 'pow', 'sin', 'sqrt', 'tan']));
 
 (function () {
-    var a = this.Class = new Type("Class", function (h) {
+  var a = this.Class = new Type('Class', function (h) {
     if (instanceOf(h, Function)) {
       h = { initialize: h };
     }
@@ -480,7 +499,7 @@ Number.alias("each", "times");
         return this;
       }
       this.$caller = null;
-            var i = (this.initialize) ? this.initialize.apply(this, arguments) : this;
+      const i = (this.initialize) ? this.initialize.apply(this, arguments) : this;
       this.$caller = this.caller = null;
       return i;
     }.extend(this).implement(h);
@@ -493,55 +512,57 @@ Number.alias("each", "times");
     if (!this.$caller) {
       throw new Error('The method "parent" cannot be called.');
     }
-        var g = this.$caller.$name, h = this.$caller.$owner.parent, i = (h) ? h.prototype[g] : null;
+    const g = this.$caller.$name; const h = this.$caller.$owner.parent; const
+      i = (h) ? h.prototype[g] : null;
     if (!i) {
-            throw new Error('The method "' + g + '" has no parent.');
+      throw new Error(`The method "${g}" has no parent.`);
     }
     return i.apply(this, arguments);
   };
   var e = function (g) {
-        for (var h in g) {
-            var j = g[h];
+    for (const h in g) {
+      const j = g[h];
       switch (typeOf(j)) {
-                case"object":
+        case 'object':
           var i = function () {
           };
           i.prototype = j;
-                    g[h] = e(new i);
+          g[h] = e(new i());
           break;
-                case"array":
+        case 'array':
           g[h] = j.clone();
           break;
       }
     }
     return g;
   };
-    var b = function (g, h, j) {
+  const b = function (g, h, j) {
     if (j.$origin) {
       j = j.$origin;
     }
     var i = function () {
       if (j.$protected && this.$caller == null) {
-                throw new Error('The method "' + h + '" cannot be called.');
+        throw new Error(`The method "${h}" cannot be called.`);
       }
-            var l = this.caller, m = this.$caller;
+      const l = this.caller; const
+        m = this.$caller;
       this.caller = m;
       this.$caller = i;
-            var k = j.apply(this, arguments);
+      const k = j.apply(this, arguments);
       this.$caller = m;
       this.caller = l;
       return k;
     }.extend({ $owner: g, $origin: j, $name: h });
     return i;
   };
-    var f = function (h, i, g) {
+  const f = function (h, i, g) {
     if (a.Mutators.hasOwnProperty(h)) {
       i = a.Mutators[h].call(this, i);
       if (i == null) {
         return this;
       }
     }
-        if (typeOf(i) == "function") {
+    if (typeOf(i) == 'function') {
       if (i.$hidden) {
         return this;
       }
@@ -551,24 +572,25 @@ Number.alias("each", "times");
     }
     return this;
   };
-    var d = function (g) {
+  const d = function (g) {
     g.$prototyping = true;
-        var h = new g;
+    const h = new g();
     delete g.$prototyping;
     return h;
   };
-    a.implement("implement", f.overloadSetter());
+  a.implement('implement', f.overloadSetter());
   a.Mutators = {
-        Extends: function (g) {
+    Extends(g) {
       this.parent = g;
       this.prototype = d(g);
-        }, Implements: function (g) {
+    },
+    Implements(g) {
       Array.from(g).each(function (j) {
-                var h = new j;
-                for (var i in h) {
+        const h = new j();
+        for (const i in h) {
           f.call(this, i, h[i], true);
         }
       }, this);
-        }
+    },
   };
-})();
+}());

packages/mindplot/lib/components/libraries/mootools/mootools-core-1.4.5.js

@@ -16,61 +16,256 @@
  ...
  */
 
-(function(){this.MooTools={version:"1.4.5",build:"ab8ea8824dc3b24b6666867a2c4ed58ebb762cf0"};var o=this.typeOf=function(i){if(i==null){return"null";}if(i.$family!=null){return i.$family();
-}if(i.nodeName){if(i.nodeType==1){return"element";}if(i.nodeType==3){return(/\S/).test(i.nodeValue)?"textnode":"whitespace";}}else{if(typeof i.length=="number"){if(i.callee){return"arguments";
-}if("item" in i){return"collection";}}}return typeof i;};var j=this.instanceOf=function(t,i){if(t==null){return false;}var s=t.$constructor||t.constructor;
-    while(s){if(s===i){return true;}s=s.parent;}if(!t.hasOwnProperty){return false;}return t instanceof i;};var f=this.Function;var p=true;for(var k in {toString:1}){p=null;
-}if(p){p=["hasOwnProperty","valueOf","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","constructor"];}f.prototype.overloadSetter=function(s){var i=this;
-    return function(u,t){if(u==null){return this;}if(s||typeof u!="string"){for(var v in u){i.call(this,v,u[v]);}if(p){for(var w=p.length;w--;){v=p[w];if(u.hasOwnProperty(v)){i.call(this,v,u[v]);
-    }}}}else{i.call(this,u,t);}return this;};};f.prototype.overloadGetter=function(s){var i=this;return function(u){var v,t;if(typeof u!="string"){v=u;}else{if(arguments.length>1){v=arguments;
-}else{if(s){v=[u];}}}if(v){t={};for(var w=0;w<v.length;w++){t[v[w]]=i.call(this,v[w]);}}else{t=i.call(this,u);}return t;};};f.prototype.extend=function(i,s){this[i]=s;
-}.overloadSetter();f.prototype.implement=function(i,s){this.prototype[i]=s;}.overloadSetter();var n=Array.prototype.slice;f.from=function(i){return(o(i)=="function")?i:function(){return i;
-};};Array.from=function(i){if(i==null){return[];}return(a.isEnumerable(i)&&typeof i!="string")?(o(i)=="array")?i:n.call(i):[i];};Number.from=function(s){var i=parseFloat(s);
-    return isFinite(i)?i:null;};String.from=function(i){return i+"";};f.implement({hide:function(){this.$hidden=true;return this;},protect:function(){this.$protected=true;
-    return this;}});var a=this.Type=function(u,t){if(u){var s=u.toLowerCase();var i=function(v){return(o(v)==s);};a["is"+u]=i;if(t!=null){t.prototype.$family=(function(){return s;
-}).hide();}}if(t==null){return null;}t.extend(this);t.$constructor=a;t.prototype.$constructor=t;return t;};var e=Object.prototype.toString;a.isEnumerable=function(i){return(i!=null&&typeof i.length=="number"&&e.call(i)!="[object Function]");
-};var q={};var r=function(i){var s=o(i.prototype);return q[s]||(q[s]=[]);};var b=function(t,x){if(x&&x.$hidden){return;}var s=r(this);for(var u=0;u<s.length;
-                                                                                                                                          u++){var w=s[u];if(o(w)=="type"){b.call(w,t,x);}else{w.call(this,t,x);}}var v=this.prototype[t];if(v==null||!v.$protected){this.prototype[t]=x;}if(this[t]==null&&o(x)=="function"){m.call(this,t,function(i){return x.apply(i,n.call(arguments,1));
-});}};var m=function(i,t){if(t&&t.$hidden){return;}var s=this[i];if(s==null||!s.$protected){this[i]=t;}};a.implement({implement:b.overloadSetter(),extend:m.overloadSetter(),alias:function(i,s){b.call(this,i,this.prototype[s]);
-}.overloadSetter(),mirror:function(i){r(this).push(i);return this;}});new a("Type",a);var d=function(s,x,v){var u=(x!=Object),B=x.prototype;if(u){x=new a(s,x);
-}for(var y=0,w=v.length;y<w;y++){var C=v[y],A=x[C],z=B[C];if(A){A.protect();}if(u&&z){x.implement(C,z.protect());}}if(u){var t=B.propertyIsEnumerable(v[0]);
-    x.forEachMethod=function(G){if(!t){for(var F=0,D=v.length;F<D;F++){G.call(B,B[v[F]],v[F]);}}for(var E in B){G.call(B,B[E],E);}};}return d;};d("String",String,["charAt","charCodeAt","concat","indexOf","lastIndexOf","match","quote","replace","search","slice","split","substr","substring","trim","toLowerCase","toUpperCase"])("Array",Array,["pop","push","reverse","shift","sort","splice","unshift","concat","join","slice","indexOf","lastIndexOf","filter","forEach","every","map","some","reduce","reduceRight"])("Number",Number,["toExponential","toFixed","toLocaleString","toPrecision"])("Function",f,["apply","call","bind"])("RegExp",RegExp,["exec","test"])("Object",Object,["create","defineProperty","defineProperties","keys","getPrototypeOf","getOwnPropertyDescriptor","getOwnPropertyNames","preventExtensions","isExtensible","seal","isSealed","freeze","isFrozen"])("Date",Date,["now"]);
-    Object.extend=m.overloadSetter();Date.extend("now",function(){return +(new Date);});new a("Boolean",Boolean);Number.prototype.$family=function(){return isFinite(this)?"number":"null";
-    }.hide();Number.extend("random",function(s,i){return Math.floor(Math.random()*(i-s+1)+s);});var g=Object.prototype.hasOwnProperty;Object.extend("forEach",function(i,t,u){for(var s in i){if(g.call(i,s)){t.call(u,i[s],s,i);
-    }}});Object.each=Object.forEach;Array.implement({forEach:function(u,v){for(var t=0,s=this.length;t<s;t++){if(t in this){u.call(v,this[t],t,this);}}},each:function(i,s){Array.forEach(this,i,s);
-        return this;}});var l=function(i){switch(o(i)){case"array":return i.clone();case"object":return Object.clone(i);default:return i;}};Array.implement("clone",function(){var s=this.length,t=new Array(s);
-        while(s--){t[s]=l(this[s]);}return t;});var h=function(s,i,t){switch(o(t)){case"object":if(o(s[i])=="object"){Object.merge(s[i],t);}else{s[i]=Object.clone(t);
-    }break;case"array":s[i]=t.clone();break;default:s[i]=t;}return s;};Object.extend({merge:function(z,u,t){if(o(u)=="string"){return h(z,u,t);}for(var y=1,s=arguments.length;
-                                                                                                                                                    y<s;y++){var w=arguments[y];for(var x in w){h(z,x,w[x]);}}return z;},clone:function(i){var t={};for(var s in i){t[s]=l(i[s]);}return t;},append:function(w){for(var v=1,t=arguments.length;
-                                                                                                                                                                                                                                                                                                                    v<t;v++){var s=arguments[v]||{};for(var u in s){w[u]=s[u];}}return w;}});["Object","WhiteSpace","TextNode","Collection","Arguments"].each(function(i){new a(i);
-    });var c=Date.now();String.extend("uniqueID",function(){return(c++).toString(36);});})();Array.implement({every:function(c,d){for(var b=0,a=this.length>>>0;
-                                                                                                                                      b<a;b++){if((b in this)&&!c.call(d,this[b],b,this)){return false;}}return true;},filter:function(d,f){var c=[];for(var e,b=0,a=this.length>>>0;b<a;b++){if(b in this){e=this[b];
-    if(d.call(f,e,b,this)){c.push(e);}}}return c;},indexOf:function(c,d){var b=this.length>>>0;for(var a=(d<0)?Math.max(0,b+d):d||0;a<b;a++){if(this[a]===c){return a;
-}}return -1;},map:function(c,e){var d=this.length>>>0,b=Array(d);for(var a=0;a<d;a++){if(a in this){b[a]=c.call(e,this[a],a,this);}}return b;},some:function(c,d){for(var b=0,a=this.length>>>0;
-                                                                                                                                                                      b<a;b++){if((b in this)&&c.call(d,this[b],b,this)){return true;}}return false;},clean:function(){return this.filter(function(a){return a!=null;});},invoke:function(a){var b=Array.slice(arguments,1);
-    return this.map(function(c){return c[a].apply(c,b);});},associate:function(c){var d={},b=Math.min(this.length,c.length);for(var a=0;a<b;a++){d[c[a]]=this[a];
-}return d;},link:function(c){var a={};for(var e=0,b=this.length;e<b;e++){for(var d in c){if(c[d](this[e])){a[d]=this[e];delete c[d];break;}}}return a;},contains:function(a,b){return this.indexOf(a,b)!=-1;
-},append:function(a){this.push.apply(this,a);return this;},getLast:function(){return(this.length)?this[this.length-1]:null;},getRandom:function(){return(this.length)?this[Number.random(0,this.length-1)]:null;
-},include:function(a){if(!this.contains(a)){this.push(a);}return this;},combine:function(c){for(var b=0,a=c.length;b<a;b++){this.include(c[b]);}return this;
-},erase:function(b){for(var a=this.length;a--;){if(this[a]===b){this.splice(a,1);}}return this;},empty:function(){this.length=0;return this;},flatten:function(){var d=[];
-    for(var b=0,a=this.length;b<a;b++){var c=typeOf(this[b]);if(c=="null"){continue;}d=d.concat((c=="array"||c=="collection"||c=="arguments"||instanceOf(this[b],Array))?Array.flatten(this[b]):this[b]);
-    }return d;},pick:function(){for(var b=0,a=this.length;b<a;b++){if(this[b]!=null){return this[b];}}return null;},rgbToHex:function(d){if(this.length<3){return null;}if(this.length==4&&this[3]==0&&!d){return"transparent";
-}var b=[];for(var a=0;a<3;a++){var c=(this[a]-0).toString(16);b.push((c.length==1)?"0"+c:c);}return(d)?b:"#"+b.join("");}});String.implement({test:function(a,b){return((typeOf(a)=="regexp")?a:new RegExp(""+a,b)).test(this);
-},contains:function(a,b){return(b)?(b+this+b).indexOf(b+a+b)>-1:String(this).indexOf(a)>-1;},trim:function(){return String(this).replace(/^\s+|\s+$/g,"");
-},clean:function(){return String(this).replace(/\s+/g," ").trim();},camelCase:function(){return String(this).replace(/-\D/g,function(a){return a.charAt(1).toUpperCase();
-});},hyphenate:function(){return String(this).replace(/[A-Z]/g,function(a){return("-"+a.charAt(0).toLowerCase());});},capitalize:function(){return String(this).replace(/\b[a-z]/g,function(a){return a.toUpperCase();
-});},escapeRegExp:function(){return String(this).replace(/([-.*+?^${}()|[\]\/\\])/g,"\\$1");},rgbToHex:function(b){var a=String(this).match(/\d{1,3}/g);
-    return(a)?a.rgbToHex(b):null;},substitute:function(a,b){return String(this).replace(b||(/\\?\{([^{}]+)\}/g),function(d,c){if(d.charAt(0)=="\\"){return d.slice(1);
-}return(a[c]!=null)?a[c]:"";});}});
-Function.implement({bind:function(e){var a=this,b=arguments.length>1?Array.slice(arguments,1):null,d=function(){};var c=function(){var g=e,h=arguments.length;if(this instanceof c){d.prototype=a.prototype;g=new d;}var f=(!b&&!h)?a.call(g):a.apply(g,b&&h?b.concat(Array.slice(arguments)):b||arguments);return g==e?f:g;};return c;},pass:function(b,c){var a=this;if(b!=null){b=Array.from(b);}return function(){return a.apply(c,b||arguments);};},delay:function(b,c,a){return setTimeout(this.pass((a==null?[]:a),c),b);},});
-Number.alias("each","times");(function(b){var a={};b.each(function(c){if(!Number[c]){a[c]=function(){return Math[c].apply(null,[this].concat(Array.from(arguments)));
-};}});Number.implement(a);})(["abs","acos","asin","atan","atan2","ceil","cos","exp","floor","log","max","min","pow","sin","sqrt","tan"]);(function(){var a=this.Class=new Type("Class",function(h){if(instanceOf(h,Function)){h={initialize:h};
-}var g=function(){e(this);if(g.$prototyping){return this;}this.$caller=null;var i=(this.initialize)?this.initialize.apply(this,arguments):this;this.$caller=this.caller=null;
-    return i;}.extend(this).implement(h);g.$constructor=a;g.prototype.$constructor=g;g.prototype.parent=c;return g;});var c=function(){if(!this.$caller){throw new Error('The method "parent" cannot be called.');
-}var g=this.$caller.$name,h=this.$caller.$owner.parent,i=(h)?h.prototype[g]:null;if(!i){throw new Error('The method "'+g+'" has no parent.');}return i.apply(this,arguments);
-};var e=function(g){for(var h in g){var j=g[h];switch(typeOf(j)){case"object":var i=function(){};i.prototype=j;g[h]=e(new i);break;case"array":g[h]=j.clone();
-    break;}}return g;};var b=function(g,h,j){if(j.$origin){j=j.$origin;}var i=function(){if(j.$protected&&this.$caller==null){throw new Error('The method "'+h+'" cannot be called.');
-}var l=this.caller,m=this.$caller;this.caller=m;this.$caller=i;var k=j.apply(this,arguments);this.$caller=m;this.caller=l;return k;}.extend({$owner:g,$origin:j,$name:h});
-    return i;};var f=function(h,i,g){if(a.Mutators.hasOwnProperty(h)){i=a.Mutators[h].call(this,i);if(i==null){return this;}}if(typeOf(i)=="function"){if(i.$hidden){return this;
-}this.prototype[h]=(g)?i:b(this,h,i);}else{Object.merge(this.prototype,h,i);}return this;};var d=function(g){g.$prototyping=true;var h=new g;delete g.$prototyping;
-    return h;};a.implement("implement",f.overloadSetter());a.Mutators={Extends:function(g){this.parent=g;this.prototype=d(g);},Implements:function(g){Array.from(g).each(function(j){var h=new j;for(var i in h){f.call(this,i,h[i],true);}},this);}};})();
+(function () {
+  this.MooTools = { version: '1.4.5', build: 'ab8ea8824dc3b24b6666867a2c4ed58ebb762cf0' }; const o = this.typeOf = function (i) {
+    if (i == null) { return 'null'; } if (i.$family != null) {
+      return i.$family();
+    } if (i.nodeName) { if (i.nodeType == 1) { return 'element'; } if (i.nodeType == 3) { return (/\S/).test(i.nodeValue) ? 'textnode' : 'whitespace'; } } else if (typeof i.length === 'number') {
+      if (i.callee) {
+        return 'arguments';
+      } if ('item' in i) { return 'collection'; }
+    } return typeof i;
+  }; const j = this.instanceOf = function (t, i) {
+    if (t == null) { return false; } let s = t.$constructor || t.constructor;
+    while (s) { if (s === i) { return true; }s = s.parent; } if (!t.hasOwnProperty) { return false; } return t instanceof i;
+  }; const f = this.Function; let p = true; for (const k in { toString: 1 }) {
+    p = null;
+  } if (p) { p = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'constructor']; }f.prototype.overloadSetter = function (s) {
+    const i = this;
+    return function (u, t) {
+      if (u == null) { return this; } if (s || typeof u !== 'string') {
+        for (var v in u) { i.call(this, v, u[v]); } if (p) {
+          for (let w = p.length; w--;) {
+            v = p[w]; if (u.hasOwnProperty(v)) {
+              i.call(this, v, u[v]);
+            }
+          }
+        }
+      } else { i.call(this, u, t); } return this;
+    };
+  }; f.prototype.overloadGetter = function (s) {
+    const i = this; return function (u) {
+      let v; let t; if (typeof u !== 'string') { v = u; } else if (arguments.length > 1) {
+        v = arguments;
+      } else if (s) { v = [u]; } if (v) { t = {}; for (let w = 0; w < v.length; w++) { t[v[w]] = i.call(this, v[w]); } } else { t = i.call(this, u); } return t;
+    };
+  }; f.prototype.extend = function (i, s) {
+    this[i] = s;
+  }.overloadSetter(); f.prototype.implement = function (i, s) { this.prototype[i] = s; }.overloadSetter(); const n = Array.prototype.slice; f.from = function (i) {
+    return (o(i) == 'function') ? i : function () {
+      return i;
+    };
+  }; Array.from = function (i) { if (i == null) { return []; } return (a.isEnumerable(i) && typeof i !== 'string') ? (o(i) == 'array') ? i : n.call(i) : [i]; }; Number.from = function (s) {
+    const i = parseFloat(s);
+    return isFinite(i) ? i : null;
+  }; String.from = function (i) { return `${i}`; }; f.implement({
+    hide() { this.$hidden = true; return this; },
+    protect() {
+      this.$protected = true;
+      return this;
+    },
+  }); var a = this.Type = function (u, t) {
+    if (u) {
+      const s = u.toLowerCase(); const i = function (v) { return (o(v) == s); }; a[`is${u}`] = i; if (t != null) {
+        t.prototype.$family = (function () {
+          return s;
+        }).hide();
+      }
+    } if (t == null) { return null; }t.extend(this); t.$constructor = a; t.prototype.$constructor = t; return t;
+  }; const e = Object.prototype.toString; a.isEnumerable = function (i) {
+    return (i != null && typeof i.length === 'number' && e.call(i) != '[object Function]');
+  }; const q = {}; const r = function (i) { const s = o(i.prototype); return q[s] || (q[s] = []); }; var b = function (t, x) {
+    if (x && x.$hidden) { return; } const s = r(this); for (let u = 0; u < s.length;
+      u++) { const w = s[u]; if (o(w) == 'type') { b.call(w, t, x); } else { w.call(this, t, x); } } const v = this.prototype[t]; if (v == null || !v.$protected) { this.prototype[t] = x; } if (this[t] == null && o(x) == 'function') {
+      m.call(this, t, function (i) {
+        return x.apply(i, n.call(arguments, 1));
+      });
+    }
+  }; var m = function (i, t) { if (t && t.$hidden) { return; } const s = this[i]; if (s == null || !s.$protected) { this[i] = t; } }; a.implement({
+    implement: b.overloadSetter(),
+    extend: m.overloadSetter(),
+    alias: function (i, s) {
+      b.call(this, i, this.prototype[s]);
+    }.overloadSetter(),
+    mirror(i) { r(this).push(i); return this; },
+  }); new a('Type', a); var d = function (s, x, v) {
+    const u = (x != Object); const B = x.prototype; if (u) {
+      x = new a(s, x);
+    } for (let y = 0, w = v.length; y < w; y++) { const C = v[y]; const A = x[C]; const z = B[C]; if (A) { A.protect(); } if (u && z) { x.implement(C, z.protect()); } } if (u) {
+      const t = B.propertyIsEnumerable(v[0]);
+      x.forEachMethod = function (G) { if (!t) { for (let F = 0, D = v.length; F < D; F++) { G.call(B, B[v[F]], v[F]); } } for (const E in B) { G.call(B, B[E], E); } };
+    } return d;
+  }; d('String', String, ['charAt', 'charCodeAt', 'concat', 'indexOf', 'lastIndexOf', 'match', 'quote', 'replace', 'search', 'slice', 'split', 'substr', 'substring', 'trim', 'toLowerCase', 'toUpperCase'])('Array', Array, ['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift', 'concat', 'join', 'slice', 'indexOf', 'lastIndexOf', 'filter', 'forEach', 'every', 'map', 'some', 'reduce', 'reduceRight'])('Number', Number, ['toExponential', 'toFixed', 'toLocaleString', 'toPrecision'])('Function', f, ['apply', 'call', 'bind'])('RegExp', RegExp, ['exec', 'test'])('Object', Object, ['create', 'defineProperty', 'defineProperties', 'keys', 'getPrototypeOf', 'getOwnPropertyDescriptor', 'getOwnPropertyNames', 'preventExtensions', 'isExtensible', 'seal', 'isSealed', 'freeze', 'isFrozen'])('Date', Date, ['now']);
+  Object.extend = m.overloadSetter(); Date.extend('now', () => +(new Date())); new a('Boolean', Boolean); Number.prototype.$family = function () {
+    return isFinite(this) ? 'number' : 'null';
+  }.hide(); Number.extend('random', (s, i) => Math.floor(Math.random() * (i - s + 1) + s)); const g = Object.prototype.hasOwnProperty; Object.extend('forEach', (i, t, u) => {
+    for (const s in i) {
+      if (g.call(i, s)) {
+        t.call(u, i[s], s, i);
+      }
+    }
+  }); Object.each = Object.forEach; Array.implement({
+    forEach(u, v) { for (let t = 0, s = this.length; t < s; t++) { if (t in this) { u.call(v, this[t], t, this); } } },
+    each(i, s) {
+      Array.forEach(this, i, s);
+      return this;
+    },
+  }); const l = function (i) { switch (o(i)) { case 'array': return i.clone(); case 'object': return Object.clone(i); default: return i; } }; Array.implement('clone', function () {
+    let s = this.length; const t = new Array(s);
+    while (s--) { t[s] = l(this[s]); } return t;
+  }); const h = function (s, i, t) {
+    switch (o(t)) {
+      case 'object': if (o(s[i]) == 'object') { Object.merge(s[i], t); } else {
+        s[i] = Object.clone(t);
+      } break; case 'array': s[i] = t.clone(); break; default: s[i] = t;
+    } return s;
+  }; Object.extend({
+    merge(z, u, t) {
+      if (o(u) == 'string') { return h(z, u, t); } for (let y = 1, s = arguments.length;
+        y < s; y++) { const w = arguments[y]; for (const x in w) { h(z, x, w[x]); } } return z;
+    },
+    clone(i) { const t = {}; for (const s in i) { t[s] = l(i[s]); } return t; },
+    append(w) {
+      for (let v = 1, t = arguments.length;
+        v < t; v++) { const s = arguments[v] || {}; for (const u in s) { w[u] = s[u]; } } return w;
+    },
+  }); ['Object', 'WhiteSpace', 'TextNode', 'Collection', 'Arguments'].each((i) => {
+    new a(i);
+  }); let c = Date.now(); String.extend('uniqueID', () => (c++).toString(36));
+}()); Array.implement({
+  every(c, d) {
+    for (let b = 0, a = this.length >>> 0;
+      b < a; b++) { if ((b in this) && !c.call(d, this[b], b, this)) { return false; } } return true;
+  },
+  filter(d, f) {
+    const c = []; for (var e, b = 0, a = this.length >>> 0; b < a; b++) {
+      if (b in this) {
+        e = this[b];
+        if (d.call(f, e, b, this)) { c.push(e); }
+      }
+    } return c;
+  },
+  indexOf(c, d) {
+    const b = this.length >>> 0; for (let a = (d < 0) ? Math.max(0, b + d) : d || 0; a < b; a++) {
+      if (this[a] === c) {
+        return a;
+      }
+    } return -1;
+  },
+  map(c, e) { const d = this.length >>> 0; const b = Array(d); for (let a = 0; a < d; a++) { if (a in this) { b[a] = c.call(e, this[a], a, this); } } return b; },
+  some(c, d) {
+    for (let b = 0, a = this.length >>> 0;
+      b < a; b++) { if ((b in this) && c.call(d, this[b], b, this)) { return true; } } return false;
+  },
+  clean() { return this.filter((a) => a != null); },
+  invoke(a) {
+    const b = Array.slice(arguments, 1);
+    return this.map((c) => c[a].apply(c, b));
+  },
+  associate(c) {
+    const d = {}; const b = Math.min(this.length, c.length); for (let a = 0; a < b; a++) {
+      d[c[a]] = this[a];
+    } return d;
+  },
+  link(c) { const a = {}; for (let e = 0, b = this.length; e < b; e++) { for (const d in c) { if (c[d](this[e])) { a[d] = this[e]; delete c[d]; break; } } } return a; },
+  contains(a, b) {
+    return this.indexOf(a, b) != -1;
+  },
+  append(a) { this.push.apply(this, a); return this; },
+  getLast() { return (this.length) ? this[this.length - 1] : null; },
+  getRandom() {
+    return (this.length) ? this[Number.random(0, this.length - 1)] : null;
+  },
+  include(a) { if (!this.contains(a)) { this.push(a); } return this; },
+  combine(c) {
+    for (let b = 0, a = c.length; b < a; b++) { this.include(c[b]); } return this;
+  },
+  erase(b) { for (let a = this.length; a--;) { if (this[a] === b) { this.splice(a, 1); } } return this; },
+  empty() { this.length = 0; return this; },
+  flatten() {
+    let d = [];
+    for (let b = 0, a = this.length; b < a; b++) {
+      const c = typeOf(this[b]); if (c == 'null') { continue; }d = d.concat((c == 'array' || c == 'collection' || c == 'arguments' || instanceOf(this[b], Array)) ? Array.flatten(this[b]) : this[b]);
+    } return d;
+  },
+  pick() { for (let b = 0, a = this.length; b < a; b++) { if (this[b] != null) { return this[b]; } } return null; },
+  rgbToHex(d) {
+    if (this.length < 3) { return null; } if (this.length == 4 && this[3] == 0 && !d) {
+      return 'transparent';
+    } const b = []; for (let a = 0; a < 3; a++) { const c = (this[a] - 0).toString(16); b.push((c.length == 1) ? `0${c}` : c); } return (d) ? b : `#${b.join('')}`;
+  },
+}); String.implement({
+  test(a, b) {
+    return ((typeOf(a) == 'regexp') ? a : new RegExp(`${a}`, b)).test(this);
+  },
+  contains(a, b) { return (b) ? (b + this + b).indexOf(b + a + b) > -1 : String(this).indexOf(a) > -1; },
+  trim() {
+    return String(this).replace(/^\s+|\s+$/g, '');
+  },
+  clean() { return String(this).replace(/\s+/g, ' ').trim(); },
+  camelCase() {
+    return String(this).replace(/-\D/g, (a) => a.charAt(1).toUpperCase());
+  },
+  hyphenate() { return String(this).replace(/[A-Z]/g, (a) => (`-${a.charAt(0).toLowerCase()}`)); },
+  capitalize() {
+    return String(this).replace(/\b[a-z]/g, (a) => a.toUpperCase());
+  },
+  escapeRegExp() { return String(this).replace(/([-.*+?^${}()|[\]\/\\])/g, '\\$1'); },
+  rgbToHex(b) {
+    const a = String(this).match(/\d{1,3}/g);
+    return (a) ? a.rgbToHex(b) : null;
+  },
+  substitute(a, b) {
+    return String(this).replace(b || (/\\?\{([^{}]+)\}/g), (d, c) => {
+      if (d.charAt(0) == '\\') {
+        return d.slice(1);
+      } return (a[c] != null) ? a[c] : '';
+    });
+  },
+});
+Function.implement({ bind(e) { const a = this; const b = arguments.length > 1 ? Array.slice(arguments, 1) : null; const d = function () {}; var c = function () { let g = e; const h = arguments.length; if (this instanceof c) { d.prototype = a.prototype; g = new d(); } const f = (!b && !h) ? a.call(g) : a.apply(g, b && h ? b.concat(Array.slice(arguments)) : b || arguments); return g == e ? f : g; }; return c; }, pass(b, c) { const a = this; if (b != null) { b = Array.from(b); } return function () { return a.apply(c, b || arguments); }; }, delay(b, c, a) { return setTimeout(this.pass((a == null ? [] : a), c), b); } });
+Number.alias('each', 'times'); (function (b) {
+  const a = {}; b.each((c) => {
+    if (!Number[c]) {
+      a[c] = function () {
+        return Math[c].apply(null, [this].concat(Array.from(arguments)));
+      };
+    }
+  }); Number.implement(a);
+}(['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp', 'floor', 'log', 'max', 'min', 'pow', 'sin', 'sqrt', 'tan'])); (function () {
+  var a = this.Class = new Type('Class', function (h) {
+    if (instanceOf(h, Function)) {
+      h = { initialize: h };
+    } var g = function () {
+      e(this); if (g.$prototyping) { return this; } this.$caller = null; const i = (this.initialize) ? this.initialize.apply(this, arguments) : this; this.$caller = this.caller = null;
+      return i;
+    }.extend(this).implement(h); g.$constructor = a; g.prototype.$constructor = g; g.prototype.parent = c; return g;
+  }); var c = function () {
+    if (!this.$caller) {
+      throw new Error('The method "parent" cannot be called.');
+    } const g = this.$caller.$name; const h = this.$caller.$owner.parent; const i = (h) ? h.prototype[g] : null; if (!i) { throw new Error(`The method "${g}" has no parent.`); } return i.apply(this, arguments);
+  }; var e = function (g) {
+    for (const h in g) {
+      const j = g[h]; switch (typeOf(j)) {
+        case 'object': var i = function () {}; i.prototype = j; g[h] = e(new i()); break; case 'array': g[h] = j.clone();
+          break;
+      }
+    } return g;
+  }; const b = function (g, h, j) {
+    if (j.$origin) { j = j.$origin; } var i = function () {
+      if (j.$protected && this.$caller == null) {
+        throw new Error(`The method "${h}" cannot be called.`);
+      } const l = this.caller; const m = this.$caller; this.caller = m; this.$caller = i; const k = j.apply(this, arguments); this.$caller = m; this.caller = l; return k;
+    }.extend({ $owner: g, $origin: j, $name: h });
+    return i;
+  }; const f = function (h, i, g) {
+    if (a.Mutators.hasOwnProperty(h)) { i = a.Mutators[h].call(this, i); if (i == null) { return this; } } if (typeOf(i) == 'function') {
+      if (i.$hidden) {
+        return this;
+      } this.prototype[h] = (g) ? i : b(this, h, i);
+    } else { Object.merge(this.prototype, h, i); } return this;
+  }; const d = function (g) {
+    g.$prototyping = true; const h = new g(); delete g.$prototyping;
+    return h;
+  }; a.implement('implement', f.overloadSetter()); a.Mutators = { Extends(g) { this.parent = g; this.prototype = d(g); }, Implements(g) { Array.from(g).each(function (j) { const h = new j(); for (const i in h) { f.call(this, i, h[i], true); } }, this); } };
+}());

packages/mindplot/lib/components/model/FeatureModel.js

@@ -18,14 +18,14 @@
 
 const FeatureModel = new Class(/** @lends FeatureModel */{
   Static: {
-        _nextUUID:function () {
+    _nextUUID() {
       if (!$defined(FeatureModel._uuid)) {
         FeatureModel._uuid = 0;
       }
 
-            FeatureModel._uuid = FeatureModel._uuid + 1;
+      FeatureModel._uuid += 1;
       return FeatureModel._uuid;
-        }
+    },
   },
 
   /**
@@ -34,7 +34,7 @@ const FeatureModel = new Class(/** @lends FeatureModel */{
      * @throws will throw an exception if type is null or undefined
      * assigns a unique id and the given type to the new model
      */
-    initialize:function (type) {
+  initialize(type) {
     $assert(type, 'type can not be null');
     this._id = FeatureModel._nextUUID();
 
@@ -42,50 +42,50 @@ const FeatureModel = new Class(/** @lends FeatureModel */{
     this._attributes = {};
 
     // Create type method ...
-        this['is' + $.camelCase(type) + 'Model'] = function () {
+    this[`is${$.camelCase(type)}Model`] = function () {
       return true;
     };
   },
 
   /** */
-    getAttributes:function () {
+  getAttributes() {
     return Object.clone(this._attributes);
   },
 
   /** */
-    setAttributes:function (attributes) {
+  setAttributes(attributes) {
     for (key in attributes) {
-            this["set" + key.capitalize()](attributes[key]);
+      this[`set${key.capitalize()}`](attributes[key]);
     }
   },
 
   /** */
-    setAttribute:function (key, value) {
+  setAttribute(key, value) {
     $assert(key, 'key id can not be null');
     this._attributes[key] = value;
   },
 
   /** */
-    getAttribute:function (key) {
+  getAttribute(key) {
     $assert(key, 'key id can not be null');
 
     return this._attributes[key];
   },
 
   /** */
-    getId:function () {
+  getId() {
     return this._id;
   },
 
   /** */
-    setId:function (id) {
+  setId(id) {
     this._id = id;
   },
 
   /** */
-    getType:function () {
+  getType() {
     return this._type;
-    }
+  },
 });
 
 export default FeatureModel;

packages/mindplot/lib/components/model/IMindmap.js

@@ -21,63 +21,63 @@ const IMindmap = new Class(/** @lends IMindmap */{
      * @constructs
      * @abstract
      */
-    initialize : function() {
-        throw "Unsupported operation";
+  initialize() {
+    throw 'Unsupported operation';
   },
 
   /** */
-    getCentralTopic : function() {
+  getCentralTopic() {
     return this.getBranches()[0];
   },
 
   /** @abstract */
-    getDescription : function() {
-        throw "Unsupported operation";
+  getDescription() {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    setDescription : function(value) {
-        throw "Unsupported operation";
+  setDescription(value) {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    getId : function() {
-        throw "Unsupported operation";
+  getId() {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    setId : function(id) {
-        throw "Unsupported operation";
+  setId(id) {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    getVersion : function() {
-        throw "Unsupported operation";
+  getVersion() {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    setVersion : function(version) {
-        throw "Unsupported operation";
+  setVersion(version) {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    addBranch : function(nodeModel) {
-        throw "Unsupported operation";
+  addBranch(nodeModel) {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    getBranches : function() {
-        throw "Unsupported operation";
+  getBranches() {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    removeBranch : function(node) {
-        throw "Unsupported operation";
+  removeBranch(node) {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    getRelationships : function() {
-        throw "Unsupported operation";
+  getRelationships() {
+    throw 'Unsupported operation';
   },
 
   /**
@@ -85,7 +85,7 @@ const IMindmap = new Class(/** @lends IMindmap */{
      * @param child
      * @throws will throw an error if child already has a connection to a parent node
      */
-    connect : function(parent, child) {
+  connect(parent, child) {
     // Child already has a parent ?
     $assert(!child.getParent(), 'Child model seems to be already connected');
 
@@ -101,8 +101,8 @@ const IMindmap = new Class(/** @lends IMindmap */{
      * @throws will throw an error if child is null or undefined
      * @throws will throw an error if child's parent cannot be found
      */
-    disconnect : function(child) {
-        var parent = child.getParent();
+  disconnect(child) {
+    const parent = child.getParent();
     $assert(child, 'Child can not be null.');
     $assert(parent, 'Child model seems to be already connected');
 
@@ -111,71 +111,71 @@ const IMindmap = new Class(/** @lends IMindmap */{
   },
 
   /** @abstract */
-    hasAlreadyAdded : function(node) {
-        throw "Unsupported operation";
+  hasAlreadyAdded(node) {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    createNode : function(type, id) {
-        throw "Unsupported operation";
+  createNode(type, id) {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    createRelationship : function(fromNode, toNode) {
-        throw "Unsupported operation";
+  createRelationship(fromNode, toNode) {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    addRelationship : function(rel) {
-        throw "Unsupported operation";
+  addRelationship(rel) {
+    throw 'Unsupported operation';
   },
 
   /** @abstract */
-    deleteRelationship : function(relationship) {
-        throw "Unsupported operation";
+  deleteRelationship(relationship) {
+    throw 'Unsupported operation';
   },
 
   /** */
-    inspect : function() {
-        var result = '';
+  inspect() {
+    let result = '';
     result = '{ ';
 
-        var branches = this.getBranches();
-        result = result + "version:" + this.getVersion();
-        result = result + " , [";
+    const branches = this.getBranches();
+    result = `${result}version:${this.getVersion()}`;
+    result = `${result} , [`;
 
-        for (var i = 0; i < branches.length; i++) {
-            var node = branches[i];
+    for (let i = 0; i < branches.length; i++) {
+      const node = branches[i];
       if (i != 0) {
-                result = result + ',\n ';
+        result = `${result},\n `;
       }
-            result = result + "(" + i + ") =>" + node.inspect();
+      result = `${result}(${i}) =>${node.inspect()}`;
     }
-        result = result + "]";
+    result = `${result}]`;
 
-        result = result + ' } ';
+    result = `${result} } `;
     return result;
   },
 
   /**
      * @param target
      */
-    copyTo : function(target) {
-        var source = this;
-        var version = source.getVersion();
+  copyTo(target) {
+    const source = this;
+    const version = source.getVersion();
     target.setVersion(version);
 
-        var desc = this.getDescription();
+    const desc = this.getDescription();
     target.setDescription(desc);
 
     // Then the rest of the branches ...
-        var sbranchs = source.getBranches();
-        _.each(sbranchs, function(snode) {
-            var tnode = target.createNode(snode.getType(), snode.getId());
+    const sbranchs = source.getBranches();
+    _.each(sbranchs, (snode) => {
+      const tnode = target.createNode(snode.getType(), snode.getId());
       snode.copyTo(tnode);
       target.addBranch(tnode);
     });
-    }
+  },
 });
 
-export default IMindmap
+export default IMindmap;

packages/mindplot/lib/components/model/INodeModel.js

@@ -22,18 +22,18 @@ const INodeModel = new Class(
          * @constructs
          * @param mindmap
          */
-        initialize: function (mindmap) {
+    initialize(mindmap) {
       $assert(mindmap && mindmap.getBranches, 'mindmap can not be null');
       this._mindmap = mindmap;
     },
 
     /** */
-        getId: function () {
+    getId() {
       return this.getProperty('id');
     },
 
     /** */
-        setId: function (id) {
+    setId(id) {
       if ($defined(id) && id > INodeModel._uuid) {
         INodeModel._uuid = id;
       }
@@ -45,79 +45,79 @@ const INodeModel = new Class(
     },
 
     /** */
-        getType: function () {
+    getType() {
       return this.getProperty('type');
     },
 
     /** */
-        setType: function (type) {
+    setType(type) {
       this.putProperty('type', type);
     },
 
     /** */
-        setText: function (text) {
+    setText(text) {
       this.putProperty('text', text);
     },
 
     /** */
-        getText: function () {
+    getText() {
       return this.getProperty('text');
     },
 
     /** */
-        setPosition: function (x, y) {
-            $assert(!isNaN(parseInt(x)), 'x position is not valid:' + x);
-            $assert(!isNaN(parseInt(y)), 'y position is not valid:' + y);
-            this.putProperty('position', '{x:' + parseInt(x) + ',y:' + parseInt(y) + '}');
+    setPosition(x, y) {
+      $assert(!isNaN(parseInt(x)), `x position is not valid:${x}`);
+      $assert(!isNaN(parseInt(y)), `y position is not valid:${y}`);
+      this.putProperty('position', `{x:${parseInt(x)},y:${parseInt(y)}}`);
     },
 
     /** */
-        getPosition: function () {
-            var value = this.getProperty('position');
-            var result = null;
+    getPosition() {
+      const value = this.getProperty('position');
+      let result = null;
       if (value != null) {
-                result = eval('(' + value + ')');
+        result = eval(`(${value})`);
       }
       return result;
     },
 
     /** */
-        setImageSize: function (width, height) {
-            this.putProperty('imageSize', '{width:' + width + ',height:' + height + '}');
+    setImageSize(width, height) {
+      this.putProperty('imageSize', `{width:${width},height:${height}}`);
     },
 
     /** */
-        getImageSize: function () {
-            var value = this.getProperty('imageSize');
-            var result = null;
+    getImageSize() {
+      const value = this.getProperty('imageSize');
+      let result = null;
       if (value != null) {
-                result = eval('(' + value + ')');
+        result = eval(`(${value})`);
       }
       return result;
     },
 
     /** */
-        setImageUrl: function (url) {
+    setImageUrl(url) {
       this.putProperty('imageUrl', url);
     },
 
     /** */
-        getMetadata: function () {
+    getMetadata() {
       return this.getProperty('metadata');
     },
 
     /** */
-        setMetadata: function (json) {
+    setMetadata(json) {
       this.putProperty('metadata', json);
     },
 
     /** */
-        getImageUrl: function () {
+    getImageUrl() {
       return this.getProperty('imageUrl');
     },
 
     /** */
-        getMindmap: function () {
+    getMindmap() {
       return this._mindmap;
     },
 
@@ -125,134 +125,134 @@ const INodeModel = new Class(
          * lets the mindmap handle the disconnect node operation
          * @see mindplot.model.IMindmap.disconnect
          */
-        disconnect: function () {
-            var mindmap = this.getMindmap();
+    disconnect() {
+      const mindmap = this.getMindmap();
       mindmap.disconnect(this);
     },
 
     /** */
-        getShapeType: function () {
+    getShapeType() {
       return this.getProperty('shapeType');
     },
 
     /** */
-        setShapeType: function (type) {
+    setShapeType(type) {
       this.putProperty('shapeType', type);
     },
 
     /** */
-        setOrder: function (value) {
+    setOrder(value) {
       $assert(
         (typeof value === 'number' && isFinite(value)) || value == null,
-                'Order must be null or a number'
+        'Order must be null or a number',
       );
       this.putProperty('order', value);
     },
 
     /** */
-        getOrder: function () {
+    getOrder() {
       return this.getProperty('order');
     },
 
     /** */
-        setFontFamily: function (fontFamily) {
+    setFontFamily(fontFamily) {
       this.putProperty('fontFamily', fontFamily);
     },
 
     /** */
-        getFontFamily: function () {
+    getFontFamily() {
       return this.getProperty('fontFamily');
     },
 
     /** */
-        setFontStyle: function (fontStyle) {
+    setFontStyle(fontStyle) {
       this.putProperty('fontStyle', fontStyle);
     },
 
     /** */
-        getFontStyle: function () {
+    getFontStyle() {
       return this.getProperty('fontStyle');
     },
 
     /** */
-        setFontWeight: function (weight) {
+    setFontWeight(weight) {
       this.putProperty('fontWeight', weight);
     },
 
     /** */
-        getFontWeight: function () {
+    getFontWeight() {
       return this.getProperty('fontWeight');
     },
 
     /** */
-        setFontColor: function (color) {
+    setFontColor(color) {
       this.putProperty('fontColor', color);
     },
 
     /** */
-        getFontColor: function () {
+    getFontColor() {
       return this.getProperty('fontColor');
     },
 
     /** */
-        setFontSize: function (size) {
+    setFontSize(size) {
       this.putProperty('fontSize', size);
     },
 
     /** */
-        getFontSize: function () {
+    getFontSize() {
       return this.getProperty('fontSize');
     },
 
     /** */
-        getBorderColor: function () {
+    getBorderColor() {
       return this.getProperty('borderColor');
     },
 
     /** */
-        setBorderColor: function (color) {
+    setBorderColor(color) {
       this.putProperty('borderColor', color);
     },
 
     /** */
-        getBackgroundColor: function () {
+    getBackgroundColor() {
       return this.getProperty('backgroundColor');
     },
 
     /** */
-        setBackgroundColor: function (color) {
+    setBackgroundColor(color) {
       this.putProperty('backgroundColor', color);
     },
 
     /** */
-        areChildrenShrunken: function () {
-            var result = this.getProperty('shrunken');
+    areChildrenShrunken() {
+      const result = this.getProperty('shrunken');
       return $defined(result) ? result : false;
     },
 
     /**
          * @return {Boolean} true if the children nodes are hidden by the shrink option
          */
-        setChildrenShrunken: function (value) {
+    setChildrenShrunken(value) {
       this.putProperty('shrunken', value);
     },
 
     /**
          * @return {Boolean} true
          */
-        isNodeModel: function () {
+    isNodeModel() {
       return true;
     },
 
     /**
          * @return {Boolean} true if the node model has a parent assigned to it
          */
-        isConnected: function () {
+    isConnected() {
       return this.getParent() != null;
     },
 
     /** @abstract */
-        append: function (node) {
+    append(node) {
       throw 'Unsupported operation';
     },
 
@@ -261,9 +261,9 @@ const INodeModel = new Class(
          * @throws will throw an error if parent is null or undefined
          * @see mindplot.model.IMindmap.connect
          */
-        connectTo: function (parent) {
+    connectTo(parent) {
       $assert(parent, 'parent can not be null');
-            var mindmap = this.getMindmap();
+      const mindmap = this.getMindmap();
       mindmap.connect(parent, this);
     },
 
@@ -271,21 +271,21 @@ const INodeModel = new Class(
          * @param target
          * @return target
          */
-        copyTo: function (target) {
-            var source = this;
+    copyTo(target) {
+      const source = this;
       // Copy properties ...
-            var keys = source.getPropertiesKeys();
-            _.each(keys, function (key) {
-                var value = source.getProperty(key);
+      const keys = source.getPropertiesKeys();
+      _.each(keys, (key) => {
+        const value = source.getProperty(key);
         target.putProperty(key, value);
       });
 
       // Copy children ...
-            var children = this.getChildren();
-            var tmindmap = target.getMindmap();
+      const children = this.getChildren();
+      const tmindmap = target.getMindmap();
 
-            _.each(function (children, snode) {
-                var tnode = tmindmap.createNode(snode.getType(), snode.getId());
+      _.each((children, snode) => {
+        const tnode = tmindmap.createNode(snode.getType(), snode.getId());
         snode.copyTo(tnode);
         target.append(tnode);
       });
@@ -297,11 +297,11 @@ const INodeModel = new Class(
          * lets parent handle the delete node operation, or, if none defined, calls the mindmap to
          * remove the respective branch
          */
-        deleteNode: function () {
-            var mindmap = this.getMindmap();
+    deleteNode() {
+      const mindmap = this.getMindmap();
 
       //        console.log("Before:" + mindmap.inspect());
-            var parent = this.getParent();
+      const parent = this.getParent();
       if ($defined(parent)) {
         parent.removeChild(this);
       } else {
@@ -313,68 +313,67 @@ const INodeModel = new Class(
     },
 
     /** @abstract */
-        getPropertiesKeys: function () {
+    getPropertiesKeys() {
       throw 'Unsupported operation';
     },
 
     /** @abstract */
-        putProperty: function (key, value) {
+    putProperty(key, value) {
       throw 'Unsupported operation';
     },
 
     /** @abstract */
-        setParent: function (parent) {
+    setParent(parent) {
       throw 'Unsupported operation';
     },
 
     /** @abstract */
-        getChildren: function () {
+    getChildren() {
       throw 'Unsupported operation';
     },
 
     /** @abstract */
-        getParent: function () {
+    getParent() {
       throw 'Unsupported operation';
     },
 
     /** @abstract */
-        clone: function () {
+    clone() {
       throw 'Unsupported operation';
     },
 
     /** */
-        inspect: function () {
-            var result =
-                '{ type: ' +
-                this.getType() +
-                ' , id: ' +
-                this.getId() +
-                ' , text: ' +
-                this.getText();
+    inspect() {
+      let result = `{ type: ${
+        this.getType()
+      } , id: ${
+        this.getId()
+      } , text: ${
+        this.getText()}`;
 
-            var children = this.getChildren();
+      const children = this.getChildren();
       if (children.length > 0) {
-                result = result + ', children: {(size:' + children.length;
-                _.each(children, function (node) {
-                    result = result + '=> (';
-                    var keys = node.getPropertiesKeys();
-                    _.each(keys, function (key) {
-                        var value = node.getProperty(key);
-                        result = result + key + ':' + value + ',';
+        result = `${result}, children: {(size:${children.length}`;
+        _.each(children, (node) => {
+          result = `${result}=> (`;
+          const keys = node.getPropertiesKeys();
+          _.each(keys, (key) => {
+            const value = node.getProperty(key);
+            result = `${result + key}:${value},`;
           });
-                    result = result + '}';
+          result = `${result}}`;
         });
       }
 
-            result = result + ' }';
+      result = `${result} }`;
       return result;
     },
 
     /** @abstract */
-        removeChild: function (child) {
+    removeChild(child) {
       throw 'Unsupported operation';
     },
-    }
+  },
 );
 
 /**
@@ -416,7 +415,7 @@ INodeModel._nextUUID = function () {
     INodeModel._uuid = 0;
   }
 
-    INodeModel._uuid = INodeModel._uuid + 1;
+  INodeModel._uuid += 1;
   return INodeModel._uuid;
 };
 INodeModel._uuid = 0;

packages/mindplot/lib/components/model/IconModel.js

@@ -15,7 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const FeatureModel = require('./FeatureModel').default
+const FeatureModel = require('./FeatureModel').default;
 
 const IconModel = new Class(/** @lends IconModel */{
   Extends: FeatureModel,
@@ -24,21 +24,21 @@ const IconModel = new Class(/** @lends IconModel */{
      * @param attributes
      * @extends mindplot.model.FeatureModel
      */
-    initialize:function (attributes) {
+  initialize(attributes) {
     this.parent(IconModel.FEATURE_TYPE);
     this.setIconType(attributes.id);
   },
 
   /** @return the icon type id */
-    getIconType:function () {
+  getIconType() {
     return this.getAttribute('id');
   },
 
   /** @param {String} iconType the icon type id */
-    setIconType:function (iconType) {
+  setIconType(iconType) {
     $assert(iconType, 'iconType id can not be null');
     this.setAttribute('id', iconType);
-    }
+  },
 });
 
 /**
@@ -46,6 +46,6 @@ const IconModel = new Class(/** @lends IconModel */{
  * @type {String}
  * @default
  */
-IconModel.FEATURE_TYPE = "icon";
+IconModel.FEATURE_TYPE = 'icon';
 
 export default IconModel;

packages/mindplot/lib/components/model/LinkModel.js

@@ -24,13 +24,13 @@ const LinkModel = new Class(/** @lends LinkModel */{
      * @param attributes
      * @extends mindplot.model.FeatureModel
      */
-    initialize:function (attributes) {
+  initialize(attributes) {
     this.parent(LinkModel.FEATURE_TYPE);
     this.setUrl(attributes.url);
   },
 
   /** @return {String} the url attribute value */
-    getUrl:function () {
+  getUrl() {
     return this.getAttribute('url');
   },
 
@@ -38,22 +38,21 @@ const LinkModel = new Class(/** @lends LinkModel */{
      * @param {String} url a URL provided by the user to set the link to
      * @throws will throw an error if url is null or undefined
      */
-    setUrl:function (url) {
+  setUrl(url) {
     $assert(url, 'url can not be null');
 
-        var fixedUrl = this._fixUrl(url);
+    const fixedUrl = this._fixUrl(url);
     this.setAttribute('url', fixedUrl);
 
-        var type = fixedUrl.contains('mailto:') ? 'mail' : 'url';
+    const type = fixedUrl.contains('mailto:') ? 'mail' : 'url';
     this.setAttribute('urlType', type);
-
   },
 
   // url format is already checked in LinkEditor.checkUrl
-    _fixUrl:function (url) {
-        var result = url;
+  _fixUrl(url) {
+    let result = url;
     if (!result.contains('http://') && !result.contains('https://') && !result.contains('mailto://')) {
-            result = "http://" + result;
+      result = `http://${result}`;
     }
     return result;
   },
@@ -62,10 +61,10 @@ const LinkModel = new Class(/** @lends LinkModel */{
      * @param {String} urlType the url type, either 'mail' or 'url'
      * @throws will throw an error if urlType is null or undefined
      */
-    setUrlType:function (urlType) {
+  setUrlType(urlType) {
     $assert(urlType, 'urlType can not be null');
     this.setAttribute('urlType', urlType);
-    }
+  },
 });
 
 /**

packages/mindplot/lib/components/model/Mindmap.js

@@ -19,7 +19,7 @@ const IMindmap = require('./IMindmap').default;
 const INodeModel = require('./INodeModel').default;
 const NodeModel = require('./NodeModel').default;
 const RelationshipModel = require('./RelationshipModel').default;
-const ModelCodeName = require('../persistence/ModelCodeName').default
+const ModelCodeName = require('../persistence/ModelCodeName').default;
 
 const Mindmap = new Class(/** @lends Mindmap */{
   Extends: IMindmap,
@@ -29,8 +29,8 @@ const Mindmap = new Class(/** @lends Mindmap */{
          * @param version
          * @extends mindplot.model.IMindmap
          */
-        initialize:function (id, version) {
-            $assert(id, "Id can not be null");
+  initialize(id, version) {
+    $assert(id, 'Id can not be null');
     this._branches = [];
     this._description = null;
     this._relationships = [];
@@ -39,32 +39,32 @@ const Mindmap = new Class(/** @lends Mindmap */{
   },
 
   /** */
-        getDescription:function () {
+  getDescription() {
     return this._description;
   },
 
   /** */
-        setDescription:function (value) {
+  setDescription(value) {
     this._description = value;
   },
 
   /** */
-        getId:function () {
+  getId() {
     return this._id;
   },
 
   /** */
-        setId:function (id) {
+  setId(id) {
     this._id = id;
   },
 
   /** */
-        getVersion:function () {
+  getVersion() {
     return this._version;
   },
 
   /** */
-        setVersion:function (version) {
+  setVersion(version) {
     this._version = version;
   },
 
@@ -73,14 +73,14 @@ const Mindmap = new Class(/** @lends Mindmap */{
          * @throws will throw an error if nodeModel is null, undefined or not a node model object
          * @throws will throw an error if
          */
-        addBranch:function (nodeModel) {
+  addBranch(nodeModel) {
     $assert(nodeModel && nodeModel.isNodeModel(), 'Add node must be invoked with model objects');
-            var branches = this.getBranches();
+    const branches = this.getBranches();
     if (branches.length == 0) {
-                $assert(nodeModel.getType() == INodeModel.CENTRAL_TOPIC_TYPE, "First element must be the central topic");
+      $assert(nodeModel.getType() == INodeModel.CENTRAL_TOPIC_TYPE, 'First element must be the central topic');
       nodeModel.setPosition(0, 0);
     } else {
-                $assert(nodeModel.getType() != INodeModel.CENTRAL_TOPIC_TYPE, "Mindmaps only have one cental topic");
+      $assert(nodeModel.getType() != INodeModel.CENTRAL_TOPIC_TYPE, 'Mindmaps only have one cental topic');
     }
 
     this._branches.push(nodeModel);
@@ -89,18 +89,18 @@ const Mindmap = new Class(/** @lends Mindmap */{
   /**
          * @param nodeModel
          */
-        removeBranch:function (nodeModel) {
+  removeBranch(nodeModel) {
     $assert(nodeModel && nodeModel.isNodeModel(), 'Remove node must be invoked with model objects');
     return this._branches.erase(nodeModel);
   },
 
   /** */
-        getBranches:function () {
+  getBranches() {
     return this._branches;
   },
 
   /** */
-        getRelationships:function () {
+  getRelationships() {
     return this._relationships;
   },
 
@@ -108,12 +108,12 @@ const Mindmap = new Class(/** @lends Mindmap */{
          * @param node
          * @return {Boolean} true if node already exists
          */
-        hasAlreadyAdded:function (node) {
-            var result = false;
+  hasAlreadyAdded(node) {
+    let result = false;
 
     // Check in not connected nodes.
-            var branches = this._branches;
-            for (var i = 0; i < branches.length; i++) {
+    const branches = this._branches;
+    for (let i = 0; i < branches.length; i++) {
       result = branches[i]._isChildNode(node);
       if (result) {
         break;
@@ -126,7 +126,7 @@ const Mindmap = new Class(/** @lends Mindmap */{
          * @param id
          * @return the node model created
          */
-        createNode:function (type, id) {
+  createNode(type, id) {
     type = !$defined(type) ? INodeModel.MAIN_TOPIC_TYPE : type;
     return new NodeModel(type, this, id);
   },
@@ -138,7 +138,7 @@ const Mindmap = new Class(/** @lends Mindmap */{
          * @throws will throw an error if target node is null or undefined
          * @return the relationship model created
          */
-        createRelationship:function (sourceNodeId, targetNodeId) {
+  createRelationship(sourceNodeId, targetNodeId) {
     $assert($defined(sourceNodeId), 'from node cannot be null');
     $assert($defined(targetNodeId), 'to node cannot be null');
 
@@ -148,14 +148,14 @@ const Mindmap = new Class(/** @lends Mindmap */{
   /**
          * @param relationship
          */
-        addRelationship:function (relationship) {
+  addRelationship(relationship) {
     this._relationships.push(relationship);
   },
 
   /**
          * @param relationship
          */
-        deleteRelationship:function (relationship) {
+  deleteRelationship(relationship) {
     this._relationships.erase(relationship);
   },
 
@@ -163,27 +163,26 @@ const Mindmap = new Class(/** @lends Mindmap */{
          * @param id
          * @return the node with the respective id or null if not in the mindmap
          */
-        findNodeById:function (id) {
-            var result = null;
-            for (var i = 0; i < this._branches.length; i++) {
-                var branch = this._branches[i];
+  findNodeById(id) {
+    let result = null;
+    for (let i = 0; i < this._branches.length; i++) {
+      const branch = this._branches[i];
       result = branch.findNodeById(id);
       if (result) {
         break;
       }
     }
     return result;
-        }
-    }
-);
+  },
+});
 
 /**
  * @param mapId
  * @return an empty mindmap with central topic only
  */
 Mindmap.buildEmpty = function (mapId) {
-    var result = new Mindmap(mapId);
-    var node = result.createNode(INodeModel.CENTRAL_TOPIC_TYPE, 0);
+  const result = new Mindmap(mapId);
+  const node = result.createNode(INodeModel.CENTRAL_TOPIC_TYPE, 0);
   result.addBranch(node);
   return result;
 };

packages/mindplot/lib/components/model/NodeModel.js

@@ -15,8 +15,8 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const INodeModel = require('./INodeModel').default
-const TopicFeature = require('../TopicFeature').default
+const INodeModel = require('./INodeModel').default;
+const TopicFeature = require('../TopicFeature').default;
 
 const NodeModel = new Class(/** @lends NodeModel */{
   Extends: INodeModel,
@@ -26,7 +26,7 @@ const NodeModel = new Class(/** @lends NodeModel */{
      * @param mindmap
      * @param id
      */
-    initialize:function (type, mindmap, id) {
+  initialize(type, mindmap, id) {
     $assert(type, 'Node type can not be null');
     $assert(mindmap, 'mindmap can not be null');
     this._properties = {};
@@ -45,7 +45,7 @@ const NodeModel = new Class(/** @lends NodeModel */{
      * @param attributes
      * @return {mindplot.model.FeatureModel} the created feature model
      */
-    createFeature:function (type, attributes) {
+  createFeature(type, attributes) {
     return TopicFeature.createModel(type, attributes);
   },
 
@@ -53,13 +53,13 @@ const NodeModel = new Class(/** @lends NodeModel */{
      * @param feature
      * @throws will throw an error if feature is null or undefined
      */
-    addFeature:function (feature) {
+  addFeature(feature) {
     $assert(feature, 'feature can not be null');
     this._feature.push(feature);
   },
 
   /** */
-    getFeatures:function () {
+  getFeatures() {
     return this._feature;
   },
 
@@ -68,25 +68,20 @@ const NodeModel = new Class(/** @lends NodeModel */{
      * @throws will throw an error if feature is null or undefined
      * @throws will throw an error if the feature could not be removed
      */
-    removeFeature:function (feature) {
+  removeFeature(feature) {
     $assert(feature, 'feature can not be null');
-        var size = this._feature.length;
-        this._feature = this._feature.filter(function (f) {
-            return feature.getId() != f.getId();
-        });
+    const size = this._feature.length;
+    this._feature = this._feature.filter((f) => feature.getId() != f.getId());
     $assert(size - 1 == this._feature.length, 'Could not be removed ...');
-
   },
 
   /**
      * @param {String} type the feature type, e.g. icon or link
      * @throws will throw an error if type is null or undefined
      */
-    findFeatureByType:function (type) {
+  findFeatureByType(type) {
     $assert(type, 'type can not be null');
-        return this._feature.filter(function (feature) {
-            return feature.getType() == type;
-        });
+    return this._feature.filter((feature) => feature.getType() == type);
   },
 
   /**
@@ -95,17 +90,15 @@ const NodeModel = new Class(/** @lends NodeModel */{
      * @throws will throw an error if feature could not be found
      * @return the feature with the given id
      */
-    findFeatureById:function (id) {
+  findFeatureById(id) {
     $assert($defined(id), 'id can not be null');
-        var result = this._feature.filter(function (feature) {
-            return feature.getId() == id;
-        });
-        $assert(result.length == 1, "Feature could not be found:" + id);
+    const result = this._feature.filter((feature) => feature.getId() == id);
+    $assert(result.length == 1, `Feature could not be found:${id}`);
     return result[0];
   },
 
   /** */
-    getPropertiesKeys:function () {
+  getPropertiesKeys() {
     return Object.keys(this._properties);
   },
 
@@ -114,30 +107,30 @@ const NodeModel = new Class(/** @lends NodeModel */{
      * @param value
      * @throws will throw an error if key is null or undefined
      */
-    putProperty:function (key, value) {
+  putProperty(key, value) {
     $defined(key, 'key can not be null');
     this._properties[key] = value;
   },
 
   /** */
-    getProperties:function () {
+  getProperties() {
     return this._properties;
   },
 
   /** */
-    getProperty:function (key) {
+  getProperty(key) {
     $defined(key, 'key can not be null');
-        var result = this._properties[key];
+    const result = this._properties[key];
     return !$defined(result) ? null : result;
   },
 
   /**
      * @return {mindplot.model.NodeModel} an identical clone of the NodeModel
      */
-    clone:function () {
-        var result = new NodeModel(this.getType(), this._mindmap);
-        result._children = this._children.map(function (node) {
-            var cnode = node.clone();
+  clone() {
+    const result = new NodeModel(this.getType(), this._mindmap);
+    result._children = this._children.map((node) => {
+      const cnode = node.clone();
       cnode._parent = result;
       return cnode;
     });
@@ -151,15 +144,15 @@ const NodeModel = new Class(/** @lends NodeModel */{
      * Similar to clone, assign new id to the elements ...
      * @return {mindplot.model.NodeModel}
      */
-    deepCopy:function () {
-        var result = new NodeModel(this.getType(), this._mindmap);
-        result._children = this._children.map(function (node) {
-            var cnode = node.deepCopy();
+  deepCopy() {
+    const result = new NodeModel(this.getType(), this._mindmap);
+    result._children = this._children.map((node) => {
+      const cnode = node.deepCopy();
       cnode._parent = result;
       return cnode;
     });
 
-        var id = result.getId();
+    const id = result.getId();
     result._properties = Object.clone(this._properties);
     result.setId(id);
 
@@ -171,7 +164,7 @@ const NodeModel = new Class(/** @lends NodeModel */{
      * @param {mindplot.model.NodeModel} child
      * @throws will throw an error if child is null, undefined or not a NodeModel object
      */
-    append:function (child) {
+  append(child) {
     $assert(child && child.isNodeModel(), 'Only NodeModel can be appended to Mindmap object');
     this._children.push(child);
     child._parent = this;
@@ -181,36 +174,36 @@ const NodeModel = new Class(/** @lends NodeModel */{
      * @param {mindplot.model.NodeModel} child
      * @throws will throw an error if child is null, undefined or not a NodeModel object
      */
-    removeChild:function (child) {
+  removeChild(child) {
     $assert(child && child.isNodeModel(), 'Only NodeModel can be appended to Mindmap object.');
     this._children.erase(child);
     child._parent = null;
   },
 
   /** */
-    getChildren:function () {
+  getChildren() {
     return this._children;
   },
 
   /** */
-    getParent:function () {
+  getParent() {
     return this._parent;
   },
 
   /** */
-    setParent:function (parent) {
+  setParent(parent) {
     $assert(parent != this, 'The same node can not be parent and child if itself.');
     this._parent = parent;
   },
 
-    _isChildNode:function (node) {
-        var result = false;
+  _isChildNode(node) {
+    let result = false;
     if (node == this) {
       result = true;
     } else {
-            var children = this.getChildren();
-            for (var i = 0; i < children.length; i++) {
-                var child = children[i];
+      const children = this.getChildren();
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
         result = child._isChildNode(node);
         if (result) {
           break;
@@ -224,14 +217,14 @@ const NodeModel = new Class(/** @lends NodeModel */{
      * @id
      * @return {mindplot.model.NodeModel} the node with the respective id
      */
-    findNodeById:function (id) {
-        var result = null;
+  findNodeById(id) {
+    let result = null;
     if (this.getId() == id) {
       result = this;
     } else {
-            var children = this.getChildren();
-            for (var i = 0; i < children.length; i++) {
-                var child = children[i];
+      const children = this.getChildren();
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
         result = child.findNodeById(id);
         if (result) {
           break;
@@ -239,7 +232,7 @@ const NodeModel = new Class(/** @lends NodeModel */{
       }
     }
     return result;
-    }
+  },
 });
 
-export default NodeModel
+export default NodeModel;

packages/mindplot/lib/components/model/NoteModel.js

@@ -15,7 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const FeatureModel = require('./FeatureModel').default
+const FeatureModel = require('./FeatureModel').default;
 
 const NoteModel = new Class(/** @lends NoteModel */{
   Extends: FeatureModel,
@@ -24,22 +24,22 @@ const NoteModel = new Class(/** @lends NoteModel */{
      * @param attributes
      * @extends mindplot.model.FeatureModel
      */
-    initialize:function (attributes) {
+  initialize(attributes) {
     this.parent(NoteModel.FEATURE_TYPE);
-        var noteText = attributes.text ? attributes.text : " ";
+    const noteText = attributes.text ? attributes.text : ' ';
     this.setText(noteText);
   },
 
   /** */
-    getText:function () {
+  getText() {
     return this.getAttribute('text');
   },
 
   /** */
-    setText:function (text) {
+  setText(text) {
     $assert(text, 'text can not be null');
     this.setAttribute('text', text);
-    }
+  },
 });
 
 /**
@@ -47,6 +47,6 @@ const NoteModel = new Class(/** @lends NoteModel */{
  * @type {String}
  * @default
  */
-NoteModel.FEATURE_TYPE = "note";
+NoteModel.FEATURE_TYPE = 'note';
 
 export default NoteModel;

packages/mindplot/lib/components/model/RelationshipModel.js

@@ -20,11 +20,11 @@ const ConnectionLine = require('../ConnectionLine').default;
 const RelationshipModel = new Class(
   /** @lends RelationshipModel */ {
     Static: {
-            _nextUUID: function () {
+      _nextUUID() {
         if (!$defined(RelationshipModel._uuid)) {
           RelationshipModel._uuid = 0;
         }
-                RelationshipModel._uuid = RelationshipModel._uuid + 1;
+        RelationshipModel._uuid += 1;
         return RelationshipModel._uuid;
       },
     },
@@ -36,7 +36,7 @@ const RelationshipModel = new Class(
          * @throws will throw an error if sourceTopicId is null or undefined
          * @throws will throw an error if targetTopicId is null or undefined
          */
-        initialize: function (sourceTopicId, targetTopicId) {
+    initialize(sourceTopicId, targetTopicId) {
       $assert($defined(sourceTopicId), 'from node type can not be null');
       $assert($defined(targetTopicId), 'to node type can not be null');
 
@@ -51,76 +51,76 @@ const RelationshipModel = new Class(
     },
 
     /** */
-        getFromNode: function () {
+    getFromNode() {
       return this._sourceTargetId;
     },
 
     /** */
-        getToNode: function () {
+    getToNode() {
       return this._targetTopicId;
     },
 
     /** */
-        getId: function () {
+    getId() {
       $assert(this._id, 'id is null');
       return this._id;
     },
 
     /** */
-        getLineType: function () {
+    getLineType() {
       return this._lineType;
     },
 
     /** */
-        setLineType: function (lineType) {
+    setLineType(lineType) {
       this._lineType = lineType;
     },
 
     /** */
-        getSrcCtrlPoint: function () {
+    getSrcCtrlPoint() {
       return this._srcCtrlPoint;
     },
 
     /** */
-        setSrcCtrlPoint: function (srcCtrlPoint) {
+    setSrcCtrlPoint(srcCtrlPoint) {
       this._srcCtrlPoint = srcCtrlPoint;
     },
 
     /** */
-        getDestCtrlPoint: function () {
+    getDestCtrlPoint() {
       return this._destCtrlPoint;
     },
 
     /** */
-        setDestCtrlPoint: function (destCtrlPoint) {
+    setDestCtrlPoint(destCtrlPoint) {
       this._destCtrlPoint = destCtrlPoint;
     },
 
     /** */
-        getEndArrow: function () {
+    getEndArrow() {
       return this._endArrow;
     },
 
     /** */
-        setEndArrow: function (endArrow) {
+    setEndArrow(endArrow) {
       this._endArrow = endArrow;
     },
 
     /** */
-        getStartArrow: function () {
+    getStartArrow() {
       return this._startArrow;
     },
 
     /** */
-        setStartArrow: function (startArrow) {
+    setStartArrow(startArrow) {
       this._startArrow = startArrow;
     },
 
     /**
          * @return a clone of the relationship model
          */
-        clone: function () {
-            var result = new RelationshipModel(this._sourceTargetId, this._targetTopicId);
+    clone() {
+      const result = new RelationshipModel(this._sourceTargetId, this._targetTopicId);
       result._id = this._id;
       result._lineType = this._lineType;
       result._srcCtrlPoint = this._srcCtrlPoint;
@@ -133,16 +133,16 @@ const RelationshipModel = new Class(
     /**
          * @return {String} textual information about the relationship's source and target node
          */
-        inspect: function () {
+    inspect() {
       return (
-                '(fromNode:' +
-                this.getFromNode().getId() +
-                ' , toNode: ' +
-                this.getToNode().getId() +
-                ')'
+        `(fromNode:${
+          this.getFromNode().getId()
+        } , toNode: ${
+          this.getToNode().getId()
+        })`
       );
     },
-    }
+  },
 );
 
 export default RelationshipModel;

packages/mindplot/lib/components/persistence/Beta2PelaMigrator.js

@@ -15,45 +15,45 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const ModelCodeName = require('./ModelCodeName').default
+const ModelCodeName = require('./ModelCodeName').default;
 const XMLSerializer_Pela = require('./XMLSerializer_Pela').default;
 
 const Beta2PelaMigrator = new Class({
-    initialize:function (betaSerializer) {
+  initialize(betaSerializer) {
     this._betaSerializer = betaSerializer;
     this._pelaSerializer = new XMLSerializer_Pela();
   },
 
-    toXML:function (mindmap) {
+  toXML(mindmap) {
     return this._pelaSerializer.toXML(mindmap);
   },
 
-    loadFromDom:function (dom, mapId) {
-        $assert($defined(mapId), "mapId can not be null");
-        var mindmap = this._betaSerializer.loadFromDom(dom, mapId);
+  loadFromDom(dom, mapId) {
+    $assert($defined(mapId), 'mapId can not be null');
+    const mindmap = this._betaSerializer.loadFromDom(dom, mapId);
     mindmap.setVersion(ModelCodeName.PELA);
 
     // Beta does not set position on second level nodes ...
-        var branches = mindmap.getBranches();
-        var me = this;
-        _.each(branches, function (model) {
+    const branches = mindmap.getBranches();
+    const me = this;
+    _.each(branches, (model) => {
       me._fixPosition(model);
     });
 
     return mindmap;
   },
 
-    _fixPosition:function (parentModel) {
-        var parentPos = parentModel.getPosition();
-        var isRight = parentPos.x > 0;
-        var me = this;
-        _.each(parentModel.getChildren(), function (child) {
+  _fixPosition(parentModel) {
+    const parentPos = parentModel.getPosition();
+    const isRight = parentPos.x > 0;
+    const me = this;
+    _.each(parentModel.getChildren(), (child) => {
       if (!child.getPosition()) {
         child.setPosition(parentPos.x + (50 * isRight ? 1 : -1), parentPos.y);
       }
       me._fixPosition(child);
     });
-    }
+  },
 });
 
 export default Beta2PelaMigrator;

packages/mindplot/lib/components/persistence/ModelCodeName.js

@@ -21,9 +21,9 @@
  * @enum {String}
  */
 const ModelCodeName = {
-    BETA : "beta",
-    PELA : "pela",
-    TANGO : "tango"
+  BETA: 'beta',
+  PELA: 'pela',
+  TANGO: 'tango',
 };
 
-export default ModelCodeName
+export default ModelCodeName;

packages/mindplot/lib/components/persistence/Pela2TangoMigrator.js

@@ -15,49 +15,45 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const XMLSerializer_Tango = require('./XMLSerializer_Tango').default
+const XMLSerializer_Tango = require('./XMLSerializer_Tango').default;
 const ModelCodeName = require('./ModelCodeName').default;
 
 const Pela2TangoMigrator = new Class({
-    initialize : function(pelaSerializer) {
+  initialize(pelaSerializer) {
     this._pelaSerializer = pelaSerializer;
     this._tangoSerializer = new XMLSerializer_Tango();
   },
 
-    toXML : function(mindmap) {
+  toXML(mindmap) {
     return this._tangoSerializer.toXML(mindmap);
   },
 
-    loadFromDom : function(dom, mapId) {
-        $assert($defined(mapId), "mapId can not be null");
-        var mindmap = this._pelaSerializer.loadFromDom(dom, mapId);
+  loadFromDom(dom, mapId) {
+    $assert($defined(mapId), 'mapId can not be null');
+    const mindmap = this._pelaSerializer.loadFromDom(dom, mapId);
     mindmap.setVersion(ModelCodeName.TANGO);
     this._fixOrder(mindmap);
     this._fixPosition(mindmap);
     return mindmap;
   },
 
-    _fixOrder : function(mindmap) {
+  _fixOrder(mindmap) {
     // First level node policies has been changed.
-        var centralNode = mindmap.getBranches()[0];
-        var children = centralNode.getChildren();
-        var leftNodes = [];
-        var rightNodes = [];
+    const centralNode = mindmap.getBranches()[0];
+    const children = centralNode.getChildren();
+    const leftNodes = [];
+    const rightNodes = [];
     for (var i = 0; i < children.length; i++) {
-            var child = children[i];
-            var position = child.getPosition();
+      const child = children[i];
+      const position = child.getPosition();
       if (position.x < 0) {
         leftNodes.push(child);
       } else {
         rightNodes.push(child);
       }
     }
-        rightNodes.sort(function(a, b) {
-            return a.getOrder() > b.getOrder()
-        });
-        leftNodes.sort(function(a, b) {
-            return a.getOrder() > b.getOrder();
-        });
+    rightNodes.sort((a, b) => a.getOrder() > b.getOrder());
+    leftNodes.sort((a, b) => a.getOrder() > b.getOrder());
 
     for (i = 0; i < rightNodes.length; i++) {
       rightNodes[i].setOrder(i * 2);
@@ -68,32 +64,29 @@ const Pela2TangoMigrator = new Class({
     }
   },
 
-    _fixPosition : function(mindmap) {
+  _fixPosition(mindmap) {
     // Position was not required in previous versions. Try to synthesize one .
-        var centralNode = mindmap.getBranches()[0];
-        var children = centralNode.getChildren();
-        for (var i = 0; i < children.length; i++) {
-            var child = children[i];
-            var position = child.getPosition();
-            this._fixNodePosition(child, position)
-
+    const centralNode = mindmap.getBranches()[0];
+    const children = centralNode.getChildren();
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      const position = child.getPosition();
+      this._fixNodePosition(child, position);
     }
   },
-    _fixNodePosition : function(node, parentPosition) {
+  _fixNodePosition(node, parentPosition) {
     // Position was not required in previous versions. Try to synthesize one .
-        var position = node.getPosition();
+    let position = node.getPosition();
     if (!position) {
       position = { x: parentPosition.x + 30, y: parentPosition.y };
       node.setPosition(position.x, position.y);
     }
-        var children = node.getChildren();
-        for (var i = 0; i < children.length; i++) {
-            var child = children[i];
+    const children = node.getChildren();
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
       this._fixNodePosition(child, position);
-
-        }
-
     }
+  },
 });
 
 export default Pela2TangoMigrator;

packages/mindplot/lib/components/persistence/XMLSerializerFactory.js

@@ -15,8 +15,8 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const ModelCodeName = require('./ModelCodeName').default
-const Beta2PelaMigrator = require('./Beta2PelaMigrator').default
+const ModelCodeName = require('./ModelCodeName').default;
+const Beta2PelaMigrator = require('./Beta2PelaMigrator').default;
 const Pela2TangoMigrator = require('./Pela2TangoMigrator').default;
 const XMLSerializer_Beta = require('./XMLSerializer_Beta').default;
 const XMLSerializer_Pela = require('./XMLSerializer_Pela').default;
@@ -41,8 +41,8 @@ XMLSerializerFactory.getSerializerFromMindmap = function(mindmap) {
  * @return serializer corresponding to the mindmap's version
  */
 XMLSerializerFactory.getSerializerFromDocument = function (domDocument) {
-    var rootElem = domDocument.documentElement;
-    return XMLSerializerFactory.getSerializer(rootElem.getAttribute("version"))
+  const rootElem = domDocument.documentElement;
+  return XMLSerializerFactory.getSerializer(rootElem.getAttribute('version'));
 };
 
 /**
@@ -56,16 +56,15 @@ XMLSerializerFactory.getSerializer = function(version) {
   if (!$defined(version)) {
     version = ModelCodeName.BETA;
   }
-    var codeNames = XMLSerializerFactory._codeNames;
-    var found = false;
-    var serializer = null;
-    for (var i = 0; i < codeNames.length; i++) {
+  const codeNames = XMLSerializerFactory._codeNames;
+  let found = false;
+  let serializer = null;
+  for (let i = 0; i < codeNames.length; i++) {
     if (!found) {
       found = codeNames[i].codeName == version;
-            if (found)
-                serializer = new (codeNames[i].serializer)();
+      if (found) serializer = new (codeNames[i].serializer)();
     } else {
-            var migrator = codeNames[i].migrator;
+      const { migrator } = codeNames[i];
       serializer = new migrator(serializer);
     }
   }
@@ -73,23 +72,23 @@ XMLSerializerFactory.getSerializer = function(version) {
   return serializer;
 };
 
-XMLSerializerFactory._codeNames =
-    [
+XMLSerializerFactory._codeNames = [
   {
     codeName: ModelCodeName.BETA,
     serializer: XMLSerializer_Beta,
-            migrator:function() {
-            }
+    migrator() {
+    },
   },
   {
     codeName: ModelCodeName.PELA,
     serializer: XMLSerializer_Pela,
-            migrator:Beta2PelaMigrator },
+    migrator: Beta2PelaMigrator,
+  },
   {
     codeName: ModelCodeName.TANGO,
     serializer: XMLSerializer_Tango,
-            migrator:Pela2TangoMigrator
-        }
+    migrator: Pela2TangoMigrator,
+  },
 ];
 
-export default XMLSerializerFactory
+export default XMLSerializerFactory;

packages/mindplot/lib/components/persistence/XMLSerializer_Beta.js

@@ -14,62 +14,63 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const Core = require('@wismapping/core-js')
+const Core = require('@wismapping/core-js');
+
 const core = Core();
-const ModelCodeName = require('./ModelCodeName').default
-const Mindmap = require('../model/Mindmap').default
+const ModelCodeName = require('./ModelCodeName').default;
+const Mindmap = require('../model/Mindmap').default;
 const INodeModel = require('../model/INodeModel').default;
-const TopicFeature = require('../TopicFeature').default
+const TopicFeature = require('../TopicFeature').default;
 
 const XMLSerializer_Beta = new Class({
 
-    toXML:function (mindmap) {
-        $assert(mindmap, "Can not save a null mindmap");
+  toXML(mindmap) {
+    $assert(mindmap, 'Can not save a null mindmap');
 
-        var document = core.Utils.createDocument();
+    const document = core.Utils.createDocument();
 
     // Store map attributes ...
-        var mapElem = document.createElement("map");
-        var name = mindmap.getId();
+    const mapElem = document.createElement('map');
+    const name = mindmap.getId();
     if ($defined(name)) {
       mapElem.setAttribute('name', name);
     }
     document.append(mapElem);
 
     // Create branches ...
-        var topics = mindmap.getBranches();
-        for (var i = 0; i < topics.length; i++) {
-            var topic = topics[i];
-            var topicDom = this._topicToXML(document, topic);
+    const topics = mindmap.getBranches();
+    for (let i = 0; i < topics.length; i++) {
+      const topic = topics[i];
+      const topicDom = this._topicToXML(document, topic);
       mapElem.append(topicDom);
     }
 
     return document;
   },
 
-    _topicToXML:function (document, topic) {
-        var parentTopic = document.createElement("topic");
+  _topicToXML(document, topic) {
+    const parentTopic = document.createElement('topic');
 
     // Set topic attributes...
     if (topic.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
-            parentTopic.setAttribute("central", true);
+      parentTopic.setAttribute('central', true);
     } else {
-            var parent = topic.getParent();
+      const parent = topic.getParent();
       if (parent == null || parent.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
-                var pos = topic.getPosition();
-                parentTopic.setAttribute("position", pos.x + ',' + pos.y);
+        const pos = topic.getPosition();
+        parentTopic.setAttribute('position', `${pos.x},${pos.y}`);
       } else {
-                var order = topic.getOrder();
-                parentTopic.setAttribute("order", order);
+        const order = topic.getOrder();
+        parentTopic.setAttribute('order', order);
       }
     }
 
-        var text = topic.getText();
+    const text = topic.getText();
     if ($defined(text)) {
       parentTopic.setAttribute('text', text);
     }
 
-        var shape = topic.getShapeType();
+    const shape = topic.getShapeType();
     if ($defined(shape)) {
       parentTopic.setAttribute('shape', shape);
     }
@@ -79,113 +80,112 @@ const  XMLSerializer_Beta = new Class({
     }
 
     // Font properties ...
-        var font = "";
+    let font = '';
 
-        var fontFamily = topic.getFontFamily();
-        font += (fontFamily ? fontFamily : '') + ';';
+    const fontFamily = topic.getFontFamily();
+    font += `${fontFamily || ''};`;
 
-        var fontSize = topic.getFontSize();
-        font += (fontSize ? fontSize : '') + ';';
+    const fontSize = topic.getFontSize();
+    font += `${fontSize || ''};`;
 
-        var fontColor = topic.getFontColor();
-        font += (fontColor ? fontColor : '') + ';';
+    const fontColor = topic.getFontColor();
+    font += `${fontColor || ''};`;
 
-        var fontWeight = topic.getFontWeight();
-        font += (fontWeight ? fontWeight : '') + ';';
+    const fontWeight = topic.getFontWeight();
+    font += `${fontWeight || ''};`;
 
-        var fontStyle = topic.getFontStyle();
-        font += (fontStyle ? fontStyle : '') + ';';
+    const fontStyle = topic.getFontStyle();
+    font += `${fontStyle || ''};`;
 
     if ($defined(fontFamily) || $defined(fontSize) || $defined(fontColor)
             || $defined(fontWeight) || $defined(fontStyle)) {
       parentTopic.setAttribute('fontStyle', font);
     }
 
-        var bgColor = topic.getBackgroundColor();
+    const bgColor = topic.getBackgroundColor();
     if ($defined(bgColor)) {
       parentTopic.setAttribute('bgColor', bgColor);
     }
 
-        var brColor = topic.getBorderColor();
+    const brColor = topic.getBorderColor();
     if ($defined(brColor)) {
       parentTopic.setAttribute('brColor', brColor);
     }
 
     // ICONS
-        var i;
-        var icons = topic.getIcons();
+    let i;
+    const icons = topic.getIcons();
     for (i = 0; i < icons.length; i++) {
-            var icon = icons[i];
-            var iconDom = this._iconToXML(document, icon);
+      const icon = icons[i];
+      const iconDom = this._iconToXML(document, icon);
       parentTopic.append(iconDom);
     }
 
     // LINKS
-        var links = topic.getLinks();
+    const links = topic.getLinks();
     for (i = 0; i < links.length; i++) {
-            var link = links[i];
-            var linkDom = this._linkToXML(document, link);
+      const link = links[i];
+      const linkDom = this._linkToXML(document, link);
       parentTopic.append(linkDom);
     }
 
-        var notes = topic.getNotes();
+    const notes = topic.getNotes();
     for (i = 0; i < notes.length; i++) {
-            var note = notes[i];
-            var noteDom = this._noteToXML(document, note);
+      const note = notes[i];
+      const noteDom = this._noteToXML(document, note);
       parentTopic.append(noteDom);
     }
 
     // CHILDREN TOPICS
-        var childTopics = topic.getChildren();
+    const childTopics = topic.getChildren();
     for (i = 0; i < childTopics.length; i++) {
-            var childTopic = childTopics[i];
-            var childDom = this._topicToXML(document, childTopic);
+      const childTopic = childTopics[i];
+      const childDom = this._topicToXML(document, childTopic);
       parentTopic.append(childDom);
-
     }
 
     return parentTopic;
   },
 
-    _iconToXML:function (document, icon) {
-        var iconDom = document.createElement("icon");
+  _iconToXML(document, icon) {
+    const iconDom = document.createElement('icon');
     iconDom.setAttribute('id', icon.getIconType());
     return iconDom;
   },
 
-    _linkToXML:function (document, link) {
-        var linkDom = document.createElement("link");
+  _linkToXML(document, link) {
+    const linkDom = document.createElement('link');
     linkDom.setAttribute('url', link.getUrl());
     return linkDom;
   },
 
-    _noteToXML:function (document, note) {
-        var noteDom = document.createElement("note");
+  _noteToXML(document, note) {
+    const noteDom = document.createElement('note');
     noteDom.setAttribute('text', note.getText());
     return noteDom;
   },
 
-    loadFromDom:function (dom, mapId) {
-        $assert(dom, "Dom can not be null");
-        $assert(mapId, "mapId can not be null");
+  loadFromDom(dom, mapId) {
+    $assert(dom, 'Dom can not be null');
+    $assert(mapId, 'mapId can not be null');
 
     // Is a valid object ?
-        var documentElement = dom.documentElement;
-        $assert(documentElement.nodeName != "parsererror", "Error while parsing: '" + documentElement.childNodes[0].nodeValue);
+    const { documentElement } = dom;
+    $assert(documentElement.nodeName != 'parsererror', `Error while parsing: '${documentElement.childNodes[0].nodeValue}`);
 
     // Is a wisemap?.
-        $assert(documentElement.tagName == XMLSerializer_Beta.MAP_ROOT_NODE, "This seem not to be a map document. Root Tag: '" + documentElement.tagName + ",',HTML:" +dom.innerHTML + ",XML:"+ core.Utils.innerXML(dom));
+    $assert(documentElement.tagName == XMLSerializer_Beta.MAP_ROOT_NODE, `This seem not to be a map document. Root Tag: '${documentElement.tagName},',HTML:${dom.innerHTML},XML:${core.Utils.innerXML(dom)}`);
 
     // Start the loading process ...
-        var version = documentElement.getAttribute("version");
+    let version = documentElement.getAttribute('version');
     version = !$defined(version) ? ModelCodeName.BETA : version;
-        var mindmap = new Mindmap(mapId, version);
+    const mindmap = new Mindmap(mapId, version);
 
-        var children = documentElement.childNodes;
-        for (var i = 0; i < children.length; i++) {
-            var child = children[i];
+    const children = documentElement.childNodes;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
       if (child.nodeType == 1) {
-                var topic = this._deserializeNode(child, mindmap);
+        const topic = this._deserializeNode(child, mindmap);
         mindmap.addBranch(topic);
       }
     }
@@ -193,34 +193,34 @@ const  XMLSerializer_Beta = new Class({
     return mindmap;
   },
 
-    _deserializeNode:function (domElem, mindmap) {
-        var type = (domElem.getAttribute('central') != null) ? INodeModel.CENTRAL_TOPIC_TYPE : INodeModel.MAIN_TOPIC_TYPE;
-        var topic = mindmap.createNode(type);
+  _deserializeNode(domElem, mindmap) {
+    const type = (domElem.getAttribute('central') != null) ? INodeModel.CENTRAL_TOPIC_TYPE : INodeModel.MAIN_TOPIC_TYPE;
+    const topic = mindmap.createNode(type);
 
     // Load attributes...
-        var text = domElem.getAttribute('text');
+    const text = domElem.getAttribute('text');
     if ($defined(text)) {
       topic.setText(text);
     }
 
-        var order = domElem.getAttribute('order');
+    const order = domElem.getAttribute('order');
     if ($defined(order)) {
       topic.setOrder(parseInt(order));
     }
 
-        var shape = domElem.getAttribute('shape');
+    const shape = domElem.getAttribute('shape');
     if ($defined(shape)) {
       topic.setShapeType(shape);
     }
 
-        var isShrink = domElem.getAttribute('shrink');
+    const isShrink = domElem.getAttribute('shrink');
     if ($defined(isShrink)) {
       topic.setChildrenShrunken(isShrink);
     }
 
-        var fontStyle = domElem.getAttribute('fontStyle');
+    const fontStyle = domElem.getAttribute('fontStyle');
     if ($defined(fontStyle)) {
-            var font = fontStyle.split(';');
+      const font = fontStyle.split(';');
 
       if (font[0]) {
         topic.setFontFamily(font[0]);
@@ -243,39 +243,39 @@ const  XMLSerializer_Beta = new Class({
       }
     }
 
-        var bgColor = domElem.getAttribute('bgColor');
+    const bgColor = domElem.getAttribute('bgColor');
     if ($defined(bgColor)) {
       topic.setBackgroundColor(bgColor);
     }
 
-        var borderColor = domElem.getAttribute('brColor');
+    const borderColor = domElem.getAttribute('brColor');
     if ($defined(borderColor)) {
       topic.setBorderColor(borderColor);
     }
 
-        var position = domElem.getAttribute('position');
+    const position = domElem.getAttribute('position');
     if ($defined(position)) {
-            var pos = position.split(',');
+      const pos = position.split(',');
       topic.setPosition(pos[0], pos[1]);
     }
 
     // Creating icons and children nodes
-        var children = domElem.childNodes;
-        for (var i = 0; i < children.length; i++) {
-            var child = children[i];
+    const children = domElem.childNodes;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
       if (child.nodeType == 1) {
-                $assert(child.tagName == "topic" || child.tagName == "icon" || child.tagName == "link" || child.tagName == "note", 'Illegal node type:' + child.tagName);
-                if (child.tagName == "topic") {
-                    var childTopic = this._deserializeNode(child, mindmap);
+        $assert(child.tagName == 'topic' || child.tagName == 'icon' || child.tagName == 'link' || child.tagName == 'note', `Illegal node type:${child.tagName}`);
+        if (child.tagName == 'topic') {
+          const childTopic = this._deserializeNode(child, mindmap);
           childTopic.connectTo(topic);
-                } else if (child.tagName == "icon") {
-                    var icon = this._deserializeIcon(child, topic);
+        } else if (child.tagName == 'icon') {
+          const icon = this._deserializeIcon(child, topic);
           topic.addFeature(icon);
-                } else if (child.tagName == "link") {
-                    var link = this._deserializeLink(child, topic);
+        } else if (child.tagName == 'link') {
+          const link = this._deserializeLink(child, topic);
           topic.addFeature(link);
-                } else if (child.tagName == "note") {
-                    var note = this._deserializeNote(child, topic);
+        } else if (child.tagName == 'note') {
+          const note = this._deserializeNote(child, topic);
           topic.addFeature(note);
         }
       }
@@ -284,20 +284,21 @@ const  XMLSerializer_Beta = new Class({
     return topic;
   },
 
-    _deserializeIcon:function (domElem) {
-        var icon = domElem.getAttribute("id");
-        icon = icon.replace("images/", "icons/legacy/");
+  _deserializeIcon(domElem) {
+    let icon = domElem.getAttribute('id');
+    icon = icon.replace('images/', 'icons/legacy/');
     return TopicFeature.createModel(TopicFeature.Icon.id, { id: icon });
   },
 
-    _deserializeLink:function (domElem) {
-        return  TopicFeature.createModel(TopicFeature.Link.id, {url:domElem.getAttribute("url")});
+  _deserializeLink(domElem) {
+    return TopicFeature.createModel(TopicFeature.Link.id, { url: domElem.getAttribute('url') });
   },
 
-    _deserializeNote:function (domElem) {
-        var text = domElem.getAttribute("text");
-        return  TopicFeature.createModel(TopicFeature.Note.id, {text:text == null ? " " : text});
-    }});
+  _deserializeNote(domElem) {
+    const text = domElem.getAttribute('text');
+    return TopicFeature.createModel(TopicFeature.Note.id, { text: text == null ? ' ' : text });
+  },
+});
 
 XMLSerializer_Beta.MAP_ROOT_NODE = 'map';
 

packages/mindplot/lib/components/persistence/XMLSerializer_Pela.js

@@ -15,12 +15,13 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-const Core = require('@wismapping/core-js')
+const Core = require('@wismapping/core-js');
+
 const core = Core();
-const Mindmap = require('../model/Mindmap').default
+const Mindmap = require('../model/Mindmap').default;
 const INodeModel = require('../model/INodeModel').default;
 const { TopicShape } = require('../model/INodeModel');
-const TopicFeature = require('../TopicFeature').default
+const TopicFeature = require('../TopicFeature').default;
 const ConnectionLine = require('../ConnectionLine').default;
 
 /**
@@ -33,18 +34,18 @@ const XMLSerializer_Pela = new Class(
          * @throws will throw an error if mindmap is null or undefined
          * @return the created XML document (using the cross-browser implementation in core)
          */
-        toXML: function (mindmap) {
+    toXML(mindmap) {
       $assert(mindmap, 'Can not save a null mindmap');
 
-            var document = core.Utils.createDocument();
+      const document = core.Utils.createDocument();
 
       // Store map attributes ...
-            var mapElem = document.createElement('map');
-            var name = mindmap.getId();
+      const mapElem = document.createElement('map');
+      const name = mindmap.getId();
       if ($defined(name)) {
         mapElem.setAttribute('name', this.rmXmlInv(name));
       }
-            var version = mindmap.getVersion();
+      const version = mindmap.getVersion();
       if ($defined(version)) {
         mapElem.setAttribute('version', version);
       }
@@ -52,24 +53,24 @@ const XMLSerializer_Pela = new Class(
       document.appendChild(mapElem);
 
       // Create branches ...
-            var topics = mindmap.getBranches();
-            for (var i = 0; i < topics.length; i++) {
-                var topic = topics[i];
-                var topicDom = this._topicToXML(document, topic);
+      const topics = mindmap.getBranches();
+      for (let i = 0; i < topics.length; i++) {
+        const topic = topics[i];
+        const topicDom = this._topicToXML(document, topic);
         mapElem.appendChild(topicDom);
       }
 
       // Create Relationships
-            var relationships = mindmap.getRelationships();
+      const relationships = mindmap.getRelationships();
       if (relationships.length > 0) {
-                for (var j = 0; j < relationships.length; j++) {
-                    var relationship = relationships[j];
+        for (let j = 0; j < relationships.length; j++) {
+          const relationship = relationships[j];
           if (
-                        mindmap.findNodeById(relationship.getFromNode()) !== null &&
-                        mindmap.findNodeById(relationship.getToNode()) !== null
+            mindmap.findNodeById(relationship.getFromNode()) !== null
+                        && mindmap.findNodeById(relationship.getToNode()) !== null
           ) {
             // Isolated relationships are not persisted ....
-                        var relationDom = this._relationshipToXML(document, relationship);
+            const relationDom = this._relationshipToXML(document, relationship);
             mapElem.appendChild(relationDom);
           }
         }
@@ -78,108 +79,107 @@ const XMLSerializer_Pela = new Class(
       return document;
     },
 
-        _topicToXML: function (document, topic) {
-            var parentTopic = document.createElement('topic');
+    _topicToXML(document, topic) {
+      const parentTopic = document.createElement('topic');
 
       // Set topic attributes...
       if (topic.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
         parentTopic.setAttribute('central', 'true');
       } else {
-                var pos = topic.getPosition();
-                parentTopic.setAttribute('position', pos.x + ',' + pos.y);
+        const pos = topic.getPosition();
+        parentTopic.setAttribute('position', `${pos.x},${pos.y}`);
 
-                var order = topic.getOrder();
-                if (typeof order === 'number' && isFinite(order))
-                    parentTopic.setAttribute('order', order);
+        const order = topic.getOrder();
+        if (typeof order === 'number' && isFinite(order)) parentTopic.setAttribute('order', order);
       }
 
-            var text = topic.getText();
+      const text = topic.getText();
       if ($defined(text)) {
         this._noteTextToXML(document, parentTopic, text);
       }
 
-            var shape = topic.getShapeType();
+      const shape = topic.getShapeType();
       if ($defined(shape)) {
         parentTopic.setAttribute('shape', shape);
 
         if (shape == TopicShape.IMAGE) {
           parentTopic.setAttribute(
             'image',
-                        topic.getImageSize().width +
-                            ',' +
-                            topic.getImageSize().height +
-                            ':' +
-                            topic.getImageUrl()
+            `${topic.getImageSize().width
+            },${
+              topic.getImageSize().height
+            }:${
+              topic.getImageUrl()}`,
           );
         }
       }
 
       if (
-                topic.areChildrenShrunken() &&
-                topic.getType() != INodeModel.CENTRAL_TOPIC_TYPE
+        topic.areChildrenShrunken()
+                && topic.getType() != INodeModel.CENTRAL_TOPIC_TYPE
       ) {
         parentTopic.setAttribute('shrink', 'true');
       }
 
       // Font properties ...
-            var id = topic.getId();
+      const id = topic.getId();
       parentTopic.setAttribute('id', id);
 
-            var font = '';
+      let font = '';
 
-            var fontFamily = topic.getFontFamily();
-            font += (fontFamily ? fontFamily : '') + ';';
+      const fontFamily = topic.getFontFamily();
+      font += `${fontFamily || ''};`;
 
-            var fontSize = topic.getFontSize();
-            font += (fontSize ? fontSize : '') + ';';
+      const fontSize = topic.getFontSize();
+      font += `${fontSize || ''};`;
 
-            var fontColor = topic.getFontColor();
-            font += (fontColor ? fontColor : '') + ';';
+      const fontColor = topic.getFontColor();
+      font += `${fontColor || ''};`;
 
-            var fontWeight = topic.getFontWeight();
-            font += (fontWeight ? fontWeight : '') + ';';
+      const fontWeight = topic.getFontWeight();
+      font += `${fontWeight || ''};`;
 
-            var fontStyle = topic.getFontStyle();
-            font += (fontStyle ? fontStyle : '') + ';';
+      const fontStyle = topic.getFontStyle();
+      font += `${fontStyle || ''};`;
 
       if (
-                $defined(fontFamily) ||
-                $defined(fontSize) ||
-                $defined(fontColor) ||
-                $defined(fontWeight) ||
-                $defined(fontStyle)
+        $defined(fontFamily)
+                || $defined(fontSize)
+                || $defined(fontColor)
+                || $defined(fontWeight)
+                || $defined(fontStyle)
       ) {
         parentTopic.setAttribute('fontStyle', font);
       }
 
-            var bgColor = topic.getBackgroundColor();
+      const bgColor = topic.getBackgroundColor();
       if ($defined(bgColor)) {
         parentTopic.setAttribute('bgColor', bgColor);
       }
 
-            var brColor = topic.getBorderColor();
+      const brColor = topic.getBorderColor();
       if ($defined(brColor)) {
         parentTopic.setAttribute('brColor', brColor);
       }
 
-            var metadata = topic.getMetadata();
+      const metadata = topic.getMetadata();
       if ($defined(metadata)) {
         parentTopic.setAttribute('metadata', metadata);
       }
 
       // Serialize features ...
-            var features = topic.getFeatures();
-            for (var i = 0; i < features.length; i++) {
-                var feature = features[i];
+      const features = topic.getFeatures();
+      for (let i = 0; i < features.length; i++) {
+        const feature = features[i];
 
-                var featureType = feature.getType();
-                var featureDom = document.createElement(featureType);
-                var attributes = feature.getAttributes();
+        const featureType = feature.getType();
+        const featureDom = document.createElement(featureType);
+        const attributes = feature.getAttributes();
 
-                for (var key in attributes) {
-                    var value = attributes[key];
+        for (const key in attributes) {
+          const value = attributes[key];
           if (key == 'text') {
-                        var cdata = document.createCDATASection(this.rmXmlInv(value));
+            const cdata = document.createCDATASection(this.rmXmlInv(value));
             featureDom.appendChild(cdata);
           } else {
             featureDom.setAttribute(key, this.rmXmlInv(value));
@@ -189,49 +189,49 @@ const XMLSerializer_Pela = new Class(
       }
 
       // CHILDREN TOPICS
-            var childTopics = topic.getChildren();
-            for (var j = 0; j < childTopics.length; j++) {
-                var childTopic = childTopics[j];
-                var childDom = this._topicToXML(document, childTopic);
+      const childTopics = topic.getChildren();
+      for (let j = 0; j < childTopics.length; j++) {
+        const childTopic = childTopics[j];
+        const childDom = this._topicToXML(document, childTopic);
         parentTopic.appendChild(childDom);
       }
       return parentTopic;
     },
 
-        _noteTextToXML: function (document, elem, text) {
+    _noteTextToXML(document, elem, text) {
       if (text.indexOf('\n') == -1) {
         elem.setAttribute('text', this.rmXmlInv(text));
       } else {
-                var textDom = document.createElement('text');
-                var cdata = document.createCDATASection(this.rmXmlInv(text));
+        const textDom = document.createElement('text');
+        const cdata = document.createCDATASection(this.rmXmlInv(text));
         textDom.appendChild(cdata);
         elem.appendChild(textDom);
       }
     },
 
-        _relationshipToXML: function (document, relationship) {
-            var result = document.createElement('relationship');
+    _relationshipToXML(document, relationship) {
+      const result = document.createElement('relationship');
       result.setAttribute('srcTopicId', relationship.getFromNode());
       result.setAttribute('destTopicId', relationship.getToNode());
 
-            var lineType = relationship.getLineType();
+      const lineType = relationship.getLineType();
       result.setAttribute('lineType', lineType);
       if (
-                lineType == ConnectionLine.CURVED ||
-                lineType == ConnectionLine.SIMPLE_CURVED
+        lineType == ConnectionLine.CURVED
+                || lineType == ConnectionLine.SIMPLE_CURVED
       ) {
         if ($defined(relationship.getSrcCtrlPoint())) {
-                    var srcPoint = relationship.getSrcCtrlPoint();
+          const srcPoint = relationship.getSrcCtrlPoint();
           result.setAttribute(
             'srcCtrlPoint',
-                        Math.round(srcPoint.x) + ',' + Math.round(srcPoint.y)
+            `${Math.round(srcPoint.x)},${Math.round(srcPoint.y)}`,
           );
         }
         if ($defined(relationship.getDestCtrlPoint())) {
-                    var destPoint = relationship.getDestCtrlPoint();
+          const destPoint = relationship.getDestCtrlPoint();
           result.setAttribute(
             'destCtrlPoint',
-                        Math.round(destPoint.x) + ',' + Math.round(destPoint.y)
+            `${Math.round(destPoint.x)},${Math.round(destPoint.y)}`,
           );
         }
       }
@@ -248,26 +248,26 @@ const XMLSerializer_Pela = new Class(
          * @throws will throw an error if the document element is not consistent with a wisemap's root
          * element
          */
-        loadFromDom: function (dom, mapId) {
+    loadFromDom(dom, mapId) {
       $assert(dom, 'dom can not be null');
       $assert(mapId, 'mapId can not be null');
 
-            var rootElem = dom.documentElement;
+      const rootElem = dom.documentElement;
 
       // Is a wisemap?.
       $assert(
         rootElem.tagName == XMLSerializer_Pela.MAP_ROOT_NODE,
-                'This seem not to be a map document.'
+        'This seem not to be a map document.',
       );
 
       this._idsMap = {};
       // Start the loading process ...
-            var version = rootElem.getAttribute('version');
+      const version = rootElem.getAttribute('version');
 
-            var mindmap = new Mindmap(mapId, version);
-            var children = rootElem.childNodes;
-            for (var i = 0; i < children.length; i++) {
-                var child = children[i];
+      const mindmap = new Mindmap(mapId, version);
+      const children = rootElem.childNodes;
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
         if (child.nodeType == 1) {
           switch (child.tagName) {
             case 'topic':
@@ -286,14 +286,13 @@ const XMLSerializer_Pela = new Class(
       return mindmap;
     },
 
-        _deserializeNode: function (domElem, mindmap) {
-            var type =
-                domElem.getAttribute('central') != null
+    _deserializeNode(domElem, mindmap) {
+      const type = domElem.getAttribute('central') != null
         ? INodeModel.CENTRAL_TOPIC_TYPE
         : INodeModel.MAIN_TOPIC_TYPE;
 
       // Load attributes...
-            var id = domElem.getAttribute('id');
+      let id = domElem.getAttribute('id');
       if ($defined(id)) {
         id = parseInt(id);
       }
@@ -304,17 +303,17 @@ const XMLSerializer_Pela = new Class(
         this._idsMap[id] = domElem;
       }
 
-            var topic = mindmap.createNode(type, id);
+      const topic = mindmap.createNode(type, id);
 
       // Set text property is it;s defined...
-            var text = domElem.getAttribute('text');
+      const text = domElem.getAttribute('text');
       if ($defined(text) && text) {
         topic.setText(text);
       }
 
-            var fontStyle = domElem.getAttribute('fontStyle');
+      const fontStyle = domElem.getAttribute('fontStyle');
       if ($defined(fontStyle) && fontStyle) {
-                var font = fontStyle.split(';');
+        const font = fontStyle.split(';');
 
         if (font[0]) {
           topic.setFontFamily(font[0]);
@@ -337,83 +336,83 @@ const XMLSerializer_Pela = new Class(
         }
       }
 
-            var shape = domElem.getAttribute('shape');
+      const shape = domElem.getAttribute('shape');
       if ($defined(shape)) {
         topic.setShapeType(shape);
 
         if (shape == TopicShape.IMAGE) {
-                    var image = domElem.getAttribute('image');
-                    var size = image.substring(0, image.indexOf(':'));
-                    var url = image.substring(image.indexOf(':') + 1, image.length);
+          const image = domElem.getAttribute('image');
+          const size = image.substring(0, image.indexOf(':'));
+          const url = image.substring(image.indexOf(':') + 1, image.length);
           topic.setImageUrl(url);
 
-                    var split = size.split(',');
+          const split = size.split(',');
           topic.setImageSize(split[0], split[1]);
         }
       }
 
-            var bgColor = domElem.getAttribute('bgColor');
+      const bgColor = domElem.getAttribute('bgColor');
       if ($defined(bgColor)) {
         topic.setBackgroundColor(bgColor);
       }
 
-            var borderColor = domElem.getAttribute('brColor');
+      const borderColor = domElem.getAttribute('brColor');
       if ($defined(borderColor)) {
         topic.setBorderColor(borderColor);
       }
 
-            var order = domElem.getAttribute('order');
+      const order = domElem.getAttribute('order');
       if ($defined(order) && order != 'NaN') {
         // Hack for broken maps ...
         topic.setOrder(parseInt(order));
       }
 
-            var isShrink = domElem.getAttribute('shrink');
+      const isShrink = domElem.getAttribute('shrink');
       // Hack: Some production maps has been stored with the central topic collapsed. This is a bug.
       if ($defined(isShrink) && type != INodeModel.CENTRAL_TOPIC_TYPE) {
         topic.setChildrenShrunken(isShrink);
       }
 
-            var position = domElem.getAttribute('position');
+      const position = domElem.getAttribute('position');
       if ($defined(position)) {
-                var pos = position.split(',');
+        const pos = position.split(',');
         topic.setPosition(pos[0], pos[1]);
       }
 
-            var metadata = domElem.getAttribute('metadata');
+      const metadata = domElem.getAttribute('metadata');
       if ($defined(metadata)) {
         topic.setMetadata(metadata);
       }
 
       // Creating icons and children nodes
-            var children = domElem.childNodes;
-            for (var i = 0; i < children.length; i++) {
-                var child = children[i];
+      const children = domElem.childNodes;
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
         if (child.nodeType == Node.ELEMENT_NODE) {
           if (child.tagName == 'topic') {
-                        var childTopic = this._deserializeNode(child, mindmap);
+            const childTopic = this._deserializeNode(child, mindmap);
             childTopic.connectTo(topic);
           } else if (TopicFeature.isSupported(child.tagName)) {
             // Load attributes ...
-                        var namedNodeMap = child.attributes;
-                        var attributes = {};
-                        for (var j = 0; j < namedNodeMap.length; j++) {
-                            var attribute = namedNodeMap.item(j);
+            const namedNodeMap = child.attributes;
+            const attributes = {};
+            for (let j = 0; j < namedNodeMap.length; j++) {
+              const attribute = namedNodeMap.item(j);
               attributes[attribute.name] = attribute.value;
             }
 
             // Has text node ?.
-                        var textAttr = this._deserializeTextAttr(child);
+            const textAttr = this._deserializeTextAttr(child);
             if (textAttr) {
-                            attributes['text'] = textAttr;
+              attributes.text = textAttr;
             }
 
             // Create a new element ....
-                        var featureType = child.tagName;
-                        var feature = TopicFeature.createModel(featureType, attributes);
+            const featureType = child.tagName;
+            const feature = TopicFeature.createModel(featureType, attributes);
             topic.addFeature(feature);
           } else if (child.tagName == 'text') {
-                        var nodeText = this._deserializeNodeText(child);
+            const nodeText = this._deserializeNodeText(child);
             topic.setText(nodeText);
           }
         }
@@ -421,12 +420,12 @@ const XMLSerializer_Pela = new Class(
       return topic;
     },
 
-        _deserializeTextAttr: function (domElem) {
-            var value = domElem.getAttribute('text');
+    _deserializeTextAttr(domElem) {
+      let value = domElem.getAttribute('text');
       if (!$defined(value)) {
-                var children = domElem.childNodes;
-                for (var i = 0; i < children.length; i++) {
-                    var child = children[i];
+        const children = domElem.childNodes;
+        for (let i = 0; i < children.length; i++) {
+          const child = children[i];
           if (child.nodeType == Node.CDATA_SECTION_NODE) {
             value = child.nodeValue;
           }
@@ -444,11 +443,11 @@ const XMLSerializer_Pela = new Class(
       return value;
     },
 
-        _deserializeNodeText: function (domElem) {
-            var children = domElem.childNodes;
-            var value = null;
-            for (var i = 0; i < children.length; i++) {
-                var child = children[i];
+    _deserializeNodeText(domElem) {
+      const children = domElem.childNodes;
+      let value = null;
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
         if (child.nodeType == Node.CDATA_SECTION_NODE) {
           value = child.nodeValue;
         }
@@ -456,14 +455,14 @@ const XMLSerializer_Pela = new Class(
       return value;
     },
 
-        _deserializeRelationship: function (domElement, mindmap) {
-            var srcId = domElement.getAttribute('srcTopicId');
-            var destId = domElement.getAttribute('destTopicId');
-            var lineType = domElement.getAttribute('lineType');
-            var srcCtrlPoint = domElement.getAttribute('srcCtrlPoint');
-            var destCtrlPoint = domElement.getAttribute('destCtrlPoint');
-            var endArrow = domElement.getAttribute('endArrow');
-            var startArrow = domElement.getAttribute('startArrow');
+    _deserializeRelationship(domElement, mindmap) {
+      const srcId = domElement.getAttribute('srcTopicId');
+      const destId = domElement.getAttribute('destTopicId');
+      const lineType = domElement.getAttribute('lineType');
+      const srcCtrlPoint = domElement.getAttribute('srcCtrlPoint');
+      const destCtrlPoint = domElement.getAttribute('destCtrlPoint');
+      const endArrow = domElement.getAttribute('endArrow');
+      const startArrow = domElement.getAttribute('startArrow');
       // If for some reason a relationship lines has source and dest nodes the same, don't import it.
       if (srcId == destId) {
         return null;
@@ -473,7 +472,7 @@ const XMLSerializer_Pela = new Class(
         return null;
       }
 
-            var model = mindmap.createRelationship(srcId, destId);
+      const model = mindmap.createRelationship(srcId, destId);
       model.setLineType(lineType);
       if ($defined(srcCtrlPoint) && srcCtrlPoint != '') {
         model.setSrcCtrlPoint(core.Point.fromString(srcCtrlPoint));
@@ -497,26 +496,26 @@ const XMLSerializer_Pela = new Class(
          * @param in The String whose non-valid characters we want to remove.
          * @return The in String, stripped of non-valid characters.
          */
-        rmXmlInv: function (str) {
+    rmXmlInv(str) {
       if (str == null || str == undefined) return null;
 
-            var result = '';
-            for (var i = 0; i < str.length; i++) {
-                var c = str.charCodeAt(i);
+      let result = '';
+      for (let i = 0; i < str.length; i++) {
+        const c = str.charCodeAt(i);
         if (
-                    c == 0x9 ||
-                    c == 0xa ||
-                    c == 0xd ||
-                    (c >= 0x20 && c <= 0xd7ff) ||
-                    (c >= 0xe000 && c <= 0xfffd) ||
-                    (c >= 0x10000 && c <= 0x10ffff)
+          c == 0x9
+                    || c == 0xa
+                    || c == 0xd
+                    || (c >= 0x20 && c <= 0xd7ff)
+                    || (c >= 0xe000 && c <= 0xfffd)
+                    || (c >= 0x10000 && c <= 0x10ffff)
         ) {
-                    result = result + str.charAt(i);
+          result += str.charAt(i);
         }
       }
       return result;
     },
-    }
+  },
 );
 
 /**

packages/mindplot/lib/components/persistence/XMLSerializer_Tango.js

@@ -24,7 +24,7 @@ const XMLSerializer_Pela = require('./XMLSerializer_Pela').default;
  * @extends mindplot.persistence.XMLSerializer_Pela
  */
 const XMLSerializer_Tango = new Class({
-    Extends: XMLSerializer_Pela
+  Extends: XMLSerializer_Pela,
 });
 
-export default XMLSerializer_Tango
+export default XMLSerializer_Tango;