@mui/x-charts-vendor 9.0.0 → 9.4.0

package/lib-vendor/d3-geo/src/projection/orthographic.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.orthographicRaw = orthographicRaw;
+var _math = require("../math.js");
+var _azimuthal = require("./azimuthal.js");
+var _index = _interopRequireDefault(require("./index.js"));
+function orthographicRaw(x, y) {
+  return [(0, _math.cos)(y) * (0, _math.sin)(x), (0, _math.sin)(y)];
+}
+orthographicRaw.invert = (0, _azimuthal.azimuthalInvert)(_math.asin);
+function _default() {
+  return (0, _index.default)(orthographicRaw).scale(249.5).clipAngle(90 + _math.epsilon);
+}

package/lib-vendor/d3-geo/src/projection/resample.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _cartesian = require("../cartesian.js");
+var _math = require("../math.js");
+var _transform = require("../transform.js");
+var maxDepth = 16,
+  // maximum depth of subdivision
+  cosMinDistance = (0, _math.cos)(30 * _math.radians); // cos(minimum angular distance)
+
+function _default(project, delta2) {
+  return +delta2 ? resample(project, delta2) : resampleNone(project);
+}
+function resampleNone(project) {
+  return (0, _transform.transformer)({
+    point: function (x, y) {
+      x = project(x, y);
+      this.stream.point(x[0], x[1]);
+    }
+  });
+}
+function resample(project, delta2) {
+  function resampleLineTo(x0, y0, lambda0, a0, b0, c0, x1, y1, lambda1, a1, b1, c1, depth, stream) {
+    var dx = x1 - x0,
+      dy = y1 - y0,
+      d2 = dx * dx + dy * dy;
+    if (d2 > 4 * delta2 && depth--) {
+      var a = a0 + a1,
+        b = b0 + b1,
+        c = c0 + c1,
+        m = (0, _math.sqrt)(a * a + b * b + c * c),
+        phi2 = (0, _math.asin)(c /= m),
+        lambda2 = (0, _math.abs)((0, _math.abs)(c) - 1) < _math.epsilon || (0, _math.abs)(lambda0 - lambda1) < _math.epsilon ? (lambda0 + lambda1) / 2 : (0, _math.atan2)(b, a),
+        p = project(lambda2, phi2),
+        x2 = p[0],
+        y2 = p[1],
+        dx2 = x2 - x0,
+        dy2 = y2 - y0,
+        dz = dy * dx2 - dx * dy2;
+      if (dz * dz / d2 > delta2 // perpendicular projected distance
+      || (0, _math.abs)((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 // midpoint close to an end
+      || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) {
+        // angular distance
+        resampleLineTo(x0, y0, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream);
+        stream.point(x2, y2);
+        resampleLineTo(x2, y2, lambda2, a, b, c, x1, y1, lambda1, a1, b1, c1, depth, stream);
+      }
+    }
+  }
+  return function (stream) {
+    var lambda00, x00, y00, a00, b00, c00,
+      // first point
+      lambda0, x0, y0, a0, b0, c0; // previous point
+
+    var resampleStream = {
+      point: point,
+      lineStart: lineStart,
+      lineEnd: lineEnd,
+      polygonStart: function () {
+        stream.polygonStart();
+        resampleStream.lineStart = ringStart;
+      },
+      polygonEnd: function () {
+        stream.polygonEnd();
+        resampleStream.lineStart = lineStart;
+      }
+    };
+    function point(x, y) {
+      x = project(x, y);
+      stream.point(x[0], x[1]);
+    }
+    function lineStart() {
+      x0 = NaN;
+      resampleStream.point = linePoint;
+      stream.lineStart();
+    }
+    function linePoint(lambda, phi) {
+      var c = (0, _cartesian.cartesian)([lambda, phi]),
+        p = project(lambda, phi);
+      resampleLineTo(x0, y0, lambda0, a0, b0, c0, x0 = p[0], y0 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);
+      stream.point(x0, y0);
+    }
+    function lineEnd() {
+      resampleStream.point = point;
+      stream.lineEnd();
+    }
+    function ringStart() {
+      lineStart();
+      resampleStream.point = ringPoint;
+      resampleStream.lineEnd = ringEnd;
+    }
+    function ringPoint(lambda, phi) {
+      linePoint(lambda00 = lambda, phi), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;
+      resampleStream.point = linePoint;
+    }
+    function ringEnd() {
+      resampleLineTo(x0, y0, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, maxDepth, stream);
+      resampleStream.lineEnd = lineEnd;
+      lineEnd();
+    }
+    return resampleStream;
+  };
+}

package/lib-vendor/d3-geo/src/projection/stereographic.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.stereographicRaw = stereographicRaw;
+var _math = require("../math.js");
+var _azimuthal = require("./azimuthal.js");
+var _index = _interopRequireDefault(require("./index.js"));
+function stereographicRaw(x, y) {
+  var cy = (0, _math.cos)(y),
+    k = 1 + (0, _math.cos)(x) * cy;
+  return [cy * (0, _math.sin)(x) / k, (0, _math.sin)(y) / k];
+}
+stereographicRaw.invert = (0, _azimuthal.azimuthalInvert)(function (z) {
+  return 2 * (0, _math.atan)(z);
+});
+function _default() {
+  return (0, _index.default)(stereographicRaw).scale(250).clipAngle(142);
+}

package/lib-vendor/d3-geo/src/projection/transverseMercator.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.transverseMercatorRaw = transverseMercatorRaw;
+var _math = require("../math.js");
+var _mercator = require("./mercator.js");
+function transverseMercatorRaw(lambda, phi) {
+  return [(0, _math.log)((0, _math.tan)((_math.halfPi + phi) / 2)), -lambda];
+}
+transverseMercatorRaw.invert = function (x, y) {
+  return [-y, 2 * (0, _math.atan)((0, _math.exp)(x)) - _math.halfPi];
+};
+function _default() {
+  var m = (0, _mercator.mercatorProjection)(transverseMercatorRaw),
+    center = m.center,
+    rotate = m.rotate;
+  m.center = function (_) {
+    return arguments.length ? center([-_[1], _[0]]) : (_ = center(), [_[1], -_[0]]);
+  };
+  m.rotate = function (_) {
+    return arguments.length ? rotate([_[0], _[1], _.length > 2 ? _[2] + 90 : 90]) : (_ = rotate(), [_[0], _[1], _[2] - 90]);
+  };
+  return rotate([0, 0, 90]).scale(159.155);
+}

package/lib-vendor/d3-geo/src/rotation.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.rotateRadians = rotateRadians;
+var _compose = _interopRequireDefault(require("./compose.js"));
+var _math = require("./math.js");
+function rotationIdentity(lambda, phi) {
+  if ((0, _math.abs)(lambda) > _math.pi) lambda -= Math.round(lambda / _math.tau) * _math.tau;
+  return [lambda, phi];
+}
+rotationIdentity.invert = rotationIdentity;
+function rotateRadians(deltaLambda, deltaPhi, deltaGamma) {
+  return (deltaLambda %= _math.tau) ? deltaPhi || deltaGamma ? (0, _compose.default)(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma)) : rotationLambda(deltaLambda) : deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma) : rotationIdentity;
+}
+function forwardRotationLambda(deltaLambda) {
+  return function (lambda, phi) {
+    lambda += deltaLambda;
+    if ((0, _math.abs)(lambda) > _math.pi) lambda -= Math.round(lambda / _math.tau) * _math.tau;
+    return [lambda, phi];
+  };
+}
+function rotationLambda(deltaLambda) {
+  var rotation = forwardRotationLambda(deltaLambda);
+  rotation.invert = forwardRotationLambda(-deltaLambda);
+  return rotation;
+}
+function rotationPhiGamma(deltaPhi, deltaGamma) {
+  var cosDeltaPhi = (0, _math.cos)(deltaPhi),
+    sinDeltaPhi = (0, _math.sin)(deltaPhi),
+    cosDeltaGamma = (0, _math.cos)(deltaGamma),
+    sinDeltaGamma = (0, _math.sin)(deltaGamma);
+  function rotation(lambda, phi) {
+    var cosPhi = (0, _math.cos)(phi),
+      x = (0, _math.cos)(lambda) * cosPhi,
+      y = (0, _math.sin)(lambda) * cosPhi,
+      z = (0, _math.sin)(phi),
+      k = z * cosDeltaPhi + x * sinDeltaPhi;
+    return [(0, _math.atan2)(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi), (0, _math.asin)(k * cosDeltaGamma + y * sinDeltaGamma)];
+  }
+  rotation.invert = function (lambda, phi) {
+    var cosPhi = (0, _math.cos)(phi),
+      x = (0, _math.cos)(lambda) * cosPhi,
+      y = (0, _math.sin)(lambda) * cosPhi,
+      z = (0, _math.sin)(phi),
+      k = z * cosDeltaGamma - y * sinDeltaGamma;
+    return [(0, _math.atan2)(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi), (0, _math.asin)(k * cosDeltaPhi - x * sinDeltaPhi)];
+  };
+  return rotation;
+}
+function _default(rotate) {
+  rotate = rotateRadians(rotate[0] * _math.radians, rotate[1] * _math.radians, rotate.length > 2 ? rotate[2] * _math.radians : 0);
+  function forward(coordinates) {
+    coordinates = rotate(coordinates[0] * _math.radians, coordinates[1] * _math.radians);
+    return coordinates[0] *= _math.degrees, coordinates[1] *= _math.degrees, coordinates;
+  }
+  forward.invert = function (coordinates) {
+    coordinates = rotate.invert(coordinates[0] * _math.radians, coordinates[1] * _math.radians);
+    return coordinates[0] *= _math.degrees, coordinates[1] *= _math.degrees, coordinates;
+  };
+  return forward;
+}

package/lib-vendor/d3-geo/src/stream.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+function streamGeometry(geometry, stream) {
+  if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) {
+    streamGeometryType[geometry.type](geometry, stream);
+  }
+}
+var streamObjectType = {
+  Feature: function (object, stream) {
+    streamGeometry(object.geometry, stream);
+  },
+  FeatureCollection: function (object, stream) {
+    var features = object.features,
+      i = -1,
+      n = features.length;
+    while (++i < n) streamGeometry(features[i].geometry, stream);
+  }
+};
+var streamGeometryType = {
+  Sphere: function (object, stream) {
+    stream.sphere();
+  },
+  Point: function (object, stream) {
+    object = object.coordinates;
+    stream.point(object[0], object[1], object[2]);
+  },
+  MultiPoint: function (object, stream) {
+    var coordinates = object.coordinates,
+      i = -1,
+      n = coordinates.length;
+    while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]);
+  },
+  LineString: function (object, stream) {
+    streamLine(object.coordinates, stream, 0);
+  },
+  MultiLineString: function (object, stream) {
+    var coordinates = object.coordinates,
+      i = -1,
+      n = coordinates.length;
+    while (++i < n) streamLine(coordinates[i], stream, 0);
+  },
+  Polygon: function (object, stream) {
+    streamPolygon(object.coordinates, stream);
+  },
+  MultiPolygon: function (object, stream) {
+    var coordinates = object.coordinates,
+      i = -1,
+      n = coordinates.length;
+    while (++i < n) streamPolygon(coordinates[i], stream);
+  },
+  GeometryCollection: function (object, stream) {
+    var geometries = object.geometries,
+      i = -1,
+      n = geometries.length;
+    while (++i < n) streamGeometry(geometries[i], stream);
+  }
+};
+function streamLine(coordinates, stream, closed) {
+  var i = -1,
+    n = coordinates.length - closed,
+    coordinate;
+  stream.lineStart();
+  while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);
+  stream.lineEnd();
+}
+function streamPolygon(coordinates, stream) {
+  var i = -1,
+    n = coordinates.length;
+  stream.polygonStart();
+  while (++i < n) streamLine(coordinates[i], stream, 1);
+  stream.polygonEnd();
+}
+function _default(object, stream) {
+  if (object && streamObjectType.hasOwnProperty(object.type)) {
+    streamObjectType[object.type](object, stream);
+  } else {
+    streamGeometry(object, stream);
+  }
+}

package/lib-vendor/d3-geo/src/transform.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.transformer = transformer;
+function _default(methods) {
+  return {
+    stream: transformer(methods)
+  };
+}
+function transformer(methods) {
+  return function (stream) {
+    var s = new TransformStream();
+    for (var key in methods) s[key] = methods[key];
+    s.stream = stream;
+    return s;
+  };
+}
+function TransformStream() {}
+TransformStream.prototype = {
+  constructor: TransformStream,
+  point: function (x, y) {
+    this.stream.point(x, y);
+  },
+  sphere: function () {
+    this.stream.sphere();
+  },
+  lineStart: function () {
+    this.stream.lineStart();
+  },
+  lineEnd: function () {
+    this.stream.lineEnd();
+  },
+  polygonStart: function () {
+    this.stream.polygonStart();
+  },
+  polygonEnd: function () {
+    this.stream.polygonEnd();
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-charts-vendor",
-  "version": "9.0.0",
+  "version": "9.4.0",
   "author": "MUI Team",
   "description": "Vendored dependencies for MUI X Charts.",
   "license": "MIT AND ISC",
@@ -16,10 +16,11 @@
     "directory": "packages/x-charts-vendor"
   },
   "dependencies": {
-    "@babel/runtime": "^7.28.6",
+    "@babel/runtime": "^7.29.7",
     "@types/d3-array": "^3.2.2",
     "@types/d3-color": "^3.1.3",
     "@types/d3-format": "^3.0.4",
+    "@types/d3-geo": "^3.1.0",
     "@types/d3-interpolate": "^3.0.4",
     "@types/d3-path": "^3.1.1",
     "@types/d3-scale": "^4.0.9",
@@ -30,6 +31,7 @@
     "d3-array": "^3.2.4",
     "d3-color": "^3.1.0",
     "d3-format": "^3.1.2",
+    "d3-geo": "^3.1.1",
     "d3-interpolate": "^3.0.1",
     "d3-path": "^3.1.0",
     "d3-scale": "^4.0.2",
@@ -89,6 +91,20 @@
         "default": "./d3-format.mjs"
       }
     },
+    "./d3-geo": {
+      "import": {
+        "types": "./d3-geo.d.ts",
+        "default": "./d3-geo.mjs"
+      },
+      "require": {
+        "types": "./d3-geo.d.ts",
+        "default": "./d3-geo.js"
+      },
+      "default": {
+        "types": "./d3-geo.d.ts",
+        "default": "./d3-geo.mjs"
+      }
+    },
     "./d3-interpolate": {
       "import": {
         "types": "./d3-interpolate.d.ts",