@d3plus/core 3.0.15 → 3.1.0

package/es/src/charts/Rings.js

@@ -1,3 +1,11 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
 function _assert_this_initialized(self) {
     if (self === void 0) {
         throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
@@ -63,12 +71,40 @@ function _inherits(subClass, superClass) {
     if (superClass) _set_prototype_of(subClass, superClass);
 }
 function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
         return left instanceof right;
     }
 }
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _possible_constructor_return(self, call) {
     if (call && (_type_of(call) === "object" || typeof call === "function")) {
         return call;
@@ -82,6 +118,9 @@ function _set_prototype_of(o, p) {
     };
     return _set_prototype_of(o, p);
 }
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
 function _super_prop_base(object, property) {
     while(!Object.prototype.hasOwnProperty.call(object, property)){
         object = _get_prototype_of(object);
@@ -93,6 +132,14 @@ function _type_of(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
 function _is_native_reflect_construct() {
     try {
         var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
@@ -101,11 +148,10 @@ function _is_native_reflect_construct() {
         return !!result;
     })();
 }
-import { extent, max, min } from "d3-array";
-import { nest } from "d3-collection";
+import { extent, groups, max, min } from "d3-array";
 import * as scales from "d3-scale";
-import { assign, elem } from "@d3plus/dom";
-import { colorLegible } from "@d3plus/color";
+import { assign, backgroundColor, elem } from "@d3plus/dom";
+import { colorContrast } from "@d3plus/color";
 import { addToQueue } from "@d3plus/data";
 import * as shapes from "../shapes/index.js";
 import { accessor, configPrep, constant } from "../utils/index.js";
@@ -182,7 +228,7 @@ var Rings = /*#__PURE__*/ function(Viz) {
         _this._sizeScale = "sqrt";
         _this._shape = constant("Circle");
         _this._shapeConfig = assign(_this._shapeConfig, {
-            ariaLabel: function(d, i) {
+            ariaLabel: function ariaLabel(d, i) {
                 var validSize = _this._size ? ", ".concat(_this._size(d, i)) : "";
                 return "".concat(_this._drawLabel(d, i)).concat(validSize, ".");
             },
@@ -208,7 +254,7 @@ var Rings = /*#__PURE__*/ function(Viz) {
             /**
       Extends the draw behavior of the abstract Viz class.
       @private
-  */ key: "_draw",
+*/ key: "_draw",
             value: function _draw(callback) {
                 var _this = this;
                 _get(_get_prototype_of(Rings.prototype), "_draw", this).call(this, callback);
@@ -276,21 +322,21 @@ var Rings = /*#__PURE__*/ function(Viz) {
                     return map;
                 }, {});
                 var duration = this._duration, height = this._height - this._margin.top - this._margin.bottom, transform = "translate(".concat(this._margin.left, ", ").concat(this._margin.top, ")"), width = this._width - this._margin.left - this._margin.right;
-                var edges = [], radius = min([
+                var edges = [], radius = (min([
                     height,
                     width
-                ]) / 2, ringWidth = radius / 3;
+                ]) || 0) / 2, ringWidth = radius / 3;
                 var primaryRing = ringWidth, secondaryRing = ringWidth * 2;
                 var center = nodeLookup[this._center];
                 center.x = width / 2;
                 center.y = height / 2;
                 center.r = this._sizeMin ? max([
                     this._sizeMin,
-                    primaryRing * .65
+                    primaryRing * 0.65
                 ]) : this._sizeMax ? min([
                     this._sizeMax,
-                    primaryRing * .65
-                ]) : primaryRing * .65;
+                    primaryRing * 0.65
+                ]) : primaryRing * 0.65;
                 var claimed = [
                     center
                 ], primaries = [];
@@ -350,20 +396,20 @@ var Rings = /*#__PURE__*/ function(Viz) {
                     primaryMax = min([
                         primaryDistance / 2,
                         8
-                    ]);
+                    ]) || 0;
                 }
                 var secondaryMax = secondaryDistance / 2 - 4;
                 if (secondaryDistance / 2 - 4 < 4) {
                     secondaryMax = min([
                         secondaryDistance / 2,
                         4
-                    ]);
+                    ]) || 0;
                 }
                 if (secondaryMax > ringWidth / 10) {
                     secondaryMax = ringWidth / 10;
                 }
                 if (secondaryMax > primaryMax && secondaryMax > 10) {
-                    secondaryMax = primaryMax * .75;
+                    secondaryMax = primaryMax * 0.75;
                 }
                 if (primaryMax > secondaryMax * 1.5) {
                     primaryMax = secondaryMax * 1.5;
@@ -554,28 +600,28 @@ var Rings = /*#__PURE__*/ function(Viz) {
                 }).node()).render());
                 var that = this;
                 var shapeConfig = {
-                    label: function(d) {
+                    label: function label(d) {
                         return nodes.length <= _this._dataCutoff || _this._hover && _this._hover(d) || _this._active && _this._active(d) ? _this._drawLabel(d.data || d.node, d.i) : false;
                     },
-                    labelBounds: function(d) {
+                    labelBounds: function labelBounds(d) {
                         return d.labelBounds;
                     },
                     labelConfig: {
-                        fontColor: function(d) {
-                            return d.id === _this._center ? configPrep.bind(that)(that._shapeConfig, "shape", d.key).labelConfig.fontColor(d) : colorLegible(configPrep.bind(that)(that._shapeConfig, "shape", d.key).fill(d));
+                        fontColor: function fontColor(d) {
+                            return d.id === _this._center ? configPrep.bind(that)(that._shapeConfig, "shape", d.key).labelConfig.fontColor(d) : colorContrast(_this._select ? backgroundColor(_this._select.node()) : "rgb(255, 255, 255)");
                         },
-                        fontResize: function(d) {
+                        fontResize: function fontResize(d) {
                             return d.id === _this._center;
                         },
                         padding: 0,
-                        textAnchor: function(d) {
+                        textAnchor: function textAnchor(d) {
                             return nodeLookup[d.id].textAnchor || configPrep.bind(that)(that._shapeConfig, "shape", d.key).labelConfig.textAnchor;
                         },
-                        verticalAlign: function(d) {
+                        verticalAlign: function verticalAlign(d) {
                             return d.id === _this._center ? "middle" : "top";
                         }
                     },
-                    rotate: function(d) {
+                    rotate: function rotate(d) {
                         return nodeLookup[d.id].rotate || 0;
                     },
                     select: elem("g.d3plus-rings-nodes", {
@@ -589,32 +635,27 @@ var Rings = /*#__PURE__*/ function(Viz) {
                         }
                     }).node()
                 };
-                nest().key(function(d) {
+                groups(nodes, function(d) {
                     return d.shape;
-                }).entries(nodes).forEach(function(d) {
-                    _this._shapes.push(new shapes[d.key]().config(configPrep.bind(_this)(_this._shapeConfig, "shape", d.key)).config(shapeConfig).data(d.values).render());
+                }).forEach(function(param) {
+                    var _param = _sliced_to_array(param, 2), key = _param[0], values = _param[1];
+                    _this._shapes.push(new shapes[key]().config(configPrep.bind(_this)(_this._shapeConfig, "shape", key)).config(shapeConfig).data(values).render());
                 });
                 return this;
             }
         },
         {
             /**
-   @memberof Rings
-   @desc Sets the center node to be the node with the given id.
-   @param {String}
-   @chainable
-   */ key: "center",
+   The center node, specified by id.
+*/ key: "center",
             value: function center(_) {
                 return arguments.length ? (this._center = _, this) : this._center;
             }
         },
         {
             /**
-      @memberof Rings
-      @desc If *value* is specified, sets the hover method to the specified function and returns the current class instance.
-      @param {Function} [*value*]
-      @chainable
-   */ key: "hover",
+      The hover callback function for highlighting shapes on mouseover.
+*/ key: "hover",
             value: function hover(_) {
                 this._hover = _;
                 this._shapes.forEach(function(s) {
@@ -626,17 +667,14 @@ var Rings = /*#__PURE__*/ function(Viz) {
         },
         {
             /**
-      @memberof Rings
-      @desc A predefined *Array* of edges that connect each object passed to the [node](#Rings.node) method. The `source` and `target` keys in each link need to map to the nodes in one of three ways:
+      A predefined *Array* of edges that connect each object passed to the [node](#Rings.node) method. The `source` and `target` keys in each link need to map to the nodes in one of three ways:
 1. The index of the node in the nodes array (as in [this](http://d3plus.org/examples/d3plus-network/getting-started/) example).
 2. The actual node *Object* itself.
 3. A *String* value matching the `id` of the node.
 
 The value passed should either be an *Array* of data or a *String* representing a filepath or URL to be loaded. An optional formatting function can be passed as a second argument to this method. This custom function will be passed the data that has been loaded, as long as there are no errors. This function should return the final links *Array*.
-      @param {Array|String} *links* = []
-      @param {Function} [*formatter*]
-      @chainable
-  */ key: "links",
+    @param f Array of link objects or a URL to load links from.
+*/ key: "links",
             value: function links(_, f) {
                 if (arguments.length) {
                     addToQueue.bind(this)(_, f, "links");
@@ -647,44 +685,32 @@ The value passed should either be an *Array* of data or a *String* representing
         },
         {
             /**
-      @memberof Network
-      @desc Defines the thickness of the links connecting each node. The value provided can be either a pixel Number to be used for all links, or an accessor function that returns a specific data value to be used in an automatically calculated linear scale.
-      @param {Function|Name} [*value* = 1]
-      @chainable
-  */ key: "linkSize",
+      Defines the thickness of the links connecting each node. The value provided can be either a pixel Number to be used for all links, or an accessor function that returns a specific data value to be used in an automatically calculated linear scale.
+*/ key: "linkSize",
             value: function linkSize(_) {
                 return arguments.length ? (this._linkSize = typeof _ === "function" ? _ : constant(_), this) : this._linkSize;
             }
         },
         {
             /**
-      @memberof Network
-      @desc Defines the minimum pixel stroke width used in link sizing.
-      @param {Number} [*value* = 2]
-      @chainable
-  */ key: "linkSizeMin",
+      Defines the minimum pixel stroke width used in link sizing.
+*/ key: "linkSizeMin",
             value: function linkSizeMin(_) {
                 return arguments.length ? (this._linkSizeMin = _, this) : this._linkSizeMin;
             }
         },
         {
             /**
-      @memberof Network
-      @desc Sets the specific type of [continuous d3-scale](https://github.com/d3/d3-scale#continuous-scales) used when calculating the pixel size of links in the network.
-      @param {String} [*value* = "sqrt"]
-      @chainable
-  */ key: "linkSizeScale",
+      The type of [continuous d3-scale](https://github.com/d3/d3-scale#continuous-scales) used when calculating the pixel size of links in the network.
+*/ key: "linkSizeScale",
             value: function linkSizeScale(_) {
                 return arguments.length ? (this._linkSizeScale = _, this) : this._linkSizeScale;
             }
         },
         {
             /**
-      @memberof Rings
-      @desc If *value* is specified, sets the node group accessor(s) to the specified string, function, or array of values and returns the current class instance. This method overrides the default .groupBy() function from being used with the data passed to .nodes(). If *value* is not specified, returns the current node group accessor.
-      @param {String|Function|Array} [*value* = undefined]
-      @chainable
-  */ key: "nodeGroupBy",
+      The node group accessor(s). This method overrides the default .groupBy() function from being used with the data passed to .nodes().
+*/ key: "nodeGroupBy",
             value: function nodeGroupBy(_) {
                 var _this = this;
                 if (!arguments.length) return this._nodeGroupBy;
@@ -707,14 +733,11 @@ The value passed should either be an *Array* of data or a *String* representing
         },
         {
             /**
-      @memberof Rings
-      @desc The list of nodes to be used for drawing the rings network. The value passed should either be an *Array* of data or a *String* representing a filepath or URL to be loaded.
+      The list of nodes to be used for drawing the rings network. The value passed should either be an *Array* of data or a *String* representing a filepath or URL to be loaded.
 
 Additionally, a custom formatting function can be passed as a second argument to this method. This custom function will be passed the data that has been loaded, as long as there are no errors. This function should return the final node *Array*.
-      @param {Array|String} *nodes* = []
-      @param {Function} [*formatter*]
-      @chainable
-  */ key: "nodes",
+    @param f Array of node objects or a URL to load nodes from.
+*/ key: "nodes",
             value: function nodes(_, f) {
                 if (arguments.length) {
                     addToQueue.bind(this)(_, f, "nodes");
@@ -725,44 +748,32 @@ Additionally, a custom formatting function can be passed as a second argument to
         },
         {
             /**
-      @memberof Rings
-      @desc If *value* is specified, sets the size accessor to the specified function or data key and returns the current class instance. If *value* is not specified, returns the current size accessor.
-      @param {Function|String} [*value*]
-      @chainable
-  */ key: "size",
+      The size accessor for each node in the rings layout.
+*/ key: "size",
             value: function size(_) {
                 return arguments.length ? (this._size = typeof _ === "function" || !_ ? _ : accessor(_), this) : this._size;
             }
         },
         {
             /**
-      @memberof Rings
-      @desc If *value* is specified, sets the size scale maximum to the specified number and returns the current class instance. If *value* is not specified, returns the current size scale maximum. By default, the maximum size is determined by half the distance of the two closest nodes.
-      @param {Number} [*value*]
-      @chainable
-  */ key: "sizeMax",
+      The size scale maximum. By default, the maximum size is determined by half the distance of the two closest nodes.
+*/ key: "sizeMax",
             value: function sizeMax(_) {
                 return arguments.length ? (this._sizeMax = _, this) : this._sizeMax;
             }
         },
         {
             /**
-      @memberof Rings
-      @desc If *value* is specified, sets the size scale minimum to the specified number and returns the current class instance. If *value* is not specified, returns the current size scale minimum.
-      @param {Number} [*value* = 5]
-      @chainable
-  */ key: "sizeMin",
+      The size scale minimum.
+*/ key: "sizeMin",
             value: function sizeMin(_) {
                 return arguments.length ? (this._sizeMin = _, this) : this._sizeMin;
             }
         },
         {
             /**
-      @memberof Rings
-      @desc If *value* is specified, sets the size scale to the specified string and returns the current class instance. If *value* is not specified, returns the current size scale.
-      @param {String} [*value* = "sqrt"]
-      @chainable
-  */ key: "sizeScale",
+      The size scale.
+*/ key: "sizeScale",
             value: function sizeScale(_) {
                 return arguments.length ? (this._sizeScale = _, this) : this._sizeScale;
             }
@@ -771,7 +782,5 @@ Additionally, a custom formatting function can be passed as a second argument to
     return Rings;
 }(Viz);
 /**
-    @class Rings
-    @extends Viz
-    @desc Creates a ring visualization based on a defined set of nodes and edges. [Click here](http://d3plus.org/examples/d3plus-network/simple-rings/) for help getting started using the Rings class.
+    Creates a ring visualization based on a defined set of nodes and edges. [Click here](http://d3plus.org/examples/d3plus-network/simple-rings/) for help getting started using the Rings class.
 */ export { Rings as default };