highcharts
Version:
JavaScript charting framework
564 lines (563 loc) • 19.5 kB
JavaScript
/* *
*
* Networkgraph series
*
* (c) 2010-2025 Paweł Fus
*
* License: www.highcharts.com/license
*
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
*
* */
'use strict';
/* *
*
* Constants
*
* */
/**
* A networkgraph is a type of relationship chart, where connnections
* (links) attracts nodes (points) and other nodes repulse each other.
*
* @extends plotOptions.line
* @product highcharts
* @sample highcharts/demo/network-graph/
* Networkgraph
* @since 7.0.0
* @excluding boostThreshold, animation, animationLimit, connectEnds,
* colorAxis, colorKey, connectNulls, cropThreshold, dragDrop,
* getExtremesFromAll, label, linecap, negativeColor,
* pointInterval, pointIntervalUnit, pointPlacement,
* pointStart, softThreshold, stack, stacking, step,
* threshold, xAxis, yAxis, zoneAxis, dataSorting,
* boostBlending
* @requires modules/networkgraph
* @optionparent plotOptions.networkgraph
*
* @private
*/
const NetworkgraphSeriesDefaults = {
stickyTracking: false,
/**
* @default true
* @extends plotOptions.series.inactiveOtherPoints
* @private
*/
inactiveOtherPoints: true,
marker: {
enabled: true,
states: {
/**
* The opposite state of a hover for a single point node.
* Applied to all not connected nodes to the hovered one.
*
* @declare Highcharts.PointStatesInactiveOptionsObject
*/
inactive: {
/**
* Opacity of inactive markers.
*/
opacity: 0.3,
/**
* Animation when not hovering over the node.
*
* @type {boolean|Partial<Highcharts.AnimationOptionsObject>}
*/
animation: {
/** @internal */
duration: 50
}
}
}
},
states: {
/**
* The opposite state of a hover for a single point link. Applied
* to all links that are not coming from the hovered node.
*
* @declare Highcharts.SeriesStatesInactiveOptionsObject
*/
inactive: {
/**
* Opacity of inactive links.
*/
linkOpacity: 0.3,
/**
* Animation when not hovering over the node.
*
* @type {boolean|Partial<Highcharts.AnimationOptionsObject>}
*/
animation: {
/** @internal */
duration: 50
}
}
},
/**
* @sample highcharts/series-networkgraph/link-datalabels
* Networkgraph with labels on links
* @sample highcharts/series-networkgraph/textpath-datalabels
* Networkgraph with labels around nodes
* @sample highcharts/series-networkgraph/link-datalabels
* Data labels moved into the nodes
* @sample highcharts/series-networkgraph/link-datalabels
* Data labels moved under the links
*
* @declare Highcharts.SeriesNetworkgraphDataLabelsOptionsObject
*
* @private
*/
dataLabels: {
/**
* The
* [format string](https://www.highcharts.com/docs/chart-concepts/labels-and-string-formatting)
* specifying what to show for _node_ in the networkgraph. In v7.0
* defaults to `{key}`, since v7.1 defaults to `undefined` and
* `formatter` is used instead.
*
* @type {string}
* @since 7.0.0
* @apioption plotOptions.networkgraph.dataLabels.format
*/
// eslint-disable-next-line valid-jsdoc
/**
* Callback JavaScript function to format the data label for a node.
* Note that if a `format` is defined, the format takes precedence
* and the formatter is ignored.
*
* @since 7.0.0
*/
formatter: function () {
return String(this.key ?? '');
},
/**
* The
* [format string](https://www.highcharts.com/docs/chart-concepts/labels-and-string-formatting)
* specifying what to show for _links_ in the networkgraph.
* (Default: `undefined`)
*
* @type {string}
* @since 7.1.0
* @apioption plotOptions.networkgraph.dataLabels.linkFormat
*/
// eslint-disable-next-line valid-jsdoc
/**
* Callback to format data labels for _links_ in the sankey diagram.
* The `linkFormat` option takes precedence over the
* `linkFormatter`.
*
* @since 7.1.0
*/
linkFormatter: function () {
return (this.fromNode.name +
'<br>' +
this.toNode.name);
},
/**
* Options for a _link_ label text which should follow link
* connection. Border and background are disabled for a label that
* follows a path.
*
* **Note:** Only SVG-based renderer supports this option. Setting
* `useHTML` to true will disable this option.
*
* @extends plotOptions.networkgraph.dataLabels.textPath
* @since 7.1.0
*/
linkTextPath: {
enabled: true
},
textPath: {
enabled: false
},
style: {
transition: 'opacity 2000ms'
},
defer: true,
animation: {
defer: 1000
}
},
/**
* Link style options
* @private
*/
link: {
/**
* A name for the dash style to use for links.
*
* @type {string}
* @apioption plotOptions.networkgraph.link.dashStyle
*/
/**
* Opacity of the link between two nodes.
*
* @type {number}
* @default 1
* @apioption plotOptions.networkgraph.link.opacity
*/
/**
* Color of the link between two nodes.
*/
color: 'rgba(100, 100, 100, 0.5)',
/**
* Width (px) of the link between two nodes.
*/
width: 1
},
/**
* Flag to determine if nodes are draggable or not.
* @private
*/
draggable: true,
layoutAlgorithm: {
/**
* Repulsive force applied on a node. Passed are two arguments:
* - `d` - which is current distance between two nodes
* - `k` - which is desired distance between two nodes
*
* In `verlet` integration, defaults to:
* `function (d, k) { return (k - d) / d * (k > d ? 1 : 0) }`
*
* @see [layoutAlgorithm.integration](#series.networkgraph.layoutAlgorithm.integration)
*
* @sample highcharts/series-networkgraph/forces/
* Custom forces with Euler integration
* @sample highcharts/series-networkgraph/cuboids/
* Custom forces with Verlet integration
*
* @type {Function}
* @default function (d, k) { return k * k / d; }
* @apioption plotOptions.networkgraph.layoutAlgorithm.repulsiveForce
*/
/**
* Attraction force applied on a node which is conected to another
* node by a link. Passed are two arguments:
* - `d` - which is current distance between two nodes
* - `k` - which is desired distance between two nodes
*
* In `verlet` integration, defaults to:
* `function (d, k) { return (k - d) / d; }`
*
* @see [layoutAlgorithm.integration](#series.networkgraph.layoutAlgorithm.integration)
*
* @sample highcharts/series-networkgraph/forces/
* Custom forces with Euler integration
* @sample highcharts/series-networkgraph/cuboids/
* Custom forces with Verlet integration
*
* @type {Function}
* @default function (d, k) { return k * k / d; }
* @apioption plotOptions.networkgraph.layoutAlgorithm.attractiveForce
*/
/**
* Ideal length (px) of the link between two nodes. When not
* defined, length is calculated as:
* `Math.pow(availableWidth * availableHeight / nodesLength, 0.4);`
*
* Note: Because of the algorithm specification, length of each link
* might be not exactly as specified.
*
* @sample highcharts/series-networkgraph/styled-links/
* Numerical values
*
* @type {number}
* @apioption plotOptions.networkgraph.layoutAlgorithm.linkLength
*/
/**
* Initial layout algorithm for positioning nodes. Can be one of
* built-in options ("circle", "random") or a function where
* positions should be set on each node (`this.nodes`) as
* `node.plotX` and `node.plotY`
*
* @sample highcharts/series-networkgraph/initial-positions/
* Initial positions with callback
*
* @type {"circle"|"random"|Function}
*/
initialPositions: 'circle',
/**
* When `initialPositions` are set to 'circle',
* `initialPositionRadius` is a distance from the center of circle,
* in which nodes are created.
*
* @type {number}
* @default 1
* @since 7.1.0
*/
initialPositionRadius: 1,
/**
* Experimental. Enables live simulation of the algorithm
* implementation. All nodes are animated as the forces applies on
* them.
*
* @sample highcharts/demo/network-graph/
* Live simulation enabled
*/
enableSimulation: false,
/**
* Barnes-Hut approximation only.
* Deteremines when distance between cell and node is small enough
* to calculate forces. Value of `theta` is compared directly with
* quotient `s / d`, where `s` is the size of the cell, and `d` is
* distance between center of cell's mass and currently compared
* node.
*
* @see [layoutAlgorithm.approximation](#series.networkgraph.layoutAlgorithm.approximation)
*
* @since 7.1.0
*/
theta: 0.5,
/**
* Verlet integration only.
* Max speed that node can get in one iteration. In terms of
* simulation, it's a maximum translation (in pixels) that node can
* move (in both, x and y, dimensions). While `friction` is applied
* on all nodes, max speed is applied only for nodes that move very
* fast, for example small or disconnected ones.
*
* @see [layoutAlgorithm.integration](#series.networkgraph.layoutAlgorithm.integration)
* @see [layoutAlgorithm.friction](#series.networkgraph.layoutAlgorithm.friction)
*
* @since 7.1.0
*/
maxSpeed: 10,
/**
* Approximation used to calculate repulsive forces affecting nodes.
* By default, when calculating net force, nodes are compared
* against each other, which gives O(N^2) complexity. Using
* Barnes-Hut approximation, we decrease this to O(N log N), but the
* resulting graph will have different layout. Barnes-Hut
* approximation divides space into rectangles via quad tree, where
* forces exerted on nodes are calculated directly for nearby cells,
* and for all others, cells are treated as a separate node with
* center of mass.
*
* @see [layoutAlgorithm.theta](#series.networkgraph.layoutAlgorithm.theta)
*
* @sample highcharts/series-networkgraph/barnes-hut-approximation/
* A graph with Barnes-Hut approximation
*
* @type {string}
* @validvalue ["barnes-hut", "none"]
* @since 7.1.0
*/
approximation: 'none',
/**
* Type of the algorithm used when positioning nodes.
*
* @type {string}
* @validvalue ["reingold-fruchterman"]
*/
type: 'reingold-fruchterman',
/**
* Integration type. Available options are `'euler'` and `'verlet'`.
* Integration determines how forces are applied on particles. In
* Euler integration, force is applied direct as
* `newPosition += velocity;`.
* In Verlet integration, new position is based on a previous
* position without velocity:
* `newPosition += previousPosition - newPosition`.
*
* Note that different integrations give different results as forces
* are different.
*
* In Highcharts v7.0.x only `'euler'` integration was supported.
*
* @sample highcharts/series-networkgraph/integration-comparison/
* Comparison of Verlet and Euler integrations
*
* @type {string}
* @validvalue ["euler", "verlet"]
* @since 7.1.0
*/
integration: 'euler',
/**
* Max number of iterations before algorithm will stop. In general,
* algorithm should find positions sooner, but when rendering huge
* number of nodes, it is recommended to increase this value as
* finding perfect graph positions can require more time.
*/
maxIterations: 1000,
/**
* Gravitational const used in the barycenter force of the
* algorithm.
*
* @sample highcharts/series-networkgraph/forces/
* Custom forces with Euler integration
*/
gravitationalConstant: 0.0625,
/**
* Friction applied on forces to prevent nodes rushing to fast to
* the desired positions.
*/
friction: -0.981
},
showInLegend: false
};
/* *
*
* Default Export
*
* */
export default NetworkgraphSeriesDefaults;
/* *
*
* API Options
*
* */
/**
* Fires after the simulation is ended and the layout is stable.
*
* @type {Highcharts.NetworkgraphAfterSimulationCallbackFunction}
* @product highcharts
* @apioption series.networkgraph.events.afterSimulation
*/
/**
* A `networkgraph` series. If the [type](#series.networkgraph.type) option is
* not specified, it is inherited from [chart.type](#chart.type).
*
* @extends series,plotOptions.networkgraph
* @excluding boostThreshold, animation, animationLimit, connectEnds,
* connectNulls, cropThreshold, dragDrop, getExtremesFromAll, label,
* linecap, negativeColor, pointInterval, pointIntervalUnit,
* pointPlacement, pointStart, softThreshold, stack, stacking,
* step, threshold, xAxis, yAxis, zoneAxis, dataSorting,
* boostBlending
* @product highcharts
* @requires modules/networkgraph
* @apioption series.networkgraph
*/
/**
* An array of data points for the series. For the `networkgraph` series type,
* points can be given in the following way:
*
* An array of objects with named values. The following snippet shows only a
* few settings, see the complete options set below. If the total number of
* data points exceeds the series'
* [turboThreshold](#series.area.turboThreshold), this option is not available.
*
* ```js
* data: [{
* from: 'Category1',
* to: 'Category2'
* }, {
* from: 'Category1',
* to: 'Category3'
* }]
* ```
*
* @type {Array<Object|Array|number>}
* @extends series.line.data
* @excluding drilldown,marker,x,y,dragDrop
* @sample {highcharts} highcharts/chart/reflow-true/
* Numerical values
* @sample {highcharts} highcharts/series/data-array-of-arrays/
* Arrays of numeric x and y
* @sample {highcharts} highcharts/series/data-array-of-arrays-datetime/
* Arrays of datetime x and y
* @sample {highcharts} highcharts/series/data-array-of-name-value/
* Arrays of point.name and y
* @sample {highcharts} highcharts/series/data-array-of-objects/
* Config objects
* @product highcharts
* @apioption series.networkgraph.data
*/
/**
* @type {Highcharts.SeriesNetworkgraphDataLabelsOptionsObject|Array<Highcharts.SeriesNetworkgraphDataLabelsOptionsObject>}
* @product highcharts
* @apioption series.networkgraph.data.dataLabels
*/
/**
* The node that the link runs from.
*
* @type {string}
* @product highcharts
* @apioption series.networkgraph.data.from
*/
/**
* The node that the link runs to.
*
* @type {string}
* @product highcharts
* @apioption series.networkgraph.data.to
*/
/**
* A collection of options for the individual nodes. The nodes in a
* networkgraph diagram are auto-generated instances of `Highcharts.Point`,
* but options can be applied here and linked by the `id`.
*
* @sample highcharts/series-networkgraph/data-options/
* Networkgraph diagram with node options
*
* @type {Array<*>}
* @product highcharts
* @apioption series.networkgraph.nodes
*/
/**
* The id of the auto-generated node, referring to the `from` or `to` setting of
* the link.
*
* @type {string}
* @product highcharts
* @apioption series.networkgraph.nodes.id
*/
/**
* The color of the auto generated node.
*
* @type {Highcharts.ColorString}
* @product highcharts
* @apioption series.networkgraph.nodes.color
*/
/**
* The color index of the auto generated node, especially for use in styled
* mode.
*
* @type {number}
* @product highcharts
* @apioption series.networkgraph.nodes.colorIndex
*/
/**
* The name to display for the node in data labels and tooltips. Use this when
* the name is different from the `id`. Where the id must be unique for each
* node, this is not necessary for the name.
*
* @sample highcharts/series-networkgraph/data-options/
* Networkgraph diagram with node options
*
* @type {string}
* @product highcharts
* @apioption series.networkgraph.nodes.name
*/
/**
* Mass of the node. By default, each node has mass equal to it's marker radius
* . Mass is used to determine how two connected nodes should affect
* each other:
*
* Attractive force is multiplied by the ratio of two connected
* nodes; if a big node has weights twice as the small one, then the small one
* will move towards the big one twice faster than the big one to the small one
* .
*
* @sample highcharts/series-networkgraph/ragdoll/
* Mass determined by marker.radius
*
* @type {number}
* @product highcharts
* @apioption series.networkgraph.nodes.mass
*/
/**
* Options for the node markers.
*
* @extends plotOptions.networkgraph.marker
* @apioption series.networkgraph.nodes.marker
*/
/**
* Individual data label for each node. The options are the same as
* the ones for [series.networkgraph.dataLabels](#series.networkgraph.dataLabels).
*
* @type {Highcharts.SeriesNetworkgraphDataLabelsOptionsObject|Array<Highcharts.SeriesNetworkgraphDataLabelsOptionsObject>}
*
* @apioption series.networkgraph.nodes.dataLabels
*/
''; // Adds doclets above to transpiled file