@mui/x-charts 7.14.0 → 7.15.0

package/{esm → node}/Gauge/GaugeContainer.js

@@ -1,16 +1,25 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GaugeContainer = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _styles = require("@mui/material/styles");
+var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
+var _useChartContainerDimensions = require("../ResponsiveChartContainer/useChartContainerDimensions");
+var _ChartsSurface = require("../ChartsSurface");
+var _DrawingProvider = require("../context/DrawingProvider");
+var _GaugeProvider = require("./GaugeProvider");
+var _jsxRuntime = require("react/jsx-runtime");
 const _excluded = ["width", "height", "margin", "title", "desc", "value", "valueMin", "valueMax", "startAngle", "endAngle", "outerRadius", "innerRadius", "cornerRadius", "cx", "cy", "children"];
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import { styled } from '@mui/material/styles';
-import useForkRef from '@mui/utils/useForkRef';
-import { useChartContainerDimensions } from '../ResponsiveChartContainer/useChartContainerDimensions';
-import { ChartsSurface } from '../ChartsSurface';
-import { DrawingProvider } from '../context/DrawingProvider';
-import { GaugeProvider } from './GaugeProvider';
-import { jsx as _jsx } from "react/jsx-runtime";
-const ResizableContainer = styled('div', {
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const ResizableContainer = (0, _styles.styled)('div', {
   name: 'MuiGauge',
   slot: 'Container'
 })(({
@@ -34,7 +43,7 @@ const ResizableContainer = styled('div', {
     fill: (theme.vars || theme).palette.text.primary
   }
 }));
-const GaugeContainer = /*#__PURE__*/React.forwardRef(function GaugeContainer(props, ref) {
+const GaugeContainer = exports.GaugeContainer = /*#__PURE__*/React.forwardRef(function GaugeContainer(props, ref) {
   const {
       width: inWidth,
       height: inHeight,
@@ -53,15 +62,15 @@ const GaugeContainer = /*#__PURE__*/React.forwardRef(function GaugeContainer(pro
       cy,
       children
     } = props,
-    other = _objectWithoutPropertiesLoose(props, _excluded);
+    other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
   const {
     containerRef,
     width,
     height
-  } = useChartContainerDimensions(inWidth, inHeight);
+  } = (0, _useChartContainerDimensions.useChartContainerDimensions)(inWidth, inHeight);
   const svgRef = React.useRef(null);
-  const chartSurfaceRef = useForkRef(ref, svgRef);
-  return /*#__PURE__*/_jsx(ResizableContainer, _extends({
+  const chartSurfaceRef = (0, _useForkRef.default)(ref, svgRef);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(ResizableContainer, (0, _extends2.default)({
     ref: containerRef,
     ownerState: {
       width: inWidth,
@@ -72,17 +81,17 @@ const GaugeContainer = /*#__PURE__*/React.forwardRef(function GaugeContainer(pro
     "aria-valuemin": valueMin,
     "aria-valuemax": valueMax
   }, other, {
-    children: width && height ? /*#__PURE__*/_jsx(DrawingProvider, {
+    children: width && height ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_DrawingProvider.DrawingProvider, {
       width: width,
       height: height,
-      margin: _extends({
+      margin: (0, _extends2.default)({
         left: 10,
         right: 10,
         top: 10,
         bottom: 10
       }, margin),
       svgRef: svgRef,
-      children: /*#__PURE__*/_jsx(GaugeProvider, {
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_GaugeProvider.GaugeProvider, {
         value: value,
         valueMin: valueMin,
         valueMax: valueMax,
@@ -93,7 +102,7 @@ const GaugeContainer = /*#__PURE__*/React.forwardRef(function GaugeContainer(pro
         cornerRadius: cornerRadius,
         cx: cx,
         cy: cy,
-        children: /*#__PURE__*/_jsx(ChartsSurface, {
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsSurface.ChartsSurface, {
           width: width,
           height: height,
           ref: chartSurfaceRef,
@@ -112,60 +121,60 @@ process.env.NODE_ENV !== "production" ? GaugeContainer.propTypes = {
   // | These PropTypes are generated from the TypeScript type definitions |
   // | To update them edit the TypeScript types and run "pnpm proptypes"  |
   // ----------------------------------------------------------------------
-  children: PropTypes.node,
-  className: PropTypes.string,
+  children: _propTypes.default.node,
+  className: _propTypes.default.string,
   /**
    * The radius applied to arc corners (similar to border radius).
    * Set it to '50%' to get rounded arc.
    * @default 0
    */
-  cornerRadius: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  cornerRadius: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),
   /**
    * The x coordinate of the arc center.
    * Can be a number (in px) or a string with a percentage such as '50%'.
    * The '100%' is the width the drawing area.
    */
-  cx: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  cx: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),
   /**
    * The y coordinate of the arc center.
    * Can be a number (in px) or a string with a percentage such as '50%'.
    * The '100%' is the height the drawing area.
    */
-  cy: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
-  desc: PropTypes.string,
+  cy: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),
+  desc: _propTypes.default.string,
   /**
    * If `true`, the charts will not listen to the mouse move event.
    * It might break interactive features, but will improve performance.
    * @default false
    */
-  disableAxisListener: PropTypes.bool,
+  disableAxisListener: _propTypes.default.bool,
   /**
    * The end angle (deg).
    * @default 360
    */
-  endAngle: PropTypes.number,
+  endAngle: _propTypes.default.number,
   /**
    * The height of the chart in px. If not defined, it takes the height of the parent element.
    */
-  height: PropTypes.number,
+  height: _propTypes.default.number,
   /**
    * The radius between circle center and the beginning of the arc.
    * Can be a number (in px) or a string with a percentage such as '50%'.
    * The '100%' is the maximal radius that fit into the drawing area.
    * @default '80%'
    */
-  innerRadius: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  innerRadius: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),
   /**
    * The margin between the SVG and the drawing area.
    * It's used for leaving some space for extra information such as the x- and y-axis or legend.
    * Accepts an object with the optional properties: `top`, `bottom`, `left`, and `right`.
    * @default object Depends on the charts type.
    */
-  margin: PropTypes.shape({
-    bottom: PropTypes.number,
-    left: PropTypes.number,
-    right: PropTypes.number,
-    top: PropTypes.number
+  margin: _propTypes.default.shape({
+    bottom: _propTypes.default.number,
+    left: _propTypes.default.number,
+    right: _propTypes.default.number,
+    top: _propTypes.default.number
   }),
   /**
    * The radius between circle center and the end of the arc.
@@ -173,38 +182,37 @@ process.env.NODE_ENV !== "production" ? GaugeContainer.propTypes = {
    * The '100%' is the maximal radius that fit into the drawing area.
    * @default '100%'
    */
-  outerRadius: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  outerRadius: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),
   /**
    * The start angle (deg).
    * @default 0
    */
-  startAngle: PropTypes.number,
-  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
-  title: PropTypes.string,
+  startAngle: _propTypes.default.number,
+  sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
+  title: _propTypes.default.string,
   /**
    * The value of the gauge.
    * Set to `null` to not display a value.
    */
-  value: PropTypes.number,
+  value: _propTypes.default.number,
   /**
    * The maximal value of the gauge.
    * @default 100
    */
-  valueMax: PropTypes.number,
+  valueMax: _propTypes.default.number,
   /**
    * The minimal value of the gauge.
    * @default 0
    */
-  valueMin: PropTypes.number,
-  viewBox: PropTypes.shape({
-    height: PropTypes.number,
-    width: PropTypes.number,
-    x: PropTypes.number,
-    y: PropTypes.number
+  valueMin: _propTypes.default.number,
+  viewBox: _propTypes.default.shape({
+    height: _propTypes.default.number,
+    width: _propTypes.default.number,
+    x: _propTypes.default.number,
+    y: _propTypes.default.number
   }),
   /**
    * The width of the chart in px. If not defined, it takes the width of the parent element.
    */
-  width: PropTypes.number
-} : void 0;
-export { GaugeContainer };
+  width: _propTypes.default.number
+} : void 0;

package/node/Gauge/GaugeProvider.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GaugeContext = void 0;
+exports.GaugeProvider = GaugeProvider;
+exports.useGaugeState = useGaugeState;
+var React = _interopRequireWildcard(require("react"));
+var _getPercentageValue = require("../internals/getPercentageValue");
+var _utils = require("./utils");
+var _useDrawingArea = require("../hooks/useDrawingArea");
+var _jsxRuntime = require("react/jsx-runtime");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+// @ignore - do not document.
+
+const GaugeContext = exports.GaugeContext = /*#__PURE__*/React.createContext({
+  value: null,
+  valueMin: 0,
+  valueMax: 0,
+  startAngle: 0,
+  endAngle: 0,
+  innerRadius: 0,
+  outerRadius: 0,
+  cornerRadius: 0,
+  cx: 0,
+  cy: 0,
+  maxRadius: 0,
+  valueAngle: null
+});
+if (process.env.NODE_ENV !== 'production') {
+  GaugeContext.displayName = 'GaugeContext';
+}
+function GaugeProvider(props) {
+  const {
+    value = null,
+    valueMin = 0,
+    valueMax = 100,
+    startAngle = 0,
+    endAngle = 360,
+    outerRadius: outerRadiusParam,
+    innerRadius: innerRadiusParam,
+    cornerRadius: cornerRadiusParam,
+    cx: cxParam,
+    cy: cyParam,
+    children
+  } = props;
+  const {
+    left,
+    top,
+    width,
+    height
+  } = (0, _useDrawingArea.useDrawingArea)();
+  const ratios = (0, _utils.getArcRatios)(startAngle, endAngle);
+  const innerCx = cxParam ? (0, _getPercentageValue.getPercentageValue)(cxParam, width) : ratios.cx * width;
+  const innerCy = cyParam ? (0, _getPercentageValue.getPercentageValue)(cyParam, height) : ratios.cy * height;
+  let cx = left + innerCx;
+  let cy = top + innerCy;
+  const maxRadius = (0, _utils.getAvailableRadius)(innerCx, innerCy, width, height, ratios);
+
+  // If the center is not defined, after computation of the available radius, update the center to use the remaining space.
+  if (cxParam === undefined) {
+    const usedWidth = maxRadius * (ratios.maxX - ratios.minX);
+    cx = left + (width - usedWidth) / 2 + ratios.cx * usedWidth;
+  }
+  if (cyParam === undefined) {
+    const usedHeight = maxRadius * (ratios.maxY - ratios.minY);
+    cy = top + (height - usedHeight) / 2 + ratios.cy * usedHeight;
+  }
+  const outerRadius = (0, _getPercentageValue.getPercentageValue)(outerRadiusParam ?? maxRadius, maxRadius);
+  const innerRadius = (0, _getPercentageValue.getPercentageValue)(innerRadiusParam ?? '80%', maxRadius);
+  const cornerRadius = (0, _getPercentageValue.getPercentageValue)(cornerRadiusParam ?? 0, outerRadius - innerRadius);
+  const contextValue = React.useMemo(() => {
+    const startAngleRad = Math.PI * startAngle / 180;
+    const endAngleRad = Math.PI * endAngle / 180;
+    return {
+      value,
+      valueMin,
+      valueMax,
+      startAngle: startAngleRad,
+      endAngle: endAngleRad,
+      outerRadius,
+      innerRadius,
+      cornerRadius,
+      cx,
+      cy,
+      maxRadius,
+      valueAngle: value === null ? null : startAngleRad + (endAngleRad - startAngleRad) * (value - valueMin) / (valueMax - valueMin)
+    };
+  }, [value, valueMin, valueMax, startAngle, endAngle, outerRadius, innerRadius, cornerRadius, cx, cy, maxRadius]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(GaugeContext.Provider, {
+    value: contextValue,
+    children: children
+  });
+}
+function useGaugeState() {
+  return React.useContext(GaugeContext);
+}

package/node/Gauge/GaugeReferenceArc.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GaugeReferenceArc = GaugeReferenceArc;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _d3Shape = require("@mui/x-charts-vendor/d3-shape");
+var _styles = require("@mui/material/styles");
+var _GaugeProvider = require("./GaugeProvider");
+var _jsxRuntime = require("react/jsx-runtime");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const StyledPath = (0, _styles.styled)('path', {
+  name: 'MuiGauge',
+  slot: 'ReferenceArc',
+  overridesResolver: (props, styles) => styles.referenceArc
+})(({
+  theme
+}) => ({
+  fill: (theme.vars || theme).palette.divider
+}));
+function GaugeReferenceArc(props) {
+  const {
+    startAngle,
+    endAngle,
+    outerRadius,
+    innerRadius,
+    cornerRadius,
+    cx,
+    cy
+  } = (0, _GaugeProvider.useGaugeState)();
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(StyledPath, (0, _extends2.default)({
+    transform: `translate(${cx}, ${cy})`,
+    d: (0, _d3Shape.arc)().cornerRadius(cornerRadius)({
+      startAngle,
+      endAngle,
+      innerRadius,
+      outerRadius
+    })
+  }, props));
+}

package/node/Gauge/GaugeValueArc.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GaugeValueArc = GaugeValueArc;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _d3Shape = require("@mui/x-charts-vendor/d3-shape");
+var _styles = require("@mui/material/styles");
+var _GaugeProvider = require("./GaugeProvider");
+var _jsxRuntime = require("react/jsx-runtime");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const StyledPath = (0, _styles.styled)('path', {
+  name: 'MuiGauge',
+  slot: 'ReferenceArc',
+  overridesResolver: (props, styles) => styles.referenceArc
+})(({
+  theme
+}) => ({
+  fill: (theme.vars || theme).palette.primary.main
+}));
+function GaugeValueArc(props) {
+  const {
+    value,
+    valueMin,
+    valueMax,
+    startAngle,
+    endAngle,
+    outerRadius,
+    innerRadius,
+    cornerRadius,
+    cx,
+    cy
+  } = (0, _GaugeProvider.useGaugeState)();
+  if (value === null) {
+    return null;
+  }
+  const valueAngle = startAngle + (value - valueMin) / (valueMax - valueMin) * (endAngle - startAngle);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(StyledPath, (0, _extends2.default)({
+    transform: `translate(${cx}, ${cy})`,
+    d: (0, _d3Shape.arc)().cornerRadius(cornerRadius)({
+      startAngle,
+      endAngle: valueAngle,
+      innerRadius,
+      outerRadius
+    })
+  }, props));
+}

package/node/Gauge/GaugeValueText.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GaugeValueText = GaugeValueText;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _GaugeProvider = require("./GaugeProvider");
+var _ChartsText = require("../ChartsText");
+var _jsxRuntime = require("react/jsx-runtime");
+const _excluded = ["text", "className"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function defaultFormatter({
+  value
+}) {
+  return value === null ? null : value.toLocaleString();
+}
+function GaugeValueText(props) {
+  const {
+      text = defaultFormatter,
+      className
+    } = props,
+    other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+  const {
+    value,
+    valueMin,
+    valueMax,
+    cx,
+    cy
+  } = (0, _GaugeProvider.useGaugeState)();
+  const formattedText = typeof text === 'function' ? text({
+    value,
+    valueMin,
+    valueMax
+  }) : text;
+  if (formattedText === null) {
+    return null;
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("g", {
+    className: className,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsText.ChartsText, (0, _extends2.default)({
+      x: cx,
+      y: cy,
+      text: formattedText,
+      style: {
+        textAnchor: 'middle',
+        dominantBaseline: 'central'
+      }
+    }, other))
+  });
+}
+process.env.NODE_ENV !== "production" ? GaugeValueText.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Height of a text line (in `em`).
+   */
+  lineHeight: _propTypes.default.number,
+  /**
+   * If `true`, the line width is computed.
+   * @default false
+   */
+  needsComputation: _propTypes.default.bool,
+  ownerState: _propTypes.default.any,
+  /**
+   * Style applied to text elements.
+   */
+  style: _propTypes.default.object,
+  text: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.string])
+} : void 0;

package/node/Gauge/gaugeClasses.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gaugeClasses = exports.default = void 0;
+exports.getGaugeUtilityClass = getGaugeUtilityClass;
+var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
+var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
+function getGaugeUtilityClass(slot) {
+  return (0, _generateUtilityClass.default)('MuiGauge', slot);
+}
+const gaugeClasses = exports.gaugeClasses = (0, _generateUtilityClasses.default)('MuiGauge', ['root', 'valueArc', 'referenceArc', 'valueText']);
+var _default = exports.default = gaugeClasses;

package/node/Gauge/index.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  useGaugeState: true
+};
+Object.defineProperty(exports, "useGaugeState", {
+  enumerable: true,
+  get: function () {
+    return _GaugeProvider.useGaugeState;
+  }
+});
+var _Gauge = require("./Gauge");
+Object.keys(_Gauge).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Gauge[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Gauge[key];
+    }
+  });
+});
+var _GaugeContainer = require("./GaugeContainer");
+Object.keys(_GaugeContainer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _GaugeContainer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _GaugeContainer[key];
+    }
+  });
+});
+var _GaugeValueText = require("./GaugeValueText");
+Object.keys(_GaugeValueText).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _GaugeValueText[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _GaugeValueText[key];
+    }
+  });
+});
+var _GaugeValueArc = require("./GaugeValueArc");
+Object.keys(_GaugeValueArc).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _GaugeValueArc[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _GaugeValueArc[key];
+    }
+  });
+});
+var _GaugeReferenceArc = require("./GaugeReferenceArc");
+Object.keys(_GaugeReferenceArc).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _GaugeReferenceArc[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _GaugeReferenceArc[key];
+    }
+  });
+});
+var _gaugeClasses = require("./gaugeClasses");
+Object.keys(_gaugeClasses).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _gaugeClasses[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _gaugeClasses[key];
+    }
+  });
+});
+var _GaugeProvider = require("./GaugeProvider");

package/{esm → node}/Gauge/utils.js

@@ -1,3 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getArcRatios = getArcRatios;
+exports.getAvailableRadius = getAvailableRadius;
 function deg2rad(angle) {
   return Math.PI * angle / 180;
 }
@@ -11,7 +18,7 @@ function getPoint(angle) {
  * @param startAngle The start angle (in deg)
  * @param endAngle The end angle (in deg)
  */
-export function getArcRatios(startAngle, endAngle) {
+function getArcRatios(startAngle, endAngle) {
   // Set the start, end and center point.
   const points = [[0, 0], getPoint(startAngle), getPoint(endAngle)];
 
@@ -38,7 +45,7 @@ export function getArcRatios(startAngle, endAngle) {
     maxY
   };
 }
-export function getAvailableRadius(cx, cy, width, height, {
+function getAvailableRadius(cx, cy, width, height, {
   minX,
   maxX,
   minY,