@carbon/charts-vue 0.48.3 → 0.49.2

package/charts-vue.umd.js

@@ -317,6 +317,7 @@ __webpack_require__.d(events_namespaceObject, "Tooltip", function() { return eve
 __webpack_require__.d(events_namespaceObject, "Threshold", function() { return events_Threshold; });
 __webpack_require__.d(events_namespaceObject, "Legend", function() { return events_Legend; });
 __webpack_require__.d(events_namespaceObject, "CirclePack", function() { return events_CirclePack; });
+__webpack_require__.d(events_namespaceObject, "Alluvial", function() { return events_Alluvial; });
 __webpack_require__.d(events_namespaceObject, "Meter", function() { return events_Meter; });
 var configuration_namespaceObject = {};
 __webpack_require__.r(configuration_namespaceObject);
@@ -337,6 +338,7 @@ __webpack_require__.d(configuration_namespaceObject, "lines", function() { retur
 __webpack_require__.d(configuration_namespaceObject, "meter", function() { return meter; });
 __webpack_require__.d(configuration_namespaceObject, "pie", function() { return configuration_non_customizable_pie; });
 __webpack_require__.d(configuration_namespaceObject, "radar", function() { return radar; });
+__webpack_require__.d(configuration_namespaceObject, "alluvial", function() { return alluvial; });
 __webpack_require__.d(configuration_namespaceObject, "spacers", function() { return spacers; });
 __webpack_require__.d(configuration_namespaceObject, "tooltips", function() { return tooltips; });
 __webpack_require__.d(configuration_namespaceObject, "transitions", function() { return configuration_non_customizable_transitions; });
@@ -634,6 +636,20 @@ var events_CirclePack;
     CirclePack["CIRCLE_MOUSEOUT"] = "circle-leaf-mouseout";
     CirclePack["CIRCLE_MOUSEMOVE"] = "circle-leaf-mousemove";
 })(events_CirclePack || (events_CirclePack = {}));
+/**
+ * enum of all alluvial related events
+ */
+var events_Alluvial;
+(function (Alluvial) {
+    Alluvial["NODE_MOUSEOVER"] = "alluvial-node-mouseover";
+    Alluvial["NODE_CLICK"] = "alluvial-node-click";
+    Alluvial["NODE_MOUSEOUT"] = "alluvial-node-mouseout";
+    Alluvial["NODE_MOUSEMOVE"] = "alluvial-node-mousemove";
+    Alluvial["LINE_MOUSEOVER"] = "alluvial-line-mouseover";
+    Alluvial["LINE_CLICK"] = "alluvial-line-click";
+    Alluvial["LINE_MOUSEOUT"] = "alluvial-line-mouseout";
+    Alluvial["LINE_MOUSEMOVE"] = "alluvial-line-mousemove";
+})(events_Alluvial || (events_Alluvial = {}));
 /**
  * enum of all meter related events
  */
@@ -1101,6 +1117,16 @@ var radar = {
     xAxisRectHeight: 50,
     dotsRadius: 5,
 };
+var alluvial = {
+    nodeWidth: 4,
+    nodeHoveredWidth: 8,
+    minNodePadding: 24,
+    opacity: {
+        unfocus: 0.3,
+        default: 0.8,
+        selected: 1,
+    },
+};
 var spacers = {
     default: {
         size: 24,
@@ -8748,6 +8774,16 @@ var circlePackChart = tools_Tools.merge({}, chart, circlePack, {
         groupMapsTo: 'name',
     }),
 });
+var alluvialChart = tools_Tools.merge({}, chart, {
+    alluvial: {
+        data: tools_Tools.merge(chart.data, {
+            groupMapsTo: 'source',
+        }),
+        nodePadding: 24,
+        monochrome: false,
+        nodes: [],
+    },
+});
 var configuration_options = {
     chart: chart,
     axisChart: axisChart,
@@ -8774,6 +8810,7 @@ var configuration_options = {
     treemapChart: treemapChart,
     circlePackChart: circlePackChart,
     wordCloudChart: wordCloudChart,
+    alluvialChart: alluvialChart,
 };
 
 //# sourceMappingURL=../src/configuration.js.map
@@ -9417,7 +9454,9 @@ var model_ChartModel = /** @class */ (function () {
         var axesOptions = tools_Tools.getProperty(options, 'axes');
         // filter out the groups that are irrelevant to the component
         if (groups) {
-            allData = allData.filter(function (item) { return groups.includes(item.group); });
+            allData = allData.filter(function (item) {
+                return groups.includes(item[groupMapsTo]);
+            });
         }
         if (axesOptions) {
             Object.keys(axesOptions).forEach(function (axis) {
@@ -19180,6 +19219,7 @@ var legend_Legend = /** @class */ (function (_super) {
         var userProvidedOrder = tools_Tools.getProperty(legendOptions, 'order');
         var svg = this.getComponentContainer()
             .classed('center-aligned', alignment === Alignments.CENTER)
+            .classed('right-aligned', alignment === Alignments.RIGHT)
             .classed(legendOrientation, true)
             .classed('has-deactivated-items', hasDeactivatedItems)
             .attr('role', Roles.GROUP)
@@ -19443,12 +19483,12 @@ var legend_Legend = /** @class */ (function (_super) {
         }
     };
     Legend.prototype.truncateLegendText = function (addedLegendItemsText) {
-        var trucationOptions = tools_Tools.getProperty(this.getOptions(), 'legend', 'truncation');
+        var truncationOptions = tools_Tools.getProperty(this.getOptions(), 'legend', 'truncation');
         // Truncation
         // get user provided custom values for truncation
-        var truncationType = tools_Tools.getProperty(trucationOptions, 'type');
-        var truncationThreshold = tools_Tools.getProperty(trucationOptions, 'threshold');
-        var truncationNumCharacter = tools_Tools.getProperty(trucationOptions, 'numCharacter');
+        var truncationType = tools_Tools.getProperty(truncationOptions, 'type');
+        var truncationThreshold = tools_Tools.getProperty(truncationOptions, 'threshold');
+        var truncationNumCharacter = tools_Tools.getProperty(truncationOptions, 'numCharacter');
         // truncate the legend label if it's too long
         if (truncationType !== TruncationTypes.NONE) {
             addedLegendItemsText.html(function (d) {
@@ -26800,10 +26840,10 @@ var bar_stacked_StackedBar = /** @class */ (function (_super) {
             var matchingDataPoint = displayData.find(function (d) {
                 var domainIdentifier = self.services.cartesianScales.getDomainIdentifier(d);
                 var rangeIdentifier = self.services.cartesianScales.getRangeIdentifier(d);
-                return (d[rangeIdentifier] === datum.data[datum.group] &&
+                return (d[rangeIdentifier] === datum.data[datum[groupMapsTo]] &&
                     d[domainIdentifier].toString() ===
                         datum.data.sharedStackKey &&
-                    d[groupMapsTo] === datum.group);
+                    d[groupMapsTo] === datum[groupMapsTo]);
             });
             if (matchingDataPoint === undefined) {
                 // use the primary range and domain ids
@@ -26811,8 +26851,8 @@ var bar_stacked_StackedBar = /** @class */ (function (_super) {
                 var rangeIdentifier = self.services.cartesianScales.getRangeIdentifier();
                 matchingDataPoint = (_a = {},
                     _a[domainIdentifier] = datum.data.sharedStackKey,
-                    _a[rangeIdentifier] = datum.data[datum.group],
-                    _a[groupMapsTo] = datum.group,
+                    _a[rangeIdentifier] = datum.data[datum[groupMapsTo]],
+                    _a[groupMapsTo] = datum[groupMapsTo],
                     _a);
             }
             // Show tooltip
@@ -34252,6 +34292,1191 @@ var wordcloud_WordCloud = /** @class */ (function (_super) {
 }(component_Component));
 
 //# sourceMappingURL=../../../src/components/graphs/wordcloud.js.map
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/node_modules/d3-array/src/sum.js
+function src_sum_sum(values, valueof) {
+  let sum = 0;
+  if (valueof === undefined) {
+    for (let value of values) {
+      if (value = +value) {
+        sum += value;
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if (value = +valueof(value, ++index, values)) {
+        sum += value;
+      }
+    }
+  }
+  return sum;
+}
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/node_modules/d3-array/src/max.js
+function src_max_max(values, valueof) {
+  let max;
+  if (valueof === undefined) {
+    for (const value of values) {
+      if (value != null
+          && (max < value || (max === undefined && value >= value))) {
+        max = value;
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null
+          && (max < value || (max === undefined && value >= value))) {
+        max = value;
+      }
+    }
+  }
+  return max;
+}
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/node_modules/d3-array/src/min.js
+function src_min_min(values, valueof) {
+  let min;
+  if (valueof === undefined) {
+    for (const value of values) {
+      if (value != null
+          && (min > value || (min === undefined && value >= value))) {
+        min = value;
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null
+          && (min > value || (min === undefined && value >= value))) {
+        min = value;
+      }
+    }
+  }
+  return min;
+}
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/src/align.js
+
+
+function targetDepth(d) {
+  return d.target.depth;
+}
+
+function align_left(node) {
+  return node.depth;
+}
+
+function align_right(node, n) {
+  return n - 1 - node.height;
+}
+
+function justify(node, n) {
+  return node.sourceLinks.length ? node.depth : n - 1;
+}
+
+function center(node) {
+  return node.targetLinks.length ? node.depth
+      : node.sourceLinks.length ? src_min_min(node.sourceLinks, targetDepth) - 1
+      : 0;
+}
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/src/constant.js
+function constant_constant(x) {
+  return function() {
+    return x;
+  };
+}
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/src/sankey.js
+
+
+
+
+function ascendingSourceBreadth(a, b) {
+  return ascendingBreadth(a.source, b.source) || a.index - b.index;
+}
+
+function ascendingTargetBreadth(a, b) {
+  return ascendingBreadth(a.target, b.target) || a.index - b.index;
+}
+
+function ascendingBreadth(a, b) {
+  return a.y0 - b.y0;
+}
+
+function sankey_value(d) {
+  return d.value;
+}
+
+function defaultId(d) {
+  return d.index;
+}
+
+function defaultNodes(graph) {
+  return graph.nodes;
+}
+
+function defaultLinks(graph) {
+  return graph.links;
+}
+
+function sankey_find(nodeById, id) {
+  const node = nodeById.get(id);
+  if (!node) throw new Error("missing: " + id);
+  return node;
+}
+
+function computeLinkBreadths({nodes}) {
+  for (const node of nodes) {
+    let y0 = node.y0;
+    let y1 = y0;
+    for (const link of node.sourceLinks) {
+      link.y0 = y0 + link.width / 2;
+      y0 += link.width;
+    }
+    for (const link of node.targetLinks) {
+      link.y1 = y1 + link.width / 2;
+      y1 += link.width;
+    }
+  }
+}
+
+function Sankey() {
+  let x0 = 0, y0 = 0, x1 = 1, y1 = 1; // extent
+  let dx = 24; // nodeWidth
+  let dy = 8, py; // nodePadding
+  let id = defaultId;
+  let align = justify;
+  let sort;
+  let linkSort;
+  let nodes = defaultNodes;
+  let links = defaultLinks;
+  let iterations = 6;
+
+  function sankey() {
+    const graph = {nodes: nodes.apply(null, arguments), links: links.apply(null, arguments)};
+    computeNodeLinks(graph);
+    computeNodeValues(graph);
+    computeNodeDepths(graph);
+    computeNodeHeights(graph);
+    computeNodeBreadths(graph);
+    computeLinkBreadths(graph);
+    return graph;
+  }
+
+  sankey.update = function(graph) {
+    computeLinkBreadths(graph);
+    return graph;
+  };
+
+  sankey.nodeId = function(_) {
+    return arguments.length ? (id = typeof _ === "function" ? _ : constant_constant(_), sankey) : id;
+  };
+
+  sankey.nodeAlign = function(_) {
+    return arguments.length ? (align = typeof _ === "function" ? _ : constant_constant(_), sankey) : align;
+  };
+
+  sankey.nodeSort = function(_) {
+    return arguments.length ? (sort = _, sankey) : sort;
+  };
+
+  sankey.nodeWidth = function(_) {
+    return arguments.length ? (dx = +_, sankey) : dx;
+  };
+
+  sankey.nodePadding = function(_) {
+    return arguments.length ? (dy = py = +_, sankey) : dy;
+  };
+
+  sankey.nodes = function(_) {
+    return arguments.length ? (nodes = typeof _ === "function" ? _ : constant_constant(_), sankey) : nodes;
+  };
+
+  sankey.links = function(_) {
+    return arguments.length ? (links = typeof _ === "function" ? _ : constant_constant(_), sankey) : links;
+  };
+
+  sankey.linkSort = function(_) {
+    return arguments.length ? (linkSort = _, sankey) : linkSort;
+  };
+
+  sankey.size = function(_) {
+    return arguments.length ? (x0 = y0 = 0, x1 = +_[0], y1 = +_[1], sankey) : [x1 - x0, y1 - y0];
+  };
+
+  sankey.extent = function(_) {
+    return arguments.length ? (x0 = +_[0][0], x1 = +_[1][0], y0 = +_[0][1], y1 = +_[1][1], sankey) : [[x0, y0], [x1, y1]];
+  };
+
+  sankey.iterations = function(_) {
+    return arguments.length ? (iterations = +_, sankey) : iterations;
+  };
+
+  function computeNodeLinks({nodes, links}) {
+    for (const [i, node] of nodes.entries()) {
+      node.index = i;
+      node.sourceLinks = [];
+      node.targetLinks = [];
+    }
+    const nodeById = new Map(nodes.map((d, i) => [id(d, i, nodes), d]));
+    for (const [i, link] of links.entries()) {
+      link.index = i;
+      let {source, target} = link;
+      if (typeof source !== "object") source = link.source = sankey_find(nodeById, source);
+      if (typeof target !== "object") target = link.target = sankey_find(nodeById, target);
+      source.sourceLinks.push(link);
+      target.targetLinks.push(link);
+    }
+    if (linkSort != null) {
+      for (const {sourceLinks, targetLinks} of nodes) {
+        sourceLinks.sort(linkSort);
+        targetLinks.sort(linkSort);
+      }
+    }
+  }
+
+  function computeNodeValues({nodes}) {
+    for (const node of nodes) {
+      node.value = node.fixedValue === undefined
+          ? Math.max(src_sum_sum(node.sourceLinks, sankey_value), src_sum_sum(node.targetLinks, sankey_value))
+          : node.fixedValue;
+    }
+  }
+
+  function computeNodeDepths({nodes}) {
+    const n = nodes.length;
+    let current = new Set(nodes);
+    let next = new Set;
+    let x = 0;
+    while (current.size) {
+      for (const node of current) {
+        node.depth = x;
+        for (const {target} of node.sourceLinks) {
+          next.add(target);
+        }
+      }
+      if (++x > n) throw new Error("circular link");
+      current = next;
+      next = new Set;
+    }
+  }
+
+  function computeNodeHeights({nodes}) {
+    const n = nodes.length;
+    let current = new Set(nodes);
+    let next = new Set;
+    let x = 0;
+    while (current.size) {
+      for (const node of current) {
+        node.height = x;
+        for (const {source} of node.targetLinks) {
+          next.add(source);
+        }
+      }
+      if (++x > n) throw new Error("circular link");
+      current = next;
+      next = new Set;
+    }
+  }
+
+  function computeNodeLayers({nodes}) {
+    const x = src_max_max(nodes, d => d.depth) + 1;
+    const kx = (x1 - x0 - dx) / (x - 1);
+    const columns = new Array(x);
+    for (const node of nodes) {
+      const i = Math.max(0, Math.min(x - 1, Math.floor(align.call(null, node, x))));
+      node.layer = i;
+      node.x0 = x0 + i * kx;
+      node.x1 = node.x0 + dx;
+      if (columns[i]) columns[i].push(node);
+      else columns[i] = [node];
+    }
+    if (sort) for (const column of columns) {
+      column.sort(sort);
+    }
+    return columns;
+  }
+
+  function initializeNodeBreadths(columns) {
+    const ky = src_min_min(columns, c => (y1 - y0 - (c.length - 1) * py) / src_sum_sum(c, sankey_value));
+    for (const nodes of columns) {
+      let y = y0;
+      for (const node of nodes) {
+        node.y0 = y;
+        node.y1 = y + node.value * ky;
+        y = node.y1 + py;
+        for (const link of node.sourceLinks) {
+          link.width = link.value * ky;
+        }
+      }
+      y = (y1 - y + py) / (nodes.length + 1);
+      for (let i = 0; i < nodes.length; ++i) {
+        const node = nodes[i];
+        node.y0 += y * (i + 1);
+        node.y1 += y * (i + 1);
+      }
+      reorderLinks(nodes);
+    }
+  }
+
+  function computeNodeBreadths(graph) {
+    const columns = computeNodeLayers(graph);
+    py = Math.min(dy, (y1 - y0) / (src_max_max(columns, c => c.length) - 1));
+    initializeNodeBreadths(columns);
+    for (let i = 0; i < iterations; ++i) {
+      const alpha = Math.pow(0.99, i);
+      const beta = Math.max(1 - alpha, (i + 1) / iterations);
+      relaxRightToLeft(columns, alpha, beta);
+      relaxLeftToRight(columns, alpha, beta);
+    }
+  }
+
+  // Reposition each node based on its incoming (target) links.
+  function relaxLeftToRight(columns, alpha, beta) {
+    for (let i = 1, n = columns.length; i < n; ++i) {
+      const column = columns[i];
+      for (const target of column) {
+        let y = 0;
+        let w = 0;
+        for (const {source, value} of target.targetLinks) {
+          let v = value * (target.layer - source.layer);
+          y += targetTop(source, target) * v;
+          w += v;
+        }
+        if (!(w > 0)) continue;
+        let dy = (y / w - target.y0) * alpha;
+        target.y0 += dy;
+        target.y1 += dy;
+        reorderNodeLinks(target);
+      }
+      if (sort === undefined) column.sort(ascendingBreadth);
+      resolveCollisions(column, beta);
+    }
+  }
+
+  // Reposition each node based on its outgoing (source) links.
+  function relaxRightToLeft(columns, alpha, beta) {
+    for (let n = columns.length, i = n - 2; i >= 0; --i) {
+      const column = columns[i];
+      for (const source of column) {
+        let y = 0;
+        let w = 0;
+        for (const {target, value} of source.sourceLinks) {
+          let v = value * (target.layer - source.layer);
+          y += sourceTop(source, target) * v;
+          w += v;
+        }
+        if (!(w > 0)) continue;
+        let dy = (y / w - source.y0) * alpha;
+        source.y0 += dy;
+        source.y1 += dy;
+        reorderNodeLinks(source);
+      }
+      if (sort === undefined) column.sort(ascendingBreadth);
+      resolveCollisions(column, beta);
+    }
+  }
+
+  function resolveCollisions(nodes, alpha) {
+    const i = nodes.length >> 1;
+    const subject = nodes[i];
+    resolveCollisionsBottomToTop(nodes, subject.y0 - py, i - 1, alpha);
+    resolveCollisionsTopToBottom(nodes, subject.y1 + py, i + 1, alpha);
+    resolveCollisionsBottomToTop(nodes, y1, nodes.length - 1, alpha);
+    resolveCollisionsTopToBottom(nodes, y0, 0, alpha);
+  }
+
+  // Push any overlapping nodes down.
+  function resolveCollisionsTopToBottom(nodes, y, i, alpha) {
+    for (; i < nodes.length; ++i) {
+      const node = nodes[i];
+      const dy = (y - node.y0) * alpha;
+      if (dy > 1e-6) node.y0 += dy, node.y1 += dy;
+      y = node.y1 + py;
+    }
+  }
+
+  // Push any overlapping nodes up.
+  function resolveCollisionsBottomToTop(nodes, y, i, alpha) {
+    for (; i >= 0; --i) {
+      const node = nodes[i];
+      const dy = (node.y1 - y) * alpha;
+      if (dy > 1e-6) node.y0 -= dy, node.y1 -= dy;
+      y = node.y0 - py;
+    }
+  }
+
+  function reorderNodeLinks({sourceLinks, targetLinks}) {
+    if (linkSort === undefined) {
+      for (const {source: {sourceLinks}} of targetLinks) {
+        sourceLinks.sort(ascendingTargetBreadth);
+      }
+      for (const {target: {targetLinks}} of sourceLinks) {
+        targetLinks.sort(ascendingSourceBreadth);
+      }
+    }
+  }
+
+  function reorderLinks(nodes) {
+    if (linkSort === undefined) {
+      for (const {sourceLinks, targetLinks} of nodes) {
+        sourceLinks.sort(ascendingTargetBreadth);
+        targetLinks.sort(ascendingSourceBreadth);
+      }
+    }
+  }
+
+  // Returns the target.y0 that would produce an ideal link from source to target.
+  function targetTop(source, target) {
+    let y = source.y0 - (source.sourceLinks.length - 1) * py / 2;
+    for (const {target: node, width} of source.sourceLinks) {
+      if (node === target) break;
+      y += width + py;
+    }
+    for (const {source: node, width} of target.targetLinks) {
+      if (node === source) break;
+      y -= width;
+    }
+    return y;
+  }
+
+  // Returns the source.y0 that would produce an ideal link from source to target.
+  function sourceTop(source, target) {
+    let y = target.y0 - (target.targetLinks.length - 1) * py / 2;
+    for (const {source: node, width} of target.targetLinks) {
+      if (node === source) break;
+      y += width + py;
+    }
+    for (const {target: node, width} of source.sourceLinks) {
+      if (node === target) break;
+      y -= width;
+    }
+    return y;
+  }
+
+  return sankey;
+}
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/node_modules/d3-path/src/path.js
+var src_path_pi = Math.PI,
+    src_path_tau = 2 * src_path_pi,
+    src_path_epsilon = 1e-6,
+    path_tauEpsilon = src_path_tau - src_path_epsilon;
+
+function path_Path() {
+  this._x0 = this._y0 = // start of current subpath
+  this._x1 = this._y1 = null; // end of current subpath
+  this._ = "";
+}
+
+function src_path_path() {
+  return new path_Path;
+}
+
+path_Path.prototype = src_path_path.prototype = {
+  constructor: path_Path,
+  moveTo: function(x, y) {
+    this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y);
+  },
+  closePath: function() {
+    if (this._x1 !== null) {
+      this._x1 = this._x0, this._y1 = this._y0;
+      this._ += "Z";
+    }
+  },
+  lineTo: function(x, y) {
+    this._ += "L" + (this._x1 = +x) + "," + (this._y1 = +y);
+  },
+  quadraticCurveTo: function(x1, y1, x, y) {
+    this._ += "Q" + (+x1) + "," + (+y1) + "," + (this._x1 = +x) + "," + (this._y1 = +y);
+  },
+  bezierCurveTo: function(x1, y1, x2, y2, x, y) {
+    this._ += "C" + (+x1) + "," + (+y1) + "," + (+x2) + "," + (+y2) + "," + (this._x1 = +x) + "," + (this._y1 = +y);
+  },
+  arcTo: function(x1, y1, x2, y2, r) {
+    x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;
+    var x0 = this._x1,
+        y0 = this._y1,
+        x21 = x2 - x1,
+        y21 = y2 - y1,
+        x01 = x0 - x1,
+        y01 = y0 - y1,
+        l01_2 = x01 * x01 + y01 * y01;
+
+    // Is the radius negative? Error.
+    if (r < 0) throw new Error("negative radius: " + r);
+
+    // Is this path empty? Move to (x1,y1).
+    if (this._x1 === null) {
+      this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1);
+    }
+
+    // Or, is (x1,y1) coincident with (x0,y0)? Do nothing.
+    else if (!(l01_2 > src_path_epsilon));
+
+    // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?
+    // Equivalently, is (x1,y1) coincident with (x2,y2)?
+    // Or, is the radius zero? Line to (x1,y1).
+    else if (!(Math.abs(y01 * x21 - y21 * x01) > src_path_epsilon) || !r) {
+      this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1);
+    }
+
+    // Otherwise, draw an arc!
+    else {
+      var x20 = x2 - x0,
+          y20 = y2 - y0,
+          l21_2 = x21 * x21 + y21 * y21,
+          l20_2 = x20 * x20 + y20 * y20,
+          l21 = Math.sqrt(l21_2),
+          l01 = Math.sqrt(l01_2),
+          l = r * Math.tan((src_path_pi - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2),
+          t01 = l / l01,
+          t21 = l / l21;
+
+      // If the start tangent is not coincident with (x0,y0), line to.
+      if (Math.abs(t01 - 1) > src_path_epsilon) {
+        this._ += "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01);
+      }
+
+      this._ += "A" + r + "," + r + ",0,0," + (+(y01 * x20 > x01 * y20)) + "," + (this._x1 = x1 + t21 * x21) + "," + (this._y1 = y1 + t21 * y21);
+    }
+  },
+  arc: function(x, y, r, a0, a1, ccw) {
+    x = +x, y = +y, r = +r, ccw = !!ccw;
+    var dx = r * Math.cos(a0),
+        dy = r * Math.sin(a0),
+        x0 = x + dx,
+        y0 = y + dy,
+        cw = 1 ^ ccw,
+        da = ccw ? a0 - a1 : a1 - a0;
+
+    // Is the radius negative? Error.
+    if (r < 0) throw new Error("negative radius: " + r);
+
+    // Is this path empty? Move to (x0,y0).
+    if (this._x1 === null) {
+      this._ += "M" + x0 + "," + y0;
+    }
+
+    // Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0).
+    else if (Math.abs(this._x1 - x0) > src_path_epsilon || Math.abs(this._y1 - y0) > src_path_epsilon) {
+      this._ += "L" + x0 + "," + y0;
+    }
+
+    // Is this arc empty? We’re done.
+    if (!r) return;
+
+    // Does the angle go the wrong way? Flip the direction.
+    if (da < 0) da = da % src_path_tau + src_path_tau;
+
+    // Is this a complete circle? Draw two arcs to complete the circle.
+    if (da > path_tauEpsilon) {
+      this._ += "A" + r + "," + r + ",0,1," + cw + "," + (x - dx) + "," + (y - dy) + "A" + r + "," + r + ",0,1," + cw + "," + (this._x1 = x0) + "," + (this._y1 = y0);
+    }
+
+    // Is this arc non-empty? Draw an arc!
+    else if (da > src_path_epsilon) {
+      this._ += "A" + r + "," + r + ",0," + (+(da >= src_path_pi)) + "," + cw + "," + (this._x1 = x + r * Math.cos(a1)) + "," + (this._y1 = y + r * Math.sin(a1));
+    }
+  },
+  rect: function(x, y, w, h) {
+    this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y) + "h" + (+w) + "v" + (+h) + "h" + (-w) + "Z";
+  },
+  toString: function() {
+    return this._;
+  }
+};
+
+/* harmony default export */ var d3_path_src_path = (src_path_path);
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/node_modules/d3-shape/src/array.js
+var src_array_slice = Array.prototype.slice;
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/node_modules/d3-shape/src/constant.js
+/* harmony default export */ var d3_shape_src_constant = (function(x) {
+  return function constant() {
+    return x;
+  };
+});
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/node_modules/d3-shape/src/point.js
+function src_point_x(p) {
+  return p[0];
+}
+
+function src_point_y(p) {
+  return p[1];
+}
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/node_modules/d3-shape/src/pointRadial.js
+/* harmony default export */ var src_pointRadial = (function(x, y) {
+  return [(y = +y) * Math.cos(x -= Math.PI / 2), y * Math.sin(x)];
+});
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/node_modules/d3-shape/src/link/index.js
+
+
+
+
+
+
+function link_linkSource(d) {
+  return d.source;
+}
+
+function link_linkTarget(d) {
+  return d.target;
+}
+
+function src_link_link(curve) {
+  var source = link_linkSource,
+      target = link_linkTarget,
+      x = src_point_x,
+      y = src_point_y,
+      context = null;
+
+  function link() {
+    var buffer, argv = src_array_slice.call(arguments), s = source.apply(this, argv), t = target.apply(this, argv);
+    if (!context) context = buffer = d3_path_src_path();
+    curve(context, +x.apply(this, (argv[0] = s, argv)), +y.apply(this, argv), +x.apply(this, (argv[0] = t, argv)), +y.apply(this, argv));
+    if (buffer) return context = null, buffer + "" || null;
+  }
+
+  link.source = function(_) {
+    return arguments.length ? (source = _, link) : source;
+  };
+
+  link.target = function(_) {
+    return arguments.length ? (target = _, link) : target;
+  };
+
+  link.x = function(_) {
+    return arguments.length ? (x = typeof _ === "function" ? _ : d3_shape_src_constant(+_), link) : x;
+  };
+
+  link.y = function(_) {
+    return arguments.length ? (y = typeof _ === "function" ? _ : d3_shape_src_constant(+_), link) : y;
+  };
+
+  link.context = function(_) {
+    return arguments.length ? ((context = _ == null ? null : _), link) : context;
+  };
+
+  return link;
+}
+
+function link_curveHorizontal(context, x0, y0, x1, y1) {
+  context.moveTo(x0, y0);
+  context.bezierCurveTo(x0 = (x0 + x1) / 2, y0, x0, y1, x1, y1);
+}
+
+function link_curveVertical(context, x0, y0, x1, y1) {
+  context.moveTo(x0, y0);
+  context.bezierCurveTo(x0, y0 = (y0 + y1) / 2, x1, y0, x1, y1);
+}
+
+function link_curveRadial(context, x0, y0, x1, y1) {
+  var p0 = src_pointRadial(x0, y0),
+      p1 = src_pointRadial(x0, y0 = (y0 + y1) / 2),
+      p2 = src_pointRadial(x1, y0),
+      p3 = src_pointRadial(x1, y1);
+  context.moveTo(p0[0], p0[1]);
+  context.bezierCurveTo(p1[0], p1[1], p2[0], p2[1], p3[0], p3[1]);
+}
+
+function link_linkHorizontal() {
+  return src_link_link(link_curveHorizontal);
+}
+
+function link_linkVertical() {
+  return src_link_link(link_curveVertical);
+}
+
+function link_linkRadial() {
+  var l = src_link_link(link_curveRadial);
+  l.angle = l.x, delete l.x;
+  l.radius = l.y, delete l.y;
+  return l;
+}
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/src/sankeyLinkHorizontal.js
+
+
+function horizontalSource(d) {
+  return [d.source.x1, d.y0];
+}
+
+function horizontalTarget(d) {
+  return [d.target.x0, d.y1];
+}
+
+/* harmony default export */ var sankeyLinkHorizontal = (function() {
+  return link_linkHorizontal()
+      .source(horizontalSource)
+      .target(horizontalTarget);
+});
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/d3-sankey/src/index.js
+
+
+
+
+// CONCATENATED MODULE: ./node_modules/@carbon/charts/components/graphs/alluvial.js
+var alluvial_extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+// Internal imports
+
+
+
+
+
+// D3 imports
+
+
+var alluvial_Alluvial = /** @class */ (function (_super) {
+    alluvial_extends(Alluvial, _super);
+    function Alluvial() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.type = 'alluvial';
+        _this.renderType = RenderTypes.SVG;
+        return _this;
+    }
+    Alluvial.prototype.render = function (animate) {
+        var _this = this;
+        if (animate === void 0) { animate = true; }
+        // svg and container widths
+        var svg = this.getComponentContainer({ withinChartClip: true });
+        svg.html('');
+        var _a = dom_utils_DOMUtils.getSVGElementSize(svg, {
+            useAttrs: true,
+        }), width = _a.width, height = _a.height;
+        // Because of a Firefox bug with regards to sizing & d3 packs,
+        // rather than checking if height or width aren't 0,
+        // we have to make sure they're not smaller than 1
+        if (width < 1 || height < 1) {
+            return;
+        }
+        var options = this.model.getOptions();
+        var data = this.model.getDisplayData();
+        // Set the custom node padding if provided
+        var nodePadding = alluvial.minNodePadding;
+        if (options.alluvial.nodePadding > alluvial.minNodePadding) {
+            nodePadding = options.alluvial.nodePadding;
+        }
+        var sankey = Sankey()
+            .nodeId(function (d) { return d.name; })
+            .nodeWidth(alluvial.nodeWidth)
+            // Distance nodes are apart from each other
+            .nodePadding(nodePadding)
+            // Size of the chart and its padding
+            // Chart starts at 2 and ends at width - 2 so the outer nodes can expand from center
+            // Chart starts from 30 so node categories can be displayed
+            .extent([
+            [2, 30],
+            [width - 2, height],
+        ]);
+        // Construct a graph with the provided user data
+        // Data must be deep cloned to ensure user passed data isn't deleted when themes change
+        this.graph = sankey({
+            nodes: options.alluvial.nodes.map(function (d) { return Object.assign({}, d); }),
+            links: data.map(function (d) { return Object.assign({}, d); }),
+        });
+        // Filter out unused nodes so they are not rendered
+        this.graph.nodes = this.graph.nodes.filter(function (node) { return node.value !== 0; });
+        // Determine the category name placement x position
+        var nodeCoordinates = {};
+        this.graph.nodes.forEach(function (element) {
+            var _a;
+            var point = element.x0;
+            // Only 1 category per x-value
+            if (element.category) {
+                nodeCoordinates[point] = (_a = element) === null || _a === void 0 ? void 0 : _a.category;
+            }
+        });
+        // Add node category text
+        var alluvialCategory = svg
+            .append('g')
+            .classed('header-arrows', true)
+            .selectAll('g')
+            .data(Object.keys(nodeCoordinates))
+            .join('g')
+            .attr('transform', function (d) {
+            return "translate(" + d + ", 0)";
+        });
+        // Add the category text
+        alluvialCategory
+            .append('text')
+            .attr('id', function (d, i) { return "category-" + i; })
+            .style('font-size', '14px')
+            .text(function (d) {
+            if (nodeCoordinates[d]) {
+                return nodeCoordinates[d];
+            }
+            return '';
+        })
+            .attr('y', 20)
+            .attr('x', function (d, i) {
+            var width = dom_utils_DOMUtils.getSVGElementSize(src_select("text#category-" + i), { useBBox: true }).width;
+            // Make the text on the left on node group (except first column)
+            var x = 0;
+            if (d + x >= width) {
+                x = -width + 4;
+            }
+            return x;
+        });
+        // Draws the links (Waves)
+        svg.append('g')
+            .attr('fill', 'none')
+            .selectAll('g')
+            .data(this.graph.links)
+            .join('path')
+            .classed('link', true)
+            .attr('d', sankeyLinkHorizontal())
+            .attr('id', function (d) { return "line-" + d.index; })
+            .attr('class', function (d) {
+            // Use a single color for the lines
+            if (options.alluvial.monochrome) {
+                return _this.model.getColorClassName({
+                    classNameTypes: [ColorClassNameTypes.STROKE],
+                    dataGroupName: 0,
+                    originalClassName: 'link',
+                });
+            }
+            return _this.model.getColorClassName({
+                classNameTypes: [ColorClassNameTypes.STROKE],
+                dataGroupName: d.source.index,
+                originalClassName: 'link',
+            });
+        })
+            .attr('stroke-width', function (d) { return Math.max(1, d.width); })
+            .style('stroke-opacity', alluvial.opacity.default)
+            .attr('aria-label', function (d) {
+            return d.source.name + " \u2192 " + d.target.name + " (" + d.value + (options.alluvial.units
+                ? ' ' + options.alluvial.units
+                : '') + ")";
+        });
+        // Creating the groups
+        var node = svg
+            .append('g')
+            .selectAll('g')
+            .data(this.graph.nodes)
+            .enter()
+            .append('g')
+            .attr('id', function (d) { return "node-" + d.index; })
+            .classed('node-group', true)
+            .attr('transform', function (d) { return "translate(" + d.x0 + ", " + d.y0 + ")"; });
+        // Creating the nodes
+        node.append('rect')
+            .classed('node', true)
+            .attr('height', function (d) { return d.y1 - d.y0; })
+            .attr('width', function (d) { return d.x1 - d.x0; })
+            .attr('fill', 'black');
+        // Group to hold the text & rectangle background
+        var textNode = node
+            .append('g')
+            .attr('id', function (d) { return "node-title-" + d.index; });
+        // Node title - text
+        textNode
+            .append('text')
+            .attr('id', function (d) { return "node-text-" + d.index; })
+            .attr('class', 'node-text')
+            .style('font-size', '12px')
+            .attr('text-anchor', 'start')
+            .attr('fill', 'white')
+            // Padding to text
+            .attr('x', 4)
+            // shift 13 pixels down to fit background container
+            .attr('dy', 13)
+            .text(function (d) {
+            return d.name + " (" + d.value + ")";
+        })
+            .attr('aria-label', function (d) {
+            return d.name + " (" + d.value + ")";
+        });
+        // Text background
+        textNode
+            .append('rect')
+            .classed('node-text-bg', true)
+            .attr('width', function (d, i) {
+            // Determine rectangle width based on text width
+            var width = dom_utils_DOMUtils.getSVGElementSize(src_select("text#node-text-" + i), { useBBox: true }).width;
+            return width + 8;
+        })
+            .attr('height', 18)
+            .attr('stroke-width', 2)
+            .lower();
+        // Position group based on text width
+        textNode.attr('transform', function (d, i) {
+            var width = dom_utils_DOMUtils.getSVGElementSize(src_select("text#node-text-" + i), { useBBox: true }).width;
+            // Subtracting 9 since text background is 18 to center
+            var y = (d.y1 - d.y0) / 2 - 9;
+            // Node width
+            var x = d.x1 - d.x0;
+            // Display bars on the right instead of left of the node
+            if (d.x1 >= width) {
+                // 16 = node width (4) + text container padding (8) + distance between node and text container (4)
+                x = x - (width + 16);
+            }
+            else {
+                // Add padding to text containers
+                x += 4;
+            }
+            return "translate(" + x + ", " + y + ")";
+        });
+        this.addLineEventListener();
+        this.addNodeEventListener();
+    };
+    Alluvial.prototype.addLineEventListener = function () {
+        var options = this.getOptions();
+        var self = this;
+        // Set delay to counter flashy behaviour
+        var debouncedLineHighlight = tools_Tools.debounce(function (link, event) {
+            if (event === void 0) { event = 'mouseover'; }
+            var allLinks = self.parent
+                .selectAll('path.link')
+                .transition(self.services.transitions.getTransition('alluvial-link-mouse-highlight'));
+            if (event === 'mouseout') {
+                src_select(link).lower();
+                allLinks.style('stroke-opacity', alluvial.opacity.default);
+            }
+            else {
+                allLinks.style('stroke-opacity', function () {
+                    // highlight and raise if link is this
+                    if (link === this) {
+                        src_select(this).raise();
+                        return alluvial.opacity.selected;
+                    }
+                    return alluvial.opacity.unfocus;
+                });
+            }
+        }, 33);
+        this.parent
+            .selectAll('path.link')
+            .on('mouseover', function (event, datum) {
+            var hoveredElement = src_select(this);
+            debouncedLineHighlight(this, 'mouseover');
+            hoveredElement.classed('link-hovered', true);
+            var strokeColor = getComputedStyle(this).getPropertyValue('stroke');
+            // Dispatch mouse over event
+            self.services.events.dispatchEvent(Events.Alluvial.LINE_MOUSEOVER, {
+                event: event,
+                element: hoveredElement,
+                datum: datum,
+            });
+            // Dispatch tooltip show event
+            self.services.events.dispatchEvent(Events.Tooltip.SHOW, {
+                event: event,
+                hoveredElement: hoveredElement,
+                items: [
+                    {
+                        label: datum.target.name,
+                        value: datum.value +
+                            (options.alluvial.units
+                                ? " " + options.alluvial.units
+                                : ''),
+                        color: strokeColor,
+                        labelIcon: self.getRightArrowIcon(),
+                    },
+                ],
+            });
+        })
+            .on('mousemove', function (event, datum) {
+            // Dispatch mouse move event
+            self.services.events.dispatchEvent(Events.Alluvial.LINE_MOUSEMOVE, {
+                event: event,
+                element: src_select(this),
+                datum: datum,
+            });
+            // Dispatch tooltip move event
+            self.services.events.dispatchEvent(Events.Tooltip.MOVE, {
+                event: event,
+            });
+        })
+            .on('click', function (event, datum) {
+            // Dispatch mouse click event
+            self.services.events.dispatchEvent(Events.Alluvial.LINE_CLICK, {
+                event: event,
+                element: src_select(this),
+                datum: datum,
+            });
+        })
+            .on('mouseout', function (event, datum) {
+            var hoveredElement = src_select(this);
+            debouncedLineHighlight(this, 'mouseout');
+            hoveredElement.classed('link-hovered', false);
+            // Dispatch mouse out event
+            self.services.events.dispatchEvent(Events.Alluvial.LINE_MOUSEOUT, {
+                event: event,
+                element: hoveredElement,
+                datum: datum,
+            });
+            // Dispatch hide tooltip event
+            self.services.events.dispatchEvent(Events.Tooltip.HIDE, {
+                event: event,
+                hoveredElement: hoveredElement,
+            });
+        });
+    };
+    Alluvial.prototype.addNodeEventListener = function () {
+        var _this = this;
+        var self = this;
+        // Set delay to counter flashy behaviour
+        var debouncedLineHighlight = tools_Tools.debounce(function (links, event) {
+            if (links === void 0) { links = []; }
+            if (event === void 0) { event = 'mouseover'; }
+            if (event === 'mouseout' || links.length === 0) {
+                // set all links to default opacity & corret link order
+                self.parent
+                    .selectAll('path.link')
+                    .classed('link-hovered', false)
+                    .data(_this.graph.links, function (d) { return d.index; })
+                    .order()
+                    .style('stroke-opacity', alluvial.opacity.default);
+                return;
+            }
+            // Highlight all nodes
+            var allLinks = self.parent
+                .selectAll('path.link')
+                .transition(self.services.transitions.getTransition('alluvial-links-mouse-highlight'));
+            allLinks.style('stroke-opacity', function (d) {
+                // Raise the links & increase stroke-opacity to selected
+                if (links.some(function (element) { return element === d.index; })) {
+                    src_select(this).classed('link-hovered', true).raise();
+                    return alluvial.opacity.selected;
+                }
+                return alluvial.opacity.unfocus;
+            });
+        }, 66);
+        self.parent
+            .selectAll('.node-group')
+            .on('mouseover', function (event, datum) {
+            var hoveredElement = src_select(this);
+            // Highlight all links that pass through node
+            var paths = [];
+            // Outgoing links
+            self.traverse({ link: 'sourceLinks', node: 'target' }, datum, paths);
+            //Incoming links
+            self.traverse({ link: 'targetLinks', node: 'source' }, datum, paths);
+            // Highlight all linked lines in the graph data structure
+            if (paths.length) {
+                // Get transformation value of node
+                var nodeMatrix = tools_Tools.getTranformOffsets(hoveredElement.attr('transform'));
+                // Move node to the left by 2 to grow node from the center
+                hoveredElement.attr('transform', "translate(" + (nodeMatrix.x - 2) + ", " + nodeMatrix.y + ")");
+                hoveredElement
+                    .classed('node-hovered', true)
+                    .selectAll('rect.node')
+                    .attr('width', 8);
+                // Translate first column text container to the
+                // right so it doesn't clash with expanding node
+                if (datum.x0 - 2 === 0) {
+                    var titleContainer = self.parent.select("g#node-title-" + datum.index);
+                    var titleMatrix = tools_Tools.getTranformOffsets(titleContainer.attr('transform'));
+                    titleContainer.attr('transform', "translate(" + (titleMatrix.x + 4) + "," + titleMatrix.y + ")");
+                }
+                self.parent
+                    .select("text#node-text-" + datum.index)
+                    .style('font-weight', 'bold');
+                debouncedLineHighlight(paths, 'mouseover');
+                // Dispatch mouse over event
+                self.services.events.dispatchEvent(Events.Alluvial.NODE_MOUSEOVER, {
+                    event: event,
+                    element: hoveredElement,
+                    datum: datum,
+                });
+            }
+        })
+            .on('mousemove', function (event, datum) {
+            // Dispatch mouse move event
+            self.services.events.dispatchEvent(Events.Alluvial.NODE_MOUSEMOVE, {
+                event: event,
+                element: src_select(this),
+                datum: datum,
+            });
+            // Dispatch tooltip move event
+            self.services.events.dispatchEvent(Events.Tooltip.MOVE, {
+                event: event,
+            });
+        })
+            .on('click', function (event, datum) {
+            // Dispatch mouse click event
+            self.services.events.dispatchEvent(Events.Alluvial.NODE_CLICK, {
+                event: event,
+                element: src_select(this),
+                datum: datum,
+            });
+        })
+            .on('mouseout', function (event, datum) {
+            var hoveredElement = src_select(this);
+            // Set the node position to initial state (unexpanded)
+            var nodeMatrix = tools_Tools.getTranformOffsets(hoveredElement.attr('transform'));
+            hoveredElement
+                .classed('node-hovered', false)
+                .attr('transform', "translate(" + (nodeMatrix.x + 2) + ", " + nodeMatrix.y + ")")
+                .select('rect.node')
+                .attr('width', alluvial.nodeWidth);
+            // Translate text container back to initial state
+            if (datum.x0 - 2 === 0) {
+                var titleContainer = self.parent.select("g#node-title-" + datum.index);
+                var titleMatrix = tools_Tools.getTranformOffsets(titleContainer.attr('transform'));
+                titleContainer.attr('transform', "translate(" + (titleMatrix.x - 4) + "," + titleMatrix.y + ")");
+            }
+            self.parent
+                .select("text#node-text-" + datum.index)
+                .style('font-weight', 'normal');
+            debouncedLineHighlight([], 'mouseout');
+            // Dispatch mouse out event
+            self.services.events.dispatchEvent(Events.Alluvial.NODE_MOUSEOUT, {
+                event: event,
+                element: hoveredElement,
+                datum: datum,
+            });
+            // Dispatch hide tooltip event
+            self.services.events.dispatchEvent(Events.Tooltip.HIDE, {
+                hoveredElement: hoveredElement,
+            });
+        });
+    };
+    // Traverse graph and get all connected links to node
+    Alluvial.prototype.traverse = function (direction, node, visited) {
+        var _this = this;
+        if (visited === void 0) { visited = []; }
+        var links = node[direction.link].map(function (element) {
+            visited.push(element.index);
+            return element[direction.node];
+        });
+        // Retrieve the child nodes
+        links.forEach(function (element) { return _this.traverse(direction, element, visited); });
+    };
+    Alluvial.prototype.getRightArrowIcon = function () {
+        return "\n\t\t<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"32\" height=\"32\" viewBox=\"0 0 32 32\">\n\t\t\t<polygon points=\"18 6 16.57 7.393 24.15 15 4 15 4 17 24.15 17 16.57 24.573 18 26 28 16 18 6\"/>\n\t\t\t<rect  data-name=\"&lt;Transparent Rectangle&gt;\" style=\"fill: none;\" width=\"32\" height=\"32\"/>\n\t\t</svg>";
+    };
+    // Remove event listeners
+    Alluvial.prototype.destroy = function () {
+        this.parent
+            .selectAll('path.line,.node-group')
+            .on('mouseover', null)
+            .on('mousemove', null)
+            .on('click', null)
+            .on('mouseout', null);
+    };
+    return Alluvial;
+}(component_Component));
+
+//# sourceMappingURL=../../../src/components/graphs/alluvial.js.map
 // CONCATENATED MODULE: ./node_modules/@carbon/charts/components/layout/spacer.js
 var spacer_extends = (undefined && undefined.__extends) || (function () {
     var extendStatics = function (d, b) {
@@ -34504,7 +35729,7 @@ function axis_number(scale) {
   return d => +scale(d);
 }
 
-function center(scale, offset) {
+function axis_center(scale, offset) {
   offset = Math.max(0, scale.bandwidth() - offset * 2) / 2;
   if (scale.round()) offset = Math.round(offset);
   return d => +scale(d) + offset;
@@ -34533,7 +35758,7 @@ function axis_axis(orient, scale) {
         range = scale.range(),
         range0 = +range[0] + offset,
         range1 = +range[range.length - 1] + offset,
-        position = (scale.bandwidth ? center : axis_number)(scale.copy(), offset),
+        position = (scale.bandwidth ? axis_center : axis_number)(scale.copy(), offset),
         selection = context.selection ? context.selection() : context,
         path = selection.selectAll(".domain").data([null]),
         tick = selection.selectAll(".tick").data(values, scale).order(),
@@ -37936,6 +39161,7 @@ var tee = {
 
 
 
+
 
 
 // Layout
@@ -40533,6 +41759,51 @@ var wordcloud_WordCloudChart = /** @class */ (function (_super) {
 }(chart_Chart));
 
 //# sourceMappingURL=../../src/charts/wordcloud.js.map
+// CONCATENATED MODULE: ./node_modules/@carbon/charts/charts/alluvial.js
+var charts_alluvial_extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+// Internal Imports
+
+
+
+// Components
+
+var alluvial_AlluvialChart = /** @class */ (function (_super) {
+    charts_alluvial_extends(AlluvialChart, _super);
+    function AlluvialChart(holder, chartConfigs) {
+        var _this = _super.call(this, holder, chartConfigs) || this;
+        // Merge the default options for this chart
+        // With the user provided options
+        _this.model.setOptions(tools_Tools.mergeDefaultChartOptions(configuration_options.alluvialChart, chartConfigs.options));
+        // Initialize data, services, components etc.
+        _this.init(holder, chartConfigs);
+        return _this;
+    }
+    AlluvialChart.prototype.getComponents = function () {
+        // Specify what to render inside the graph-frame
+        var graphFrameComponents = [
+            new alluvial_Alluvial(this.model, this.services),
+        ];
+        var components = this.getChartComponents(graphFrameComponents, {
+            excludeLegend: true,
+        });
+        return components;
+    };
+    return AlluvialChart;
+}(chart_Chart));
+
+//# sourceMappingURL=../../src/charts/alluvial.js.map
 // CONCATENATED MODULE: ./node_modules/@carbon/charts/charts/index.js
 
 
@@ -40554,6 +41825,7 @@ var wordcloud_WordCloudChart = /** @class */ (function (_super) {
 
 
 
+
 
 
 //# sourceMappingURL=../../src/charts/index.js.map
@@ -41719,6 +42991,52 @@ var ccv_wordcloud_chart_component = normalizeComponent(
 )
 
 /* harmony default export */ var ccv_wordcloud_chart = (ccv_wordcloud_chart_component.exports);
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"624081f5-vue-loader-template"}!/home/runner/work/carbon-charts/carbon-charts/node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!/home/runner/work/carbon-charts/carbon-charts/node_modules/cache-loader/dist/cjs.js??ref--0-0!/home/runner/work/carbon-charts/carbon-charts/node_modules/vue-loader/lib??vue-loader-options!./src/ccv-alluvial-chart.vue?vue&type=template&id=7afdadc2&
+var ccv_alluvial_chartvue_type_template_id_7afdadc2_render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"ccv-alluvial-chart"})}
+var ccv_alluvial_chartvue_type_template_id_7afdadc2_staticRenderFns = []
+
+
+// CONCATENATED MODULE: ./src/ccv-alluvial-chart.vue?vue&type=template&id=7afdadc2&
+
+// CONCATENATED MODULE: /home/runner/work/carbon-charts/carbon-charts/node_modules/cache-loader/dist/cjs.js??ref--12-0!/home/runner/work/carbon-charts/carbon-charts/node_modules/thread-loader/dist/cjs.js!/home/runner/work/carbon-charts/carbon-charts/node_modules/@vue/cli-plugin-babel/node_modules/babel-loader/lib!/home/runner/work/carbon-charts/carbon-charts/node_modules/cache-loader/dist/cjs.js??ref--0-0!/home/runner/work/carbon-charts/carbon-charts/node_modules/vue-loader/lib??vue-loader-options!./src/ccv-alluvial-chart.vue?vue&type=script&lang=js&
+//
+//
+//
+//
+
+
+/* harmony default export */ var ccv_alluvial_chartvue_type_script_lang_js_ = ({
+  name: 'CcvAlluvialChart',
+  extends: ccv_base_chart,
+  mounted: function mounted() {
+    this.coreChart = new alluvial_AlluvialChart(this.$el, {
+      data: this.data,
+      options: this.options
+    });
+  }
+});
+// CONCATENATED MODULE: ./src/ccv-alluvial-chart.vue?vue&type=script&lang=js&
+ /* harmony default export */ var src_ccv_alluvial_chartvue_type_script_lang_js_ = (ccv_alluvial_chartvue_type_script_lang_js_); 
+// CONCATENATED MODULE: ./src/ccv-alluvial-chart.vue
+
+
+
+
+
+/* normalize component */
+
+var ccv_alluvial_chart_component = normalizeComponent(
+  src_ccv_alluvial_chartvue_type_script_lang_js_,
+  ccv_alluvial_chartvue_type_template_id_7afdadc2_render,
+  ccv_alluvial_chartvue_type_template_id_7afdadc2_staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var ccv_alluvial_chart = (ccv_alluvial_chart_component.exports);
 // CONCATENATED MODULE: ./src/index.js
 
 
@@ -41752,7 +43070,8 @@ var ccv_wordcloud_chart_component = normalizeComponent(
 
 
 
-var src_components = [ccv_area_chart, ccv_stacked_area_chart, ccv_simple_bar_chart, ccv_grouped_bar_chart, ccv_stacked_bar_chart, ccv_boxplot_chart, ccv_bubble_chart, ccv_bullet_chart, ccv_donut_chart, ccv_gauge_chart, ccv_histogram_chart, ccv_line_chart, ccv_lollipop_chart, ccv_pie_chart, ccv_scatter_chart, ccv_meter_chart, ccv_radar_chart, ccv_combo_chart, ccv_tree_chart, ccv_treemap_chart, ccv_circle_pack_chart, ccv_wordcloud_chart];
+
+var src_components = [ccv_area_chart, ccv_stacked_area_chart, ccv_simple_bar_chart, ccv_grouped_bar_chart, ccv_stacked_bar_chart, ccv_boxplot_chart, ccv_bubble_chart, ccv_bullet_chart, ccv_donut_chart, ccv_gauge_chart, ccv_histogram_chart, ccv_line_chart, ccv_lollipop_chart, ccv_pie_chart, ccv_scatter_chart, ccv_meter_chart, ccv_radar_chart, ccv_combo_chart, ccv_tree_chart, ccv_treemap_chart, ccv_circle_pack_chart, ccv_wordcloud_chart, ccv_alluvial_chart];
 /*
   Allows the module to be used as a Vue plug-in, and has an install()
   method (which is called when the plug-in loads) that registers all the
@@ -41851,6 +43170,7 @@ var src_components = [ccv_area_chart, ccv_stacked_area_chart, ccv_simple_bar_cha
 /* concated harmony reexport CcvTreemapChart */__webpack_require__.d(__webpack_exports__, "CcvTreemapChart", function() { return ccv_treemap_chart; });
 /* concated harmony reexport CcvCirclePackChart */__webpack_require__.d(__webpack_exports__, "CcvCirclePackChart", function() { return ccv_circle_pack_chart; });
 /* concated harmony reexport CcvWordCloudChart */__webpack_require__.d(__webpack_exports__, "CcvWordCloudChart", function() { return ccv_wordcloud_chart; });
+/* concated harmony reexport CcvAlluvialChart */__webpack_require__.d(__webpack_exports__, "CcvAlluvialChart", function() { return ccv_alluvial_chart; });
 
 
 /* harmony default export */ var entry_lib = __webpack_exports__["default"] = (src);