@mui/x-charts-vendor 8.19.0 → 8.22.0

package/d3-path.d.ts

@@ -0,0 +1,5 @@
+
+// `x-charts-vendor/d3-path` (TypeScript)
+//
+// Export the type definitions for this package:
+export * from "d3-path";

package/d3-path.js

@@ -0,0 +1,7 @@
+
+// `x-charts-vendor/d3-path` (CommonJS)
+// See upstream license: https://github.com/d3/d3-path/blob/main/LICENSE
+//
+// This file only exists for tooling that doesn't work yet with package.json:exports
+// by proxying through the CommonJS version.
+module.exports = require("./lib/d3-path");

package/d3-sankey.d.ts

@@ -1,5 +0,0 @@
-
-// `x-charts-vendor/d3-sankey` (TypeScript)
-//
-// Export the type definitions for this package:
-export * from "d3-sankey";

package/es/flatqueue.mjs

@@ -0,0 +1,8 @@
+
+// `x-charts-vendor/flatqueue` (ESM)
+// See upstream license: git+https://github.com/mourner/flatqueue/blob/main/LICENSE
+//
+// Our ESM package uses the underlying installed dependencies of `node_modules/flatqueue`
+export * from "flatqueue";
+
+export { default } from "flatqueue";

package/lib/flatqueue.js

@@ -0,0 +1,6 @@
+
+// `x-charts-vendor/flatqueue` (CommonJS)
+// See upstream license: git+https://github.com/mourner/flatqueue/blob/main/LICENSE
+//
+// Our CommonJS package relies on transpiled vendor files in `lib-vendor/flatqueue`
+module.exports = require("../lib-vendor/flatqueue/index.js");

package/lib-vendor/flatqueue/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025, Volodymyr Agafonkin
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/lib-vendor/flatqueue/index.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/** @template T */
+class FlatQueue {
+  constructor() {
+    /** @type T[] */
+    this.ids = [];
+
+    /** @type number[] */
+    this.values = [];
+
+    /** Number of items in the queue. */
+    this.length = 0;
+  }
+
+  /** Removes all items from the queue. */
+  clear() {
+    this.length = 0;
+  }
+
+  /**
+   * Adds `item` to the queue with the specified `priority`.
+   *
+   * `priority` must be a number. Items are sorted and returned from low to high priority. Multiple items
+   * with the same priority value can be added to the queue, but there is no guaranteed order between these items.
+   *
+   * @param {T} item
+   * @param {number} priority
+   */
+  push(item, priority) {
+    let pos = this.length++;
+    while (pos > 0) {
+      const parent = pos - 1 >> 1;
+      const parentValue = this.values[parent];
+      if (priority >= parentValue) break;
+      this.ids[pos] = this.ids[parent];
+      this.values[pos] = parentValue;
+      pos = parent;
+    }
+    this.ids[pos] = item;
+    this.values[pos] = priority;
+  }
+
+  /**
+   * Removes and returns the item from the head of this queue, which is one of
+   * the items with the lowest priority. If this queue is empty, returns `undefined`.
+   */
+  pop() {
+    if (this.length === 0) return undefined;
+    const ids = this.ids,
+      values = this.values,
+      top = ids[0],
+      last = --this.length;
+    if (last > 0) {
+      const id = ids[last];
+      const value = values[last];
+      let pos = 0;
+      const halfLen = last >> 1;
+      while (pos < halfLen) {
+        const left = (pos << 1) + 1;
+        const right = left + 1;
+        const child = left + (+(right < last) & +(values[right] < values[left]));
+        if (values[child] >= value) break;
+        ids[pos] = ids[child];
+        values[pos] = values[child];
+        pos = child;
+      }
+      ids[pos] = id;
+      values[pos] = value;
+    }
+    return top;
+  }
+
+  /** Returns the item from the head of this queue without removing it. If this queue is empty, returns `undefined`. */
+  peek() {
+    return this.length > 0 ? this.ids[0] : undefined;
+  }
+
+  /**
+   * Returns the priority value of the item at the head of this queue without
+   * removing it. If this queue is empty, returns `undefined`.
+   */
+  peekValue() {
+    return this.length > 0 ? this.values[0] : undefined;
+  }
+
+  /**
+   * Shrinks the internal arrays to `this.length`.
+   *
+   * `pop()` and `clear()` calls don't free memory automatically to avoid unnecessary resize operations.
+   * This also means that items that have been added to the queue can't be garbage collected until
+   * a new item is pushed in their place, or this method is called.
+   */
+  shrink() {
+    this.ids.length = this.values.length = this.length;
+  }
+}
+exports.default = FlatQueue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-charts-vendor",
-  "version": "8.19.0",
+  "version": "8.22.0",
   "author": "MUI Team",
   "description": "Vendored dependencies for MUI X Charts.",
   "keywords": [
@@ -27,34 +27,34 @@
     "@babel/runtime": "^7.28.4",
     "@types/d3-color": "^3.1.3",
     "@types/d3-interpolate": "^3.0.4",
-    "@types/d3-sankey": "^0.12.4",
+    "@types/d3-path": "^3.1.1",
+    "@types/d3-sankey": "^0.12.5",
     "@types/d3-scale": "^4.0.9",
     "@types/d3-shape": "^3.1.7",
     "@types/d3-time": "^3.0.4",
     "@types/d3-timer": "^3.0.2",
     "d3-color": "^3.1.0",
     "d3-interpolate": "^3.0.1",
-    "d3-sankey": "^0.12.3",
+    "d3-path": "^3.1.0",
     "d3-scale": "^4.0.2",
     "d3-shape": "^3.2.0",
     "d3-time": "^3.1.0",
-    "d3-timer": "^3.0.1"
+    "d3-timer": "^3.0.1",
+    "flatqueue": "^3.0.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.28.3",
     "@babel/plugin-transform-runtime": "^7.28.5",
     "@types/d3-array": "^3.2.2",
     "@types/d3-format": "^3.0.4",
-    "@types/d3-path": "^3.1.1",
     "@types/d3-time-format": "^4.0.3",
     "babel-plugin-module-resolver": "^5.0.2",
     "d3-array": "^3.2.4",
     "d3-format": "^3.1.0",
-    "d3-path": "^3.1.0",
     "d3-time-format": "^4.1.0",
     "execa": "^9.6.0",
     "internmap": "^2.0.3",
-    "rimraf": "^6.1.0"
+    "rimraf": "^6.1.2"
   },
   "publishConfig": {
     "access": "public"

package/es/d3-sankey.mjs

@@ -1,6 +0,0 @@
-
-// `x-charts-vendor/d3-sankey` (ESM)
-// See upstream license: https://github.com/d3/d3-sankey/blob/main/LICENSE
-//
-// Our ESM package uses the underlying installed dependencies of `node_modules/d3-sankey`
-export * from "d3-sankey";

package/lib/d3-sankey.js

@@ -1,6 +0,0 @@
-
-// `x-charts-vendor/d3-sankey` (CommonJS)
-// See upstream license: https://github.com/d3/d3-sankey/blob/main/LICENSE
-//
-// Our CommonJS package relies on transpiled vendor files in `lib-vendor/d3-sankey`
-module.exports = require("../lib-vendor/d3-sankey/src/index.js");

package/lib-vendor/d3-sankey/LICENSE

@@ -1,27 +0,0 @@
-Copyright 2015, Mike Bostock
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of the author nor the names of contributors may be used to
-  endorse or promote products derived from this software without specific prior
-  written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/lib-vendor/d3-sankey/dist/d3-sankey.js

@@ -1,438 +0,0 @@
-"use strict";
-
-// https://github.com/d3/d3-sankey v0.12.3 Copyright 2019 Mike Bostock
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require("../../../lib-vendor/d3-array/src/index.js"), require("../../../lib-vendor/d3-shape/src/index.js")) : typeof define === 'function' && define.amd ? define(['exports', 'd3-array', 'd3-shape'], factory) : (global = global || self, factory(global.d3 = global.d3 || {}, global.d3, global.d3));
-})(this, function (exports, d3Array, d3Shape) {
-  'use strict';
-
-  function targetDepth(d) {
-    return d.target.depth;
-  }
-  function left(node) {
-    return node.depth;
-  }
-  function 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 ? d3Array.min(node.sourceLinks, targetDepth) - 1 : 0;
-  }
-  function constant(x) {
-    return function () {
-      return x;
-    };
-  }
-  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 value(d) {
-    return d.value;
-  }
-  function defaultId(d) {
-    return d.index;
-  }
-  function defaultNodes(graph) {
-    return graph.nodes;
-  }
-  function defaultLinks(graph) {
-    return graph.links;
-  }
-  function 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(_), sankey) : id;
-    };
-    sankey.nodeAlign = function (_) {
-      return arguments.length ? (align = typeof _ === "function" ? _ : 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(_), sankey) : nodes;
-    };
-    sankey.links = function (_) {
-      return arguments.length ? (links = typeof _ === "function" ? _ : 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 = find(nodeById, source);
-        if (typeof target !== "object") target = link.target = 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(d3Array.sum(node.sourceLinks, value), d3Array.sum(node.targetLinks, 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 = d3Array.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 = d3Array.min(columns, c => (y1 - y0 - (c.length - 1) * py) / d3Array.sum(c, 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) / (d3Array.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;
-  }
-  function horizontalSource(d) {
-    return [d.source.x1, d.y0];
-  }
-  function horizontalTarget(d) {
-    return [d.target.x0, d.y1];
-  }
-  function sankeyLinkHorizontal() {
-    return d3Shape.linkHorizontal().source(horizontalSource).target(horizontalTarget);
-  }
-  exports.sankey = Sankey;
-  exports.sankeyCenter = center;
-  exports.sankeyJustify = justify;
-  exports.sankeyLeft = left;
-  exports.sankeyLinkHorizontal = sankeyLinkHorizontal;
-  exports.sankeyRight = right;
-  Object.defineProperty(exports, '__esModule', {
-    value: true
-  });
-});