@dynatrace/strato-components 3.10.4 → 3.11.0

package/esm/charts/sankey-chart/vendor/d3-sankey/sankey.js

@@ -0,0 +1,432 @@
+import { max, min, sum } from "d3-array";
+import { justify } from "./align.js";
+import constant from "./constant.js";
+function ascendingSourceBreadth(a, b) {
+  return a.source.y0 - b.source.y0 || a.index - b.index;
+}
+function ascendingTargetBreadth(a, b) {
+  return a.target.y0 - b.target.y0 || a.index - b.index;
+}
+function nodeValue(d) {
+  return d.value;
+}
+function linkValue(d) {
+  return d.value;
+}
+function findNode(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 bx0 = 0, by0 = 0, bx1 = 1, by1 = 1;
+  let dx = 24;
+  let dy = 8, py = 8;
+  let idAccessor = (d) => d.index;
+  let alignFn = justify;
+  let sortFn;
+  let linkSortFn;
+  let nodesAccessor = (g) => g.nodes;
+  let linksAccessor = (g) => g.links;
+  let iterations = 6;
+  function computeNodeLinks(graph) {
+    for (const [i, node] of graph.nodes.entries()) {
+      node.index = i;
+      node.sourceLinks = [];
+      node.targetLinks = [];
+    }
+    const nodeById = new Map(
+      graph.nodes.map((d) => [idAccessor(d), d])
+    );
+    const unresolvedLinks = graph.links;
+    for (const [i, link] of unresolvedLinks.entries()) {
+      link.index = i;
+      if (typeof link.source !== "object") {
+        link.source = findNode(nodeById, link.source);
+      }
+      if (typeof link.target !== "object") {
+        link.target = findNode(nodeById, link.target);
+      }
+      link.source.sourceLinks.push(link);
+      link.target.targetLinks.push(link);
+    }
+    if (linkSortFn !== null && linkSortFn !== void 0) {
+      for (const { sourceLinks, targetLinks } of graph.nodes) {
+        sourceLinks.sort(linkSortFn);
+        targetLinks.sort(linkSortFn);
+      }
+    }
+  }
+  function computeNodeValues({ nodes }) {
+    for (const node of nodes) {
+      node.value = node.fixedValue === void 0 ? Math.max(
+        sum(node.sourceLinks, linkValue),
+        sum(node.targetLinks, linkValue)
+      ) : node.fixedValue;
+    }
+  }
+  function computeNodeDepths({ nodes }) {
+    const n = nodes.length;
+    let current = new Set(nodes);
+    let next = /* @__PURE__ */ new Set();
+    let x = 0;
+    let iterations2 = 0;
+    while (current.size) {
+      let maxPinnedDepth = -1;
+      for (const node of current) {
+        node.depth = typeof node["column"] === "number" ? node["column"] : x;
+        if (typeof node["column"] === "number" && node["column"] > maxPinnedDepth) {
+          maxPinnedDepth = node["column"];
+        }
+        for (const { target } of node.sourceLinks) {
+          next.add(target);
+        }
+      }
+      if (++iterations2 > n) {
+        throw new Error("circular link");
+      }
+      x = Math.max(x + 1, maxPinnedDepth + 1);
+      current = next;
+      next = /* @__PURE__ */ new Set();
+    }
+  }
+  function computeNodeHeights({ nodes }) {
+    const n = nodes.length;
+    let current = new Set(nodes);
+    let next = /* @__PURE__ */ 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 = /* @__PURE__ */ new Set();
+    }
+  }
+  function computeNodeLayers({ nodes }) {
+    const x = (max(nodes, (d) => d.depth) ?? 0) + 1;
+    const kx = (bx1 - bx0 - dx) / (x - 1);
+    const columns = new Array(x);
+    for (const node of nodes) {
+      const i = Math.max(0, Math.min(x - 1, Math.floor(alignFn(node, x))));
+      node.layer = i;
+      node.x0 = bx0 + i * kx;
+      node.x1 = node.x0 + dx;
+      if (columns[i]) {
+        columns[i].push(node);
+      } else {
+        columns[i] = [node];
+      }
+    }
+    const compact = columns.filter((c) => c !== void 0);
+    if (sortFn) {
+      for (const column of compact) {
+        column.sort(sortFn);
+      }
+    }
+    return compact;
+  }
+  function initializeNodeBreadths(columns) {
+    const ky = min(
+      columns,
+      (c) => (by1 - by0 - (c.length - 1) * py) / sum(c, nodeValue)
+    ) ?? 0;
+    for (const nodes of columns) {
+      let y = by0;
+      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 = (by1 - 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, (by1 - by0) / ((max(columns, (c) => c.length) ?? 1) - 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);
+    }
+  }
+  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) {
+          const v = value * (target.layer - source.layer);
+          y += targetTop(source, target) * v;
+          w += v;
+        }
+        if (!(w > 0)) {
+          continue;
+        }
+        const dy2 = (y / w - target.y0) * alpha;
+        target.y0 += dy2;
+        target.y1 += dy2;
+        reorderNodeLinks(target);
+      }
+      if (sortFn === void 0) {
+        column.sort(ascendingBreadth);
+      }
+      resolveCollisions(column, beta);
+    }
+  }
+  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) {
+          const v = value * (target.layer - source.layer);
+          y += sourceTop(source, target) * v;
+          w += v;
+        }
+        if (!(w > 0)) {
+          continue;
+        }
+        const dy2 = (y / w - source.y0) * alpha;
+        source.y0 += dy2;
+        source.y1 += dy2;
+        reorderNodeLinks(source);
+      }
+      if (sortFn === void 0) {
+        column.sort(ascendingBreadth);
+      }
+      resolveCollisions(column, beta);
+    }
+  }
+  function ascendingBreadth(a, b) {
+    return a.y0 - b.y0;
+  }
+  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, by1, nodes.length - 1, alpha);
+    resolveCollisionsTopToBottom(nodes, by0, 0, alpha);
+  }
+  function resolveCollisionsTopToBottom(nodes, y, i, alpha) {
+    for (; i < nodes.length; ++i) {
+      const node = nodes[i];
+      const dy2 = (y - node.y0) * alpha;
+      if (dy2 > 1e-6) {
+        node.y0 += dy2;
+        node.y1 += dy2;
+      }
+      y = node.y1 + py;
+    }
+  }
+  function resolveCollisionsBottomToTop(nodes, y, i, alpha) {
+    for (; i >= 0; --i) {
+      const node = nodes[i];
+      const dy2 = (node.y1 - y) * alpha;
+      if (dy2 > 1e-6) {
+        node.y0 -= dy2;
+        node.y1 -= dy2;
+      }
+      y = node.y0 - py;
+    }
+  }
+  function reorderNodeLinks({ sourceLinks, targetLinks }) {
+    if (linkSortFn === void 0) {
+      for (const {
+        source: { sourceLinks: sl }
+      } of targetLinks) {
+        sl.sort(ascendingTargetBreadth);
+      }
+      for (const {
+        target: { targetLinks: tl }
+      } of sourceLinks) {
+        tl.sort(ascendingSourceBreadth);
+      }
+    }
+  }
+  function reorderLinks(nodes) {
+    if (linkSortFn === void 0) {
+      for (const { sourceLinks, targetLinks } of nodes) {
+        sourceLinks.sort(ascendingTargetBreadth);
+        targetLinks.sort(ascendingSourceBreadth);
+      }
+    }
+  }
+  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;
+  }
+  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;
+  }
+  function runLayout(data) {
+    const graph = {
+      nodes: nodesAccessor(data),
+      links: linksAccessor(data)
+    };
+    computeNodeLinks(graph);
+    computeNodeValues(graph);
+    computeNodeDepths(graph);
+    computeNodeHeights(graph);
+    computeNodeBreadths(graph);
+    computeLinkBreadths(graph);
+    return graph;
+  }
+  const layout = Object.assign(runLayout, {
+    update(graph) {
+      computeLinkBreadths(graph);
+      return graph;
+    },
+    nodeId(fn) {
+      if (fn === void 0) {
+        return idAccessor;
+      }
+      idAccessor = fn;
+      return layout;
+    },
+    nodeAlign(fn) {
+      if (fn === void 0) {
+        return alignFn;
+      }
+      alignFn = typeof fn === "function" ? fn : constant(fn)();
+      return layout;
+    },
+    nodeSort(fn) {
+      if (arguments.length === 0) {
+        return sortFn;
+      }
+      sortFn = fn;
+      return layout;
+    },
+    nodeWidth(w) {
+      if (w === void 0) {
+        return dx;
+      }
+      dx = +w;
+      return layout;
+    },
+    nodePadding(p) {
+      if (p === void 0) {
+        return dy;
+      }
+      dy = py = +p;
+      return layout;
+    },
+    nodes(accessor) {
+      if (accessor === void 0) {
+        return nodesAccessor;
+      }
+      nodesAccessor = typeof accessor === "function" ? accessor : constant(accessor);
+      return layout;
+    },
+    links(accessor) {
+      if (accessor === void 0) {
+        return linksAccessor;
+      }
+      linksAccessor = typeof accessor === "function" ? accessor : constant(accessor);
+      return layout;
+    },
+    linkSort(fn) {
+      if (arguments.length === 0) {
+        return linkSortFn;
+      }
+      linkSortFn = fn;
+      return layout;
+    },
+    size(s) {
+      if (s === void 0) {
+        return [bx1 - bx0, by1 - by0];
+      }
+      bx0 = by0 = 0;
+      bx1 = +s[0];
+      by1 = +s[1];
+      return layout;
+    },
+    extent(e) {
+      if (e === void 0) {
+        return [
+          [bx0, by0],
+          [bx1, by1]
+        ];
+      }
+      bx0 = +e[0][0];
+      bx1 = +e[1][0];
+      by0 = +e[0][1];
+      by1 = +e[1][1];
+      return layout;
+    },
+    iterations(n) {
+      if (n === void 0) {
+        return iterations;
+      }
+      iterations = +n;
+      return layout;
+    }
+  });
+  return layout;
+}
+export {
+  Sankey as default
+};
+//# sourceMappingURL=sankey.js.map

package/esm/charts/sankey-chart/vendor/d3-sankey/sankey.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/charts/sankey-chart/vendor/d3-sankey/sankey.ts"],
+  "sourcesContent": ["// Copyright 2015, Mike Bostock\n// BSD 3-Clause License \u2014 https://github.com/d3/d3-sankey/blob/main/LICENSE\n// Vendored from d3-sankey@0.12.3 \u2014 https://github.com/d3/d3-sankey\n\nimport { max, min, sum } from 'd3-array';\n\nimport { justify } from './align.js';\nimport constant from './constant.js';\nimport type {\n  SankeyExtraProperties,\n  SankeyGraph,\n  SankeyLayout,\n} from './types.js';\n\n// Internal working types \u2014 the algorithm mutates input objects in place to add geometry fields.\n\ninterface WorkingNode {\n  index: number;\n  depth: number;\n  height: number;\n  layer: number;\n  x0: number;\n  x1: number;\n  y0: number;\n  y1: number;\n  value: number;\n  fixedValue?: number;\n  sourceLinks: WorkingLink[];\n  targetLinks: WorkingLink[];\n  [key: string]: unknown;\n}\n\n// Before computeNodeLinks resolves source/target ids, they may still be strings or numbers.\ninterface UnresolvedLink {\n  index: number;\n  source: WorkingNode | string | number;\n  target: WorkingNode | string | number;\n  value: number;\n  y0: number;\n  y1: number;\n  width: number;\n  [key: string]: unknown;\n}\n\ninterface WorkingLink extends UnresolvedLink {\n  source: WorkingNode;\n  target: WorkingNode;\n}\n\ninterface WorkingGraph {\n  nodes: WorkingNode[];\n  links: WorkingLink[];\n}\n\nfunction ascendingSourceBreadth(a: WorkingLink, b: WorkingLink): number {\n  return a.source.y0 - b.source.y0 || a.index - b.index;\n}\n\nfunction ascendingTargetBreadth(a: WorkingLink, b: WorkingLink): number {\n  return a.target.y0 - b.target.y0 || a.index - b.index;\n}\n\nfunction nodeValue(d: WorkingNode): number {\n  return d.value;\n}\n\nfunction linkValue(d: WorkingLink): number {\n  return d.value;\n}\n\nfunction findNode(\n  nodeById: Map<string | number, WorkingNode>,\n  id: string | number,\n): WorkingNode {\n  const node = nodeById.get(id);\n  if (!node) {\n    throw new Error('missing: ' + id);\n  }\n  return node;\n}\n\nfunction computeLinkBreadths({ nodes }: WorkingGraph): void {\n  for (const node of nodes) {\n    let y0 = node.y0;\n    let y1 = y0;\n    for (const link of node.sourceLinks) {\n      link.y0 = y0 + link.width / 2;\n      y0 += link.width;\n    }\n    for (const link of node.targetLinks) {\n      link.y1 = y1 + link.width / 2;\n      y1 += link.width;\n    }\n  }\n}\n\nexport default function Sankey<\n  N extends SankeyExtraProperties,\n  L extends SankeyExtraProperties,\n>(): SankeyLayout<SankeyGraph<N, L>, N, L> {\n  let bx0 = 0,\n    by0 = 0,\n    bx1 = 1,\n    by1 = 1;\n  let dx = 24;\n  let dy = 8,\n    py = 8;\n  let idAccessor: (d: WorkingNode) => string | number = (d) => d.index;\n  let alignFn: (node: WorkingNode, n: number) => number = justify;\n  let sortFn: ((a: WorkingNode, b: WorkingNode) => number) | undefined | null;\n  let linkSortFn:\n    | ((a: WorkingLink, b: WorkingLink) => number)\n    | undefined\n    | null;\n  let nodesAccessor: (data: SankeyGraph<N, L>) => WorkingNode[] = (g) =>\n    g.nodes as unknown as WorkingNode[];\n  let linksAccessor: (data: SankeyGraph<N, L>) => WorkingLink[] = (g) =>\n    g.links as unknown as WorkingLink[];\n  let iterations = 6;\n\n  function computeNodeLinks(graph: WorkingGraph): void {\n    for (const [i, node] of graph.nodes.entries()) {\n      node.index = i;\n      node.sourceLinks = [];\n      node.targetLinks = [];\n    }\n    const nodeById = new Map<string | number, WorkingNode>(\n      graph.nodes.map((d) => [idAccessor(d), d]),\n    );\n    const unresolvedLinks = graph.links as unknown as UnresolvedLink[];\n    for (const [i, link] of unresolvedLinks.entries()) {\n      link.index = i;\n      if (typeof link.source !== 'object') {\n        link.source = findNode(nodeById, link.source);\n      }\n      if (typeof link.target !== 'object') {\n        link.target = findNode(nodeById, link.target);\n      }\n      (link.source as WorkingNode).sourceLinks.push(link as WorkingLink);\n      (link.target as WorkingNode).targetLinks.push(link as WorkingLink);\n    }\n    if (linkSortFn !== null && linkSortFn !== undefined) {\n      for (const { sourceLinks, targetLinks } of graph.nodes) {\n        sourceLinks.sort(linkSortFn);\n        targetLinks.sort(linkSortFn);\n      }\n    }\n  }\n\n  function computeNodeValues({ nodes }: WorkingGraph): void {\n    for (const node of nodes) {\n      node.value =\n        node.fixedValue === undefined\n          ? Math.max(\n              sum(node.sourceLinks, linkValue),\n              sum(node.targetLinks, linkValue),\n            )\n          : node.fixedValue;\n    }\n  }\n\n  function computeNodeDepths({ nodes }: WorkingGraph): void {\n    const n = nodes.length;\n    let current = new Set(nodes);\n    let next = new Set<WorkingNode>();\n    let x = 0;\n    let iterations = 0;\n    while (current.size) {\n      let maxPinnedDepth = -1;\n      for (const node of current) {\n        node.depth = typeof node['column'] === 'number' ? node['column'] : x;\n        if (\n          typeof node['column'] === 'number' &&\n          node['column'] > maxPinnedDepth\n        ) {\n          maxPinnedDepth = node['column'];\n        }\n        for (const { target } of node.sourceLinks) {\n          next.add(target);\n        }\n      }\n      if (++iterations > n) {\n        throw new Error('circular link');\n      }\n      x = Math.max(x + 1, maxPinnedDepth + 1);\n      current = next;\n      next = new Set();\n    }\n  }\n\n  function computeNodeHeights({ nodes }: WorkingGraph): void {\n    const n = nodes.length;\n    let current = new Set(nodes);\n    let next = new Set<WorkingNode>();\n    let x = 0;\n    while (current.size) {\n      for (const node of current) {\n        node.height = x;\n        for (const { source } of node.targetLinks) {\n          next.add(source);\n        }\n      }\n      if (++x > n) {\n        throw new Error('circular link');\n      }\n      current = next;\n      next = new Set();\n    }\n  }\n\n  function computeNodeLayers({ nodes }: WorkingGraph): WorkingNode[][] {\n    const x = (max(nodes, (d) => d.depth) ?? 0) + 1;\n    const kx = (bx1 - bx0 - dx) / (x - 1);\n    const columns = new Array<WorkingNode[]>(x);\n    for (const node of nodes) {\n      const i = Math.max(0, Math.min(x - 1, Math.floor(alignFn(node, x))));\n      node.layer = i;\n      node.x0 = bx0 + i * kx;\n      node.x1 = node.x0 + dx;\n      if (columns[i]) {\n        columns[i].push(node);\n      } else {\n        columns[i] = [node];\n      }\n    }\n    // alignFn may remap nodes so that some indices in the sparse array remain empty.\n    // Filter before downstream passes to prevent crashes on undefined column entries.\n    const compact = columns.filter((c): c is WorkingNode[] => c !== undefined);\n    if (sortFn) {\n      for (const column of compact) {\n        column.sort(sortFn);\n      }\n    }\n    return compact;\n  }\n\n  function initializeNodeBreadths(columns: WorkingNode[][]): void {\n    const ky =\n      min(\n        columns,\n        (c) => (by1 - by0 - (c.length - 1) * py) / sum(c, nodeValue),\n      ) ?? 0;\n    for (const nodes of columns) {\n      let y = by0;\n      for (const node of nodes) {\n        node.y0 = y;\n        node.y1 = y + node.value * ky;\n        y = node.y1 + py;\n        for (const link of node.sourceLinks) {\n          link.width = link.value * ky;\n        }\n      }\n      y = (by1 - y + py) / (nodes.length + 1);\n      for (let i = 0; i < nodes.length; ++i) {\n        const node = nodes[i];\n        node.y0 += y * (i + 1);\n        node.y1 += y * (i + 1);\n      }\n      reorderLinks(nodes);\n    }\n  }\n\n  function computeNodeBreadths(graph: WorkingGraph): void {\n    const columns = computeNodeLayers(graph);\n    py = Math.min(dy, (by1 - by0) / ((max(columns, (c) => c.length) ?? 1) - 1));\n    initializeNodeBreadths(columns);\n    for (let i = 0; i < iterations; ++i) {\n      const alpha = Math.pow(0.99, i);\n      const beta = Math.max(1 - alpha, (i + 1) / iterations);\n      relaxRightToLeft(columns, alpha, beta);\n      relaxLeftToRight(columns, alpha, beta);\n    }\n  }\n\n  function relaxLeftToRight(\n    columns: WorkingNode[][],\n    alpha: number,\n    beta: number,\n  ): void {\n    for (let i = 1, n = columns.length; i < n; ++i) {\n      const column = columns[i];\n      for (const target of column) {\n        let y = 0;\n        let w = 0;\n        for (const { source, value } of target.targetLinks) {\n          const v = value * (target.layer - source.layer);\n          y += targetTop(source, target) * v;\n          w += v;\n        }\n        if (!(w > 0)) {\n          continue;\n        }\n        const dy = (y / w - target.y0) * alpha;\n        target.y0 += dy;\n        target.y1 += dy;\n        reorderNodeLinks(target);\n      }\n      if (sortFn === undefined) {\n        column.sort(ascendingBreadth);\n      }\n      resolveCollisions(column, beta);\n    }\n  }\n\n  function relaxRightToLeft(\n    columns: WorkingNode[][],\n    alpha: number,\n    beta: number,\n  ): void {\n    for (let n = columns.length, i = n - 2; i >= 0; --i) {\n      const column = columns[i];\n      for (const source of column) {\n        let y = 0;\n        let w = 0;\n        for (const { target, value } of source.sourceLinks) {\n          const v = value * (target.layer - source.layer);\n          y += sourceTop(source, target) * v;\n          w += v;\n        }\n        if (!(w > 0)) {\n          continue;\n        }\n        const dy = (y / w - source.y0) * alpha;\n        source.y0 += dy;\n        source.y1 += dy;\n        reorderNodeLinks(source);\n      }\n      if (sortFn === undefined) {\n        column.sort(ascendingBreadth);\n      }\n      resolveCollisions(column, beta);\n    }\n  }\n\n  function ascendingBreadth(a: WorkingNode, b: WorkingNode): number {\n    return a.y0 - b.y0;\n  }\n\n  function resolveCollisions(nodes: WorkingNode[], alpha: number): void {\n    const i = nodes.length >> 1;\n    const subject = nodes[i];\n    resolveCollisionsBottomToTop(nodes, subject.y0 - py, i - 1, alpha);\n    resolveCollisionsTopToBottom(nodes, subject.y1 + py, i + 1, alpha);\n    resolveCollisionsBottomToTop(nodes, by1, nodes.length - 1, alpha);\n    resolveCollisionsTopToBottom(nodes, by0, 0, alpha);\n  }\n\n  function resolveCollisionsTopToBottom(\n    nodes: WorkingNode[],\n    y: number,\n    i: number,\n    alpha: number,\n  ): void {\n    for (; i < nodes.length; ++i) {\n      const node = nodes[i];\n      const dy = (y - node.y0) * alpha;\n      if (dy > 1e-6) {\n        node.y0 += dy;\n        node.y1 += dy;\n      }\n      y = node.y1 + py;\n    }\n  }\n\n  function resolveCollisionsBottomToTop(\n    nodes: WorkingNode[],\n    y: number,\n    i: number,\n    alpha: number,\n  ): void {\n    for (; i >= 0; --i) {\n      const node = nodes[i];\n      const dy = (node.y1 - y) * alpha;\n      if (dy > 1e-6) {\n        node.y0 -= dy;\n        node.y1 -= dy;\n      }\n      y = node.y0 - py;\n    }\n  }\n\n  function reorderNodeLinks({ sourceLinks, targetLinks }: WorkingNode): void {\n    if (linkSortFn === undefined) {\n      for (const {\n        source: { sourceLinks: sl },\n      } of targetLinks) {\n        sl.sort(ascendingTargetBreadth);\n      }\n      for (const {\n        target: { targetLinks: tl },\n      } of sourceLinks) {\n        tl.sort(ascendingSourceBreadth);\n      }\n    }\n  }\n\n  function reorderLinks(nodes: WorkingNode[]): void {\n    if (linkSortFn === undefined) {\n      for (const { sourceLinks, targetLinks } of nodes) {\n        sourceLinks.sort(ascendingTargetBreadth);\n        targetLinks.sort(ascendingSourceBreadth);\n      }\n    }\n  }\n\n  function targetTop(source: WorkingNode, target: WorkingNode): number {\n    let y = source.y0 - ((source.sourceLinks.length - 1) * py) / 2;\n    for (const { target: node, width } of source.sourceLinks) {\n      if (node === target) {\n        break;\n      }\n      y += width + py;\n    }\n    for (const { source: node, width } of target.targetLinks) {\n      if (node === source) {\n        break;\n      }\n      y -= width;\n    }\n    return y;\n  }\n\n  function sourceTop(source: WorkingNode, target: WorkingNode): number {\n    let y = target.y0 - ((target.targetLinks.length - 1) * py) / 2;\n    for (const { source: node, width } of target.targetLinks) {\n      if (node === source) {\n        break;\n      }\n      y += width + py;\n    }\n    for (const { target: node, width } of source.sourceLinks) {\n      if (node === target) {\n        break;\n      }\n      y -= width;\n    }\n    return y;\n  }\n\n  function runLayout(data: SankeyGraph<N, L>): SankeyGraph<N, L> {\n    const graph: WorkingGraph = {\n      nodes: nodesAccessor(data),\n      links: linksAccessor(data),\n    };\n    computeNodeLinks(graph);\n    computeNodeValues(graph);\n    computeNodeDepths(graph);\n    computeNodeHeights(graph);\n    computeNodeBreadths(graph);\n    computeLinkBreadths(graph);\n    return graph as unknown as SankeyGraph<N, L>;\n  }\n\n  // Build the fluent SankeyLayout object using Object.assign on the callable.\n  // The type assertion at the return bridges the simplified optional-parameter\n  // method signatures to the overloaded SankeyLayout interface.\n  const layout = Object.assign(runLayout, {\n    update(graph: SankeyGraph<N, L>): SankeyGraph<N, L> {\n      computeLinkBreadths(graph as unknown as WorkingGraph);\n      return graph;\n    },\n\n    nodeId(fn?: (node: WorkingNode) => string | number) {\n      if (fn === undefined) {\n        return idAccessor;\n      }\n      idAccessor = fn;\n      return layout;\n    },\n\n    nodeAlign(fn?: (node: WorkingNode, n: number) => number) {\n      if (fn === undefined) {\n        return alignFn;\n      }\n      alignFn = typeof fn === 'function' ? fn : constant(fn)();\n      return layout;\n    },\n\n    nodeSort(fn?: ((a: WorkingNode, b: WorkingNode) => number) | null) {\n      if (arguments.length === 0) {\n        return sortFn;\n      }\n      sortFn = fn;\n      return layout;\n    },\n\n    nodeWidth(w?: number) {\n      if (w === undefined) {\n        return dx;\n      }\n      dx = +w;\n      return layout;\n    },\n\n    nodePadding(p?: number) {\n      if (p === undefined) {\n        return dy;\n      }\n      dy = py = +p;\n      return layout;\n    },\n\n    nodes(\n      accessor?:\n        | Array<SankeyGraph<N, L>['nodes'][number]>\n        | ((data: SankeyGraph<N, L>) => WorkingNode[]),\n    ) {\n      if (accessor === undefined) {\n        return nodesAccessor;\n      }\n      nodesAccessor =\n        typeof accessor === 'function'\n          ? accessor\n          : constant(accessor as unknown as WorkingNode[]);\n      return layout;\n    },\n\n    links(\n      accessor?:\n        | Array<SankeyGraph<N, L>['links'][number]>\n        | ((data: SankeyGraph<N, L>) => WorkingLink[]),\n    ) {\n      if (accessor === undefined) {\n        return linksAccessor;\n      }\n      linksAccessor =\n        typeof accessor === 'function'\n          ? accessor\n          : constant(accessor as unknown as WorkingLink[]);\n      return layout;\n    },\n\n    linkSort(fn?: ((a: WorkingLink, b: WorkingLink) => number) | null) {\n      if (arguments.length === 0) {\n        return linkSortFn;\n      }\n      linkSortFn = fn;\n      return layout;\n    },\n\n    size(s?: [number, number]) {\n      if (s === undefined) {\n        return [bx1 - bx0, by1 - by0] as [number, number];\n      }\n      bx0 = by0 = 0;\n      bx1 = +s[0];\n      by1 = +s[1];\n      return layout;\n    },\n\n    extent(e?: [[number, number], [number, number]]) {\n      if (e === undefined) {\n        return [\n          [bx0, by0],\n          [bx1, by1],\n        ] as [[number, number], [number, number]];\n      }\n      bx0 = +e[0][0];\n      bx1 = +e[1][0];\n      by0 = +e[0][1];\n      by1 = +e[1][1];\n      return layout;\n    },\n\n    iterations(n?: number) {\n      if (n === undefined) {\n        return iterations;\n      }\n      iterations = +n;\n      return layout;\n    },\n  });\n\n  return layout as unknown as SankeyLayout<SankeyGraph<N, L>, N, L>;\n}\n"],
+  "mappings": "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",
+  "names": ["iterations", "dy"]
+}

package/esm/charts/sankey-chart/vendor/d3-sankey/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/esm/charts/sankey-chart/vendor/d3-sankey/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/esm/charts/single-value/SingleValue.css

@@ -1,4 +1,4 @@
-._1sfgzlg0-3-10-4 {
+._1sfgzlg0-3-11-0 {
   height: inherit;
   width: inherit;
 }

package/esm/charts/single-value/SingleValue.sty.js

@@ -1,5 +1,5 @@
 import "./SingleValue.css";
-var container = "_1sfgzlg0-3-10-4";
+var container = "_1sfgzlg0-3-11-0";
 export {
   container
 };

package/esm/charts/single-value/SingleValue.sty.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/charts/single-value/SingleValue.css.ts"],
-  "sourcesContent": ["import './SingleValue.css';\nexport var container = '_1sfgzlg0-3-10-4';"],
+  "sourcesContent": ["import './SingleValue.css';\nexport var container = '_1sfgzlg0-3-11-0';"],
   "mappings": "AAAA,OAAO;AACA,IAAI,YAAY;",
   "names": []
 }

package/esm/charts/single-value-grid/SingleValueGrid.css

@@ -1,7 +1,7 @@
-._1mx9zjb0-3-10-4 {
+._1mx9zjb0-3-11-0 {
   height: 100%;
   width: 100%;
 }
-._1mx9zjb0-3-10-4 > div {
+._1mx9zjb0-3-11-0 > div {
   overflow: hidden;
 }

package/esm/charts/single-value-grid/SingleValueGrid.sty.js

@@ -1,5 +1,5 @@
 import "./SingleValueGrid.css";
-var gridRows = "_1mx9zjb0-3-10-4";
+var gridRows = "_1mx9zjb0-3-11-0";
 export {
   gridRows
 };

package/esm/charts/single-value-grid/SingleValueGrid.sty.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/charts/single-value-grid/SingleValueGrid.css.ts"],
-  "sourcesContent": ["import './SingleValueGrid.css';\nexport var gridRows = '_1mx9zjb0-3-10-4';"],
+  "sourcesContent": ["import './SingleValueGrid.css';\nexport var gridRows = '_1mx9zjb0-3-11-0';"],
   "mappings": "AAAA,OAAO;AACA,IAAI,WAAW;",
   "names": []
 }

package/esm/charts/single-value-grid/components/GlobalFontSizeVariables.css

@@ -1,4 +1,4 @@
-._eom86z0-3-10-4 {
+._eom86z0-3-11-0 {
   position: relative;
   width: 100%;
   height: 100%;

package/esm/charts/single-value-grid/components/GlobalFontSizeVariables.sty.js

@@ -1,5 +1,5 @@
 import "./GlobalFontSizeVariables.css";
-var fontSizeWrapper = "_eom86z0-3-10-4";
+var fontSizeWrapper = "_eom86z0-3-11-0";
 export {
   fontSizeWrapper
 };

package/esm/charts/single-value-grid/components/GlobalFontSizeVariables.sty.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/charts/single-value-grid/components/GlobalFontSizeVariables.css.ts"],
-  "sourcesContent": ["import './GlobalFontSizeVariables.css';\nexport var fontSizeWrapper = '_eom86z0-3-10-4';"],
+  "sourcesContent": ["import './GlobalFontSizeVariables.css';\nexport var fontSizeWrapper = '_eom86z0-3-11-0';"],
   "mappings": "AAAA,OAAO;AACA,IAAI,kBAAkB;",
   "names": []
 }

package/esm/charts/timeseries/components/axes/TimeseriesTimeBottomAxisArea/TimeseriesTimeBottomAxisArea.css

@@ -1,6 +1,6 @@
-._19z0vdp0-3-10-4 {
+._19z0vdp0-3-11-0 {
   position: relative;
 }
-._19z0vdp1-3-10-4 {
+._19z0vdp1-3-11-0 {
   touch-action: none;
 }

package/esm/charts/timeseries/components/axes/TimeseriesTimeBottomAxisArea/TimeseriesTimeBottomAxisArea.sty.js

@@ -1,6 +1,6 @@
 import "./TimeseriesTimeBottomAxisArea.css";
 import { createRuntimeFn as _7a468 } from "@vanilla-extract/recipes/createRuntimeFn";
-var timeBottomAxisContainer = _7a468({ defaultClassName: "_19z0vdp0-3-10-4", variantClassNames: { isTouchableDevice: { true: "_19z0vdp1-3-10-4" } }, defaultVariants: {}, compoundVariants: [] });
+var timeBottomAxisContainer = _7a468({ defaultClassName: "_19z0vdp0-3-11-0", variantClassNames: { isTouchableDevice: { true: "_19z0vdp1-3-11-0" } }, defaultVariants: {}, compoundVariants: [] });
 export {
   timeBottomAxisContainer
 };

package/esm/charts/timeseries/components/axes/TimeseriesTimeBottomAxisArea/TimeseriesTimeBottomAxisArea.sty.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../../src/charts/timeseries/components/axes/TimeseriesTimeBottomAxisArea/TimeseriesTimeBottomAxisArea.css.ts"],
-  "sourcesContent": ["import './TimeseriesTimeBottomAxisArea.css';\nimport { createRuntimeFn as _7a468 } from '@vanilla-extract/recipes/createRuntimeFn';\nexport var timeBottomAxisContainer = _7a468({defaultClassName:'_19z0vdp0-3-10-4',variantClassNames:{isTouchableDevice:{true:'_19z0vdp1-3-10-4'}},defaultVariants:{},compoundVariants:[]});"],
+  "sourcesContent": ["import './TimeseriesTimeBottomAxisArea.css';\nimport { createRuntimeFn as _7a468 } from '@vanilla-extract/recipes/createRuntimeFn';\nexport var timeBottomAxisContainer = _7a468({defaultClassName:'_19z0vdp0-3-11-0',variantClassNames:{isTouchableDevice:{true:'_19z0vdp1-3-11-0'}},defaultVariants:{},compoundVariants:[]});"],
   "mappings": "AAAA,OAAO;AACP,SAAS,mBAAmB,cAAc;AACnC,IAAI,0BAA0B,OAAO,EAAC,kBAAiB,oBAAmB,mBAAkB,EAAC,mBAAkB,EAAC,MAAK,mBAAkB,EAAC,GAAE,iBAAgB,CAAC,GAAE,kBAAiB,CAAC,EAAC,CAAC;",
   "names": []
 }

package/esm/charts/timeseries/components/overlays/TimeseriesChartOverlays.js

@@ -35,10 +35,7 @@ import { useSynchronizedCrosshair } from "../../../core/components/shared-chart-
 import { useSynchronizedSelection } from "../../../core/components/shared-chart-interactions/hooks/useSynchronizedSelection.js";
 import { useToolbarHandlerRef } from "../../../core/components/toolbar/hooks/useToolbarHandlerRef.js";
 import { getPercentageFromPixel } from "../../../core/utils/get-percentage-from-pixel.js";
-import {
-  TIMESERIES_INTERACTIONS_ARIA_LABEL,
-  zIndicesTimeseriesAreas
-} from "../../constants.js";
+import { zIndicesTimeseriesAreas } from "../../constants.js";
 import { TimeseriesChartOverlayRefContext } from "../../context/TimeseriesChartOverlayRefContext.js";
 import { TimeseriesChartSelectionAreaRef } from "../../context/TimeseriesChartSelectionAreaRef.context.js";
 import {
@@ -240,7 +237,6 @@ const TimeseriesChartOverlays = () => {
   return /* @__PURE__ */ jsx(
     InteractionsOverlay,
     {
-      "aria-label": TIMESERIES_INTERACTIONS_ARIA_LABEL,
       style: {
         zIndex: zIndicesTimeseriesAreas.overlays,
         userSelect: selectState?.finished === false ? "none" : "auto"