@linkurious/ogma-linkurious-parser 3.1.12 → 4.0.0

package/dist/ogma/features/styles.js

@@ -1,19 +1,8 @@
 'use strict';
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var __1 = require("../..");
-var tools_1 = require("../../tools/tools");
-var HOVERED_SELECTED_NODE_STYLE = {
+const __1 = require("../..");
+const tools_1 = require("../../tools/tools");
+const HOVERED_SELECTED_NODE_STYLE = {
     text: {
         style: 'bold',
         backgroundColor: '#fff',
@@ -22,7 +11,7 @@ var HOVERED_SELECTED_NODE_STYLE = {
     outerStroke: { width: 2 },
     outline: false
 };
-var HOVERED_SELECTED_EDGE_STYLE = {
+const HOVERED_SELECTED_EDGE_STYLE = {
     text: {
         style: 'bold',
         backgroundColor: '#fff',
@@ -30,25 +19,25 @@ var HOVERED_SELECTED_EDGE_STYLE = {
     },
     outline: false
 };
-var NODE_HALO_CONFIGURATION = {
+const NODE_HALO_CONFIGURATION = {
     color: '#FFF',
     width: 7,
     scalingMethod: 'scaled',
     strokeWidth: 0,
     hideNonAdjacentEdges: false
 };
-var EDGE_HALO_CONFIGURATION = {
+const EDGE_HALO_CONFIGURATION = {
     color: '#FFF',
     scalingMethod: 'scaled',
     width: 4
 };
-var DEFAULT_OGMA_FONT = "'roboto', sans-serif";
-var DARK_FONT_COLOR = '#000';
-var CLEAR_FONT_COLOR = '#FFF';
-var ITEM_DEFAULT_COLOR = '#7f7f7f';
+const DEFAULT_OGMA_FONT = "'roboto', sans-serif";
+const DARK_FONT_COLOR = '#000';
+const CLEAR_FONT_COLOR = '#FFF';
+const ITEM_DEFAULT_COLOR = '#7f7f7f';
 exports.FILTER_OPACITY = 0.2;
-var StylesViz = /** @class */ (function () {
-    function StylesViz(ogma, configuration) {
+class StylesViz {
+    constructor(ogma, configuration) {
         this._nodeAttributes = new __1.NodeAttributes({});
         this._edgeAttributes = new __1.EdgeAttributes({});
         this._ogma = ogma;
@@ -57,7 +46,7 @@ var StylesViz = /** @class */ (function () {
     /**
      * Set nodes default styles based on the configuration
      */
-    StylesViz.prototype.setNodesDefaultStyles = function () {
+    setNodesDefaultStyles() {
         // setting selection and hover attributes
         this._ogma.styles.setHoveredNodeAttributes(HOVERED_SELECTED_NODE_STYLE);
         this._ogma.styles.setSelectedNodeAttributes(HOVERED_SELECTED_NODE_STYLE);
@@ -65,6 +54,7 @@ var StylesViz = /** @class */ (function () {
         this._nodeDefaultStylesRules = this._ogma.styles.addRule({
             nodeAttributes: {
                 text: {
+                    padding: 5,
                     minVisibleSize: this._defaultConfiguration.node.text !== undefined &&
                         this._defaultConfiguration.node.text.minVisibleSize
                         ? this._defaultConfiguration.node.text.minVisibleSize
@@ -109,11 +99,11 @@ var StylesViz = /** @class */ (function () {
                 outline: false
             }
         });
-    };
+    }
     /**
      * Set edges default styles based on the configuration
      */
-    StylesViz.prototype.setEdgesDefaultStyles = function () {
+    setEdgesDefaultStyles() {
         // setting selection and hover attributes
         this._ogma.styles.setHoveredEdgeAttributes(HOVERED_SELECTED_EDGE_STYLE);
         this._ogma.styles.setSelectedEdgeAttributes(HOVERED_SELECTED_EDGE_STYLE);
@@ -154,23 +144,22 @@ var StylesViz = /** @class */ (function () {
                 color: ITEM_DEFAULT_COLOR
             }
         });
-    };
+    }
     /**
      * Set nodes default styles based on the configuration
      */
-    StylesViz.prototype.setNodesDefaultHalo = function () {
-        var _this = this;
+    setNodesDefaultHalo() {
         // setting default halo style
         this._nodeDefaultHaloRules = this._ogma.styles.addRule({
-            nodeSelector: function (node) { return node && !node.hasClass('filtered'); },
+            nodeSelector: (node) => node && !node.hasClass('filtered'),
             nodeAttributes: {
-                halo: function (node) {
+                halo: (node) => {
                     if (node !== undefined &&
                         !node.hasClass('filtered') &&
                         (node.isSelected() ||
                             node.getAdjacentNodes({}).isSelected().includes(true) ||
                             node.getAdjacentEdges().isSelected().includes(true))) {
-                        return __assign(__assign({}, NODE_HALO_CONFIGURATION), { scalingMethod: _this._ogma.geo.enabled() ? 'fixed' : 'scaled' });
+                        return Object.assign(Object.assign({}, NODE_HALO_CONFIGURATION), { scalingMethod: this._ogma.geo.enabled() ? 'fixed' : 'scaled' });
                     }
                     return null;
                 }
@@ -189,23 +178,20 @@ var StylesViz = /** @class */ (function () {
                 }
             }
         });
-    };
+    }
     /**
      * Set edges default styles based on the configuration
      */
-    StylesViz.prototype.setEdgesDefaultHalo = function () {
-        var _this = this;
+    setEdgesDefaultHalo() {
         // setting default halo styles
         this._edgeDefaultHaloRules = this._ogma.styles.addRule({
-            edgeSelector: function (edge) {
-                return edge && edge.getSource() && edge.getTarget() && !edge.hasClass('filtered');
-            },
+            edgeSelector: (edge) => edge && edge.getSource() && edge.getTarget() && !edge.hasClass('filtered'),
             edgeAttributes: {
-                halo: function (edge) {
+                halo: (edge) => {
                     if (edge &&
                         !edge.hasClass('filtered') &&
                         (edge.isSelected() || edge.getSource().isSelected() || edge.getTarget().isSelected())) {
-                        return __assign(__assign({}, EDGE_HALO_CONFIGURATION), { scalingMethod: _this._ogma.geo.enabled() ? 'fixed' : 'scaled' });
+                        return Object.assign(Object.assign({}, EDGE_HALO_CONFIGURATION), { scalingMethod: this._ogma.geo.enabled() ? 'fixed' : 'scaled' });
                     }
                     return null;
                 }
@@ -221,36 +207,36 @@ var StylesViz = /** @class */ (function () {
                 }
             }
         });
-    };
+    }
     /**
      * Return the default node radius set in configuration or 5
      *
      * @returns {number}
      */
-    StylesViz.prototype.defaultNodeRadius = function (styles) {
+    defaultNodeRadius(styles) {
         return this.defaultStylesHas(styles, ['nodeRadius']) ? styles.nodeRadius : 5;
-    };
+    }
     /**
      * Return the default edge width set in configuration or 1
      *
      * @returns {number}
      */
-    StylesViz.prototype.defaultEdgeWidth = function (styles) {
+    defaultEdgeWidth(styles) {
         return this.defaultStylesHas(styles, ['edgeWidth']) ? styles.edgeWidth : 1;
-    };
+    }
     /**
      * Check if a style property exists in the default styles object
      */
-    StylesViz.prototype.defaultStylesHas = function (styles, propertyPath) {
+    defaultStylesHas(styles, propertyPath) {
         if (!tools_1.Tools.isDefined(styles)) {
             return false;
         }
         return tools_1.Tools.getIn(styles, propertyPath) !== undefined;
-    };
+    }
     /**
      * Set styles for the class "filtered"
      */
-    StylesViz.prototype.setFilterClass = function () {
+    setFilterClass() {
         this._ogma.styles.createClass({
             name: 'filtered',
             nodeAttributes: {
@@ -287,11 +273,11 @@ var StylesViz = /** @class */ (function () {
                 width: 0.2
             }
         });
-    };
+    }
     /**
      * Set the class for exported nodes and edges
      */
-    StylesViz.prototype.setExportClass = function (textWrappingLength) {
+    setExportClass(textWrappingLength) {
         if (!this._exportClass) {
             this._exportClass = this._ogma.styles.createClass({
                 name: 'exported',
@@ -322,29 +308,28 @@ var StylesViz = /** @class */ (function () {
                 }
             });
         }
-    };
+    }
     /**
      * Set the rule to display badges
      */
-    StylesViz.prototype.setBadgeRule = function () {
-        var _this = this;
+    setBadgeRule() {
         this._ogma.styles.createClass({
             name: 'degreeIndicator',
             nodeAttributes: {
                 badges: {
-                    topRight: function (node) {
+                    topRight: (node) => {
                         if (node !== undefined) {
-                            var degree = tools_1.Tools.getHiddenNeighbors(node.toList());
-                            var badgeContent = tools_1.Tools.formatNumber(degree);
+                            const degree = tools_1.Tools.getHiddenNeighbors(node.toList());
+                            const badgeContent = tools_1.Tools.formatNumber(degree);
                             if (degree > 0) {
-                                var nodeColor = Array.isArray(node.getAttribute('color'))
+                                const nodeColor = Array.isArray(node.getAttribute('color'))
                                     ? node.getAttribute('color')[0]
                                     : node.getAttribute('color');
-                                var textColor = __1.OgmaTools.isBright(nodeColor)
+                                const textColor = __1.OgmaTools.isBright(nodeColor)
                                     ? DARK_FONT_COLOR
                                     : CLEAR_FONT_COLOR;
-                                var isSupernode = node.getData(['statistics', 'supernode']);
-                                var content = null;
+                                const isSupernode = node.getData(['statistics', 'supernode']);
+                                let content = null;
                                 if (+badgeContent !== 0) {
                                     content = isSupernode ? badgeContent + '+' : badgeContent;
                                 }
@@ -356,9 +341,9 @@ var StylesViz = /** @class */ (function () {
                                         color: null
                                     },
                                     text: {
-                                        font: _this._defaultConfiguration.node.text !== undefined &&
-                                            _this._defaultConfiguration.node.text.font !== undefined
-                                            ? _this._defaultConfiguration.node.text.font
+                                        font: this._defaultConfiguration.node.text !== undefined &&
+                                            this._defaultConfiguration.node.text.font !== undefined
+                                            ? this._defaultConfiguration.node.text.font
                                             : DEFAULT_OGMA_FONT,
                                         scale: 0.4,
                                         color: textColor,
@@ -375,12 +360,12 @@ var StylesViz = /** @class */ (function () {
             name: 'pinnedIndicator',
             nodeAttributes: {
                 badges: {
-                    bottomRight: function (node) {
+                    bottomRight: (node) => {
                         if (node !== undefined && !node.getAttribute('layoutable')) {
-                            var nodeColor = Array.isArray(node.getAttribute('color'))
+                            const nodeColor = Array.isArray(node.getAttribute('color'))
                                 ? node.getAttribute('color')[0]
                                 : node.getAttribute('color');
-                            var textColor = __1.OgmaTools.isBright(nodeColor)
+                            const textColor = __1.OgmaTools.isBright(nodeColor)
                                 ? DARK_FONT_COLOR
                                 : CLEAR_FONT_COLOR;
                             return {
@@ -405,43 +390,42 @@ var StylesViz = /** @class */ (function () {
                 self: { attributes: ['layoutable'] }
             }
         });
-        this._ogma.events.on('addNodes', function (nodesEvent) { return nodesEvent.nodes.addClass('degreeIndicator'); });
-        this._ogma.events.on('addNodes', function (nodesEvent) { return nodesEvent.nodes.addClass('pinnedIndicator'); });
-    };
+        this._ogma.events.on('addNodes', (nodesEvent) => nodesEvent.nodes.addClass('degreeIndicator'));
+        this._ogma.events.on('addNodes', (nodesEvent) => nodesEvent.nodes.addClass('pinnedIndicator'));
+    }
     /**
      * Delete the rule to display badges
      */
-    StylesViz.prototype.deleteBadgeRule = function () {
+    deleteBadgeRule() {
         this._ogma.getNodes().removeClasses(['degreeIndicator', 'pinnedIndicator'], 0);
-    };
+    }
     /**
      * set text overlap to true or false
      *
      * @param {boolean} overlap
      */
-    StylesViz.prototype.toggleTextOverlap = function (overlap) {
+    toggleTextOverlap(overlap) {
         this._ogma.setOptions({ texts: { preventOverlap: overlap } });
-    };
+    }
     /**
      * refresh nodes and edge rules
      *
      */
-    StylesViz.prototype.refreshRules = function () {
+    refreshRules() {
         this._nodeDefaultStylesRules.refresh();
         this._edgeDefaultStylesRules.refresh();
-    };
+    }
     /**
      * Create / refresh an ogma rule for node colors
      */
-    StylesViz.prototype.refreshNodeColors = function (colorStyleRules) {
-        var _this = this;
+    refreshNodeColors(colorStyleRules) {
         if (!tools_1.Tools.isDefined(this._ogmaNodeColor)) {
             this._nodeAttributes.refresh({ color: colorStyleRules });
             this._ogmaNodeColor = this._ogma.styles.addRule({
                 nodeAttributes: {
-                    color: function (node) {
+                    color: (node) => {
                         if (node !== undefined) {
-                            return _this._nodeAttributes.color(node.getData());
+                            return this._nodeAttributes.color(node.getData());
                         }
                     }
                 },
@@ -454,60 +438,59 @@ var StylesViz = /** @class */ (function () {
             // TODO refresh node icons when moving the code from LKE
             // this.refreshIconsColor();
         }
-    };
+    }
     /**
      * Return an array of StyleRules with only the style that need to be applied
      */
-    StylesViz.prototype.getStyleRule = function (state, styleType) {
+    getStyleRule(state, styleType) {
         return new __1.StyleRules(state)[styleType];
-    };
-    StylesViz.prototype.initNodeColors = function (nodeRules) {
-        var nodeColorRules = this.getStyleRule(nodeRules, __1.StyleType.COLOR);
+    }
+    initNodeColors(nodeRules) {
+        const nodeColorRules = this.getStyleRule(nodeRules, __1.StyleType.COLOR);
         this.refreshNodeColors(nodeColorRules);
-    };
-    StylesViz.prototype.initNodesIcons = function (nodeRules) {
-        var nodeIconsRules = this.getStyleRule(nodeRules, __1.StyleType.ICON);
+    }
+    initNodesIcons(nodeRules) {
+        const nodeIconsRules = this.getStyleRule(nodeRules, __1.StyleType.ICON);
         this.refreshNodeIcons(nodeIconsRules);
-    };
-    StylesViz.prototype.initNodesSizes = function (nodeRules) {
-        var nodeSizeRules = this.getStyleRule(nodeRules, __1.StyleType.SIZE);
+    }
+    initNodesSizes(nodeRules) {
+        const nodeSizeRules = this.getStyleRule(nodeRules, __1.StyleType.SIZE);
         this.refreshNodeSize(nodeSizeRules);
-    };
-    StylesViz.prototype.initNodesShapes = function (nodeRules) {
-        var nodeShapesRules = this.getStyleRule(nodeRules, __1.StyleType.SHAPE);
+    }
+    initNodesShapes(nodeRules) {
+        const nodeShapesRules = this.getStyleRule(nodeRules, __1.StyleType.SHAPE);
         this.refreshNodeShape(nodeShapesRules);
-    };
-    StylesViz.prototype.initEdgesWidth = function (edgeRules) {
-        var edgesWidthRules = this.getStyleRule(edgeRules, __1.StyleType.WIDTH);
+    }
+    initEdgesWidth(edgeRules) {
+        const edgesWidthRules = this.getStyleRule(edgeRules, __1.StyleType.WIDTH);
         this.refreshEdgeWidth(edgesWidthRules);
-    };
-    StylesViz.prototype.initEdgesShape = function (edgeRules) {
-        var edgesShapeRules = this.getStyleRule(edgeRules, __1.StyleType.SHAPE);
+    }
+    initEdgesShape(edgeRules) {
+        const edgesShapeRules = this.getStyleRule(edgeRules, __1.StyleType.SHAPE);
         this.refreshEdgeShape(edgesShapeRules);
-    };
-    StylesViz.prototype.initEdgesColor = function (edgeRules) {
-        var edgesColorRules = this.getStyleRule(edgeRules, __1.StyleType.COLOR);
+    }
+    initEdgesColor(edgeRules) {
+        const edgesColorRules = this.getStyleRule(edgeRules, __1.StyleType.COLOR);
         this.refreshEdgeColors(edgesColorRules);
-    };
+    }
     /**
      * Create / refresh an ogma rule for node icons
      *
      * @param {Array<any>} iconStyleRules
      */
-    StylesViz.prototype.refreshNodeIcons = function (iconStyleRules) {
-        var _this = this;
+    refreshNodeIcons(iconStyleRules) {
         if (!tools_1.Tools.isDefined(this._ogmaNodeIcon)) {
             this._nodeAttributes.refresh({ icon: iconStyleRules });
             this._ogmaNodeIcon = this._ogma.styles.addRule({
                 nodeAttributes: {
-                    icon: function (node) {
+                    icon: (node) => {
                         if (node !== undefined) {
-                            return _this._nodeAttributes.icon(node.getData()).icon;
+                            return this._nodeAttributes.icon(node.getData()).icon;
                         }
                     },
-                    image: function (node) {
+                    image: (node) => {
                         if (node !== undefined) {
-                            return _this._nodeAttributes.icon(node.getData()).image;
+                            return this._nodeAttributes.icon(node.getData()).image;
                         }
                     }
                 },
@@ -518,21 +501,20 @@ var StylesViz = /** @class */ (function () {
             this._nodeAttributes.refresh({ icon: iconStyleRules });
             this._ogmaNodeIcon.refresh();
         }
-    };
+    }
     /**
      * Create / refresh an ogma rule for node sizes
      *
      * @param {Array<any>} sizeStyleRules
      */
-    StylesViz.prototype.refreshNodeSize = function (sizeStyleRules) {
-        var _this = this;
+    refreshNodeSize(sizeStyleRules) {
         if (!tools_1.Tools.isDefined(this._ogmaNodeSize)) {
             this._nodeAttributes.refresh({ size: sizeStyleRules });
             this._ogmaNodeSize = this._ogma.styles.addRule({
                 nodeAttributes: {
-                    radius: function (node) {
+                    radius: (node) => {
                         if (node !== undefined) {
-                            return _this._nodeAttributes.size(node.getData());
+                            return this._nodeAttributes.size(node.getData());
                         }
                     }
                 },
@@ -543,21 +525,20 @@ var StylesViz = /** @class */ (function () {
             this._nodeAttributes.refresh({ size: sizeStyleRules });
             this._ogmaNodeSize.refresh();
         }
-    };
+    }
     /**
      * Create / refresh an ogma rule for node images
      *
      * @param {Array<any>} shapeStyleRules
      */
-    StylesViz.prototype.refreshNodeShape = function (shapeStyleRules) {
-        var _this = this;
+    refreshNodeShape(shapeStyleRules) {
         if (!tools_1.Tools.isDefined(this._ogmaNodeShape)) {
             this._nodeAttributes.refresh({ shape: shapeStyleRules });
             this._ogmaNodeShape = this._ogma.styles.addRule({
                 nodeAttributes: {
-                    shape: function (node) {
+                    shape: (node) => {
                         if (node !== undefined) {
-                            return _this._nodeAttributes.shape(node.getData());
+                            return this._nodeAttributes.shape(node.getData());
                         }
                     }
                 },
@@ -568,19 +549,18 @@ var StylesViz = /** @class */ (function () {
             this._nodeAttributes.refresh({ shape: shapeStyleRules });
             this._ogmaNodeShape.refresh();
         }
-    };
+    }
     /**
      * Create / refresh an ogma rule for edge colors
      */
-    StylesViz.prototype.refreshEdgeColors = function (colorStyleRules) {
-        var _this = this;
+    refreshEdgeColors(colorStyleRules) {
         if (!tools_1.Tools.isDefined(this._ogmaEdgeColor)) {
             this._edgeAttributes.refresh({ color: colorStyleRules });
             this._ogmaEdgeColor = this._ogma.styles.addRule({
                 edgeAttributes: {
-                    color: function (edge) {
+                    color: (edge) => {
                         if (edge !== undefined) {
-                            return _this._edgeAttributes.color(edge.getData());
+                            return this._edgeAttributes.color(edge.getData());
                         }
                     }
                 },
@@ -591,21 +571,20 @@ var StylesViz = /** @class */ (function () {
             this._edgeAttributes.refresh({ color: colorStyleRules });
             this._ogmaEdgeColor.refresh();
         }
-    };
+    }
     /**
      * Create / refresh an ogma rule for edge width
      *
      * @param {Array<LKStyleRule>} widthStyleRules
      */
-    StylesViz.prototype.refreshEdgeWidth = function (widthStyleRules) {
-        var _this = this;
+    refreshEdgeWidth(widthStyleRules) {
         if (!tools_1.Tools.isDefined(this._ogmaEdgeWidth)) {
             this._edgeAttributes.refresh({ width: widthStyleRules });
             this._ogmaEdgeWidth = this._ogma.styles.addRule({
                 edgeAttributes: {
-                    width: function (edge) {
+                    width: (edge) => {
                         if (edge !== undefined) {
-                            return _this._edgeAttributes.width(edge.getData());
+                            return this._edgeAttributes.width(edge.getData());
                         }
                     }
                 },
@@ -618,21 +597,20 @@ var StylesViz = /** @class */ (function () {
             this._edgeAttributes.refresh({ width: widthStyleRules });
             this._ogmaEdgeWidth.refresh();
         }
-    };
+    }
     /**
      * Create / refresh an ogma rule for edge width
      *
      * @param {Array<LKStyleRule>} shapeStyleRules
      */
-    StylesViz.prototype.refreshEdgeShape = function (shapeStyleRules) {
-        var _this = this;
+    refreshEdgeShape(shapeStyleRules) {
         if (!tools_1.Tools.isDefined(this._ogmaEdgeShape)) {
             this._edgeAttributes.refresh({ shape: shapeStyleRules });
             this._ogmaEdgeShape = this._ogma.styles.addRule({
                 edgeAttributes: {
-                    shape: function (edge) {
+                    shape: (edge) => {
                         if (edge !== undefined) {
-                            return _this._edgeAttributes.shape(edge.getData());
+                            return this._edgeAttributes.shape(edge.getData());
                         }
                     }
                 },
@@ -643,8 +621,7 @@ var StylesViz = /** @class */ (function () {
             this._edgeAttributes.refresh({ shape: shapeStyleRules });
             this._ogmaEdgeShape.refresh();
         }
-    };
-    return StylesViz;
-}());
+    }
+}
 exports.StylesViz = StylesViz;
 //# sourceMappingURL=styles.js.map