@mui/x-charts-pro 8.0.0-alpha.10 → 8.0.0-alpha.12

package/esm/Heatmap/HeatmapTooltip.js

@@ -0,0 +1,276 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import HTMLElementType from '@mui/utils/HTMLElementType';
+import composeClasses from '@mui/utils/composeClasses';
+import { ChartsTooltipPaper, ChartsTooltipTable, ChartsTooltipRow, ChartsTooltipCell, useItemTooltip, getChartsTooltipUtilityClass, ChartsTooltipContainer } from '@mui/x-charts/ChartsTooltip';
+import { useXAxis, useYAxis } from '@mui/x-charts/hooks';
+import { getLabel, ChartsLabelMark } from '@mui/x-charts/internals';
+import { useHeatmapSeriesContext } from "../hooks/useHeatmapSeries.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const useUtilityClasses = ownerState => {
+  const {
+    classes
+  } = ownerState;
+  const slots = {
+    root: ['root'],
+    paper: ['paper'],
+    table: ['table'],
+    row: ['row'],
+    cell: ['cell'],
+    mark: ['mark'],
+    markCell: ['markCell'],
+    labelCell: ['labelCell'],
+    valueCell: ['valueCell']
+  };
+  return composeClasses(slots, getChartsTooltipUtilityClass, classes);
+};
+function DefaultHeatmapTooltipContent(props) {
+  const {
+    classes
+  } = props;
+  const xAxis = useXAxis();
+  const yAxis = useYAxis();
+  const heatmapSeries = useHeatmapSeriesContext();
+  const tooltipData = useItemTooltip();
+  if (!tooltipData || !heatmapSeries || heatmapSeries.seriesOrder.length === 0) {
+    return null;
+  }
+  const {
+    series,
+    seriesOrder
+  } = heatmapSeries;
+  const seriesId = seriesOrder[0];
+  const {
+    color,
+    value,
+    identifier,
+    markType
+  } = tooltipData;
+  const [xIndex, yIndex] = value;
+  const formattedX = xAxis.valueFormatter?.(xAxis.data[xIndex], {
+    location: 'tooltip',
+    scale: xAxis.scale
+  }) ?? xAxis.data[xIndex].toLocaleString();
+  const formattedY = yAxis.valueFormatter?.(yAxis.data[yIndex], {
+    location: 'tooltip',
+    scale: yAxis.scale
+  }) ?? yAxis.data[yIndex].toLocaleString();
+  const formattedValue = series[seriesId].valueFormatter(value, {
+    dataIndex: identifier.dataIndex
+  });
+  const seriesLabel = getLabel(series[seriesId].label, 'tooltip');
+  return /*#__PURE__*/_jsx(ChartsTooltipPaper, {
+    className: classes?.paper,
+    children: /*#__PURE__*/_jsxs(ChartsTooltipTable, {
+      className: classes?.table,
+      children: [/*#__PURE__*/_jsx("thead", {
+        children: /*#__PURE__*/_jsxs(ChartsTooltipRow, {
+          className: classes?.row,
+          children: [/*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: classes?.cell,
+            children: formattedX
+          }), formattedX && formattedY && /*#__PURE__*/_jsx(ChartsTooltipCell, {}), /*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: classes?.cell,
+            children: formattedY
+          })]
+        })
+      }), /*#__PURE__*/_jsx("tbody", {
+        children: /*#__PURE__*/_jsxs(ChartsTooltipRow, {
+          className: classes?.row,
+          children: [/*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: clsx(classes?.markCell, classes?.cell),
+            children: /*#__PURE__*/_jsx(ChartsLabelMark, {
+              type: markType,
+              color: color,
+              className: classes?.mark
+            })
+          }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: clsx(classes?.labelCell, classes?.cell),
+            children: seriesLabel
+          }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: clsx(classes?.valueCell, classes?.cell),
+            children: formattedValue
+          })]
+        })
+      })]
+    })
+  });
+}
+process.env.NODE_ENV !== "production" ? DefaultHeatmapTooltipContent.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object
+} : void 0;
+function HeatmapTooltip(props) {
+  const classes = useUtilityClasses({
+    classes: props.classes
+  });
+  return /*#__PURE__*/_jsx(ChartsTooltipContainer, _extends({}, props, {
+    classes: classes,
+    trigger: "item",
+    children: /*#__PURE__*/_jsx(DefaultHeatmapTooltipContent, {
+      classes: classes
+    })
+  }));
+}
+process.env.NODE_ENV !== "production" ? HeatmapTooltip.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * An HTML element, [virtualElement](https://popper.js.org/docs/v2/virtual-elements/),
+   * or a function that returns either.
+   * It's used to set the position of the popper.
+   * The return value will passed as the reference object of the Popper instance.
+   */
+  anchorEl: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.object, PropTypes.func]),
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: PropTypes.elementType,
+  /**
+   * The components used for each slot inside the Popper.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  components: PropTypes.shape({
+    Root: PropTypes.elementType
+  }),
+  /**
+   * The props used for each slot inside the Popper.
+   * @default {}
+   */
+  componentsProps: PropTypes.shape({
+    root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
+  }),
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * You can also provide a callback, which is called in a React layout effect.
+   * This lets you set the container from a ref, and also makes server-side rendering possible.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: PropTypes.oneOfType([(props, propName) => {
+    if (props[propName] == null) {
+      return new Error(`Prop '${propName}' is required but wasn't specified`);
+    }
+    if (typeof props[propName] !== 'object' || props[propName].nodeType !== 1) {
+      return new Error(`Expected prop '${propName}' to be of type Element`);
+    }
+    return null;
+  }, PropTypes.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: PropTypes.bool,
+  /**
+   * Always keep the children in the DOM.
+   * This prop can be useful in SEO situation or
+   * when you want to maximize the responsiveness of the Popper.
+   * @default false
+   */
+  keepMounted: PropTypes.bool,
+  /**
+   * Popper.js is based on a "plugin-like" architecture,
+   * most of its features are fully encapsulated "modifiers".
+   *
+   * A modifier is a function that is called each time Popper.js needs to
+   * compute the position of the popper.
+   * For this reason, modifiers should be very performant to avoid bottlenecks.
+   * To learn how to create a modifier, [read the modifiers documentation](https://popper.js.org/docs/v2/modifiers/).
+   */
+  modifiers: PropTypes.arrayOf(PropTypes.shape({
+    data: PropTypes.object,
+    effect: PropTypes.func,
+    enabled: PropTypes.bool,
+    fn: PropTypes.func,
+    name: PropTypes.any,
+    options: PropTypes.object,
+    phase: PropTypes.oneOf(['afterMain', 'afterRead', 'afterWrite', 'beforeMain', 'beforeRead', 'beforeWrite', 'main', 'read', 'write']),
+    requires: PropTypes.arrayOf(PropTypes.string),
+    requiresIfExists: PropTypes.arrayOf(PropTypes.string)
+  })),
+  /**
+   * If `true`, the component is shown.
+   */
+  open: PropTypes.bool,
+  /**
+   * Popper placement.
+   * @default 'bottom'
+   */
+  placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
+  /**
+   * Options provided to the [`Popper.js`](https://popper.js.org/docs/v2/constructors/#options) instance.
+   * @default {}
+   */
+  popperOptions: PropTypes.shape({
+    modifiers: PropTypes.array,
+    onFirstUpdate: PropTypes.func,
+    placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
+    strategy: PropTypes.oneOf(['absolute', 'fixed'])
+  }),
+  /**
+   * A ref that points to the used popper instance.
+   */
+  popperRef: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
+    current: PropTypes.shape({
+      destroy: PropTypes.func.isRequired,
+      forceUpdate: PropTypes.func.isRequired,
+      setOptions: PropTypes.func.isRequired,
+      state: PropTypes.shape({
+        attributes: PropTypes.object.isRequired,
+        elements: PropTypes.object.isRequired,
+        modifiersData: PropTypes.object.isRequired,
+        options: PropTypes.object.isRequired,
+        orderedModifiers: PropTypes.arrayOf(PropTypes.object).isRequired,
+        placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']).isRequired,
+        rects: PropTypes.object.isRequired,
+        reset: PropTypes.bool.isRequired,
+        scrollParents: PropTypes.object.isRequired,
+        strategy: PropTypes.oneOf(['absolute', 'fixed']).isRequired,
+        styles: PropTypes.object.isRequired
+      }).isRequired,
+      update: PropTypes.func.isRequired
+    })
+  })]),
+  /**
+   * The props used for each slot inside the Popper.
+   * @default {}
+   */
+  slotProps: PropTypes.object,
+  /**
+   * The components used for each slot inside the Popper.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: PropTypes.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  /**
+   * Help supporting a react-transition-group/Transition component.
+   * @default false
+   */
+  transition: PropTypes.bool
+} : void 0;
+export { HeatmapTooltip };

package/esm/Heatmap/heatmapClasses.d.ts

@@ -0,0 +1,11 @@
+export interface HeatmapClasses {
+  /** Styles applied to the heatmap cells. */
+  cell: string;
+  /** Styles applied to the cell element if highlighted. */
+  highlighted: string;
+  /** Styles applied to the cell element if faded. */
+  faded: string;
+}
+export type HeatmapClassKey = keyof HeatmapClasses;
+export declare function getHeatmapUtilityClass(slot: string): string;
+export declare const heatmapClasses: HeatmapClasses;

package/esm/Heatmap/heatmapClasses.js

@@ -0,0 +1,14 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+export function getHeatmapUtilityClass(slot) {
+  // Those should be common to all charts
+  if (['highlighted', 'faded'].includes(slot)) {
+    return generateUtilityClass('Charts', slot);
+  }
+  return generateUtilityClass('MuiHeatmap', slot);
+}
+export const heatmapClasses = _extends({}, generateUtilityClasses('MuiHeatmap', ['cell']), {
+  highlighted: 'Charts-highlighted',
+  faded: 'Charts-faded'
+});

package/esm/Heatmap/index.d.ts

@@ -0,0 +1,4 @@
+export { Heatmap } from "./Heatmap.js";
+export { HeatmapPlot } from "./HeatmapPlot.js";
+export * from "./HeatmapTooltip.js";
+export * from "./heatmapClasses.js";

package/esm/Heatmap/index.js

@@ -0,0 +1,4 @@
+export { Heatmap } from "./Heatmap.js";
+export { HeatmapPlot } from "./HeatmapPlot.js";
+export * from "./HeatmapTooltip.js";
+export * from "./heatmapClasses.js";

package/esm/Heatmap/seriesConfig/extremums.d.ts

@@ -0,0 +1,2 @@
+import { CartesianExtremumGetter } from '@mui/x-charts/internals';
+export declare const getBaseExtremum: CartesianExtremumGetter<'heatmap'>;

package/esm/Heatmap/seriesConfig/getColor.d.ts

@@ -0,0 +1,3 @@
+import { ColorProcessor } from '@mui/x-charts/internals';
+declare const getColor: ColorProcessor<'heatmap'>;
+export default getColor;

package/esm/Heatmap/seriesConfig/index.d.ts

@@ -0,0 +1,2 @@
+import { ChartSeriesTypeConfig } from '@mui/x-charts/internals';
+export declare const seriesConfig: ChartSeriesTypeConfig<'heatmap'>;

package/{Heatmap/plugin.js → esm/Heatmap/seriesConfig/index.js}

@@ -1,9 +1,9 @@
 import { getBaseExtremum } from "./extremums.js";
-import formatter from "./formatter.js";
+import seriesProcessor from "./seriesProcessor.js";
 import getColor from "./getColor.js";
 import tooltipGetter from "./tooltip.js";
-export const plugin = {
-  seriesProcessor: formatter,
+export const seriesConfig = {
+  seriesProcessor,
   colorProcessor: getColor,
   legendGetter: () => [],
   tooltipGetter,

package/esm/Heatmap/seriesConfig/seriesProcessor.d.ts

@@ -0,0 +1,3 @@
+import { SeriesProcessor } from '@mui/x-charts/internals';
+declare const seriesProcessor: SeriesProcessor<'heatmap'>;
+export default seriesProcessor;

package/{Heatmap/formatter.js → esm/Heatmap/seriesConfig/seriesProcessor.js}

@@ -1,5 +1,5 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
-const formatter = params => {
+const seriesProcessor = params => {
   const {
     series,
     seriesOrder
@@ -18,4 +18,4 @@ const formatter = params => {
     seriesOrder
   };
 };
-export default formatter;
+export default seriesProcessor;

package/esm/Heatmap/seriesConfig/tooltip.d.ts

@@ -0,0 +1,3 @@
+import { TooltipGetter } from '@mui/x-charts/internals';
+declare const tooltipGetter: TooltipGetter<'heatmap'>;
+export default tooltipGetter;

package/esm/LineChartPro/LineChartPro.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { LineChartProps } from '@mui/x-charts/LineChart';
+import { ChartContainerProProps } from "../ChartContainerPro/index.js";
+export interface LineChartProProps extends Omit<LineChartProps, 'apiRef'>, Omit<ChartContainerProProps<'line'>, 'series' | 'plugins' | 'seriesConfig'> {}
+/**
+ * Demos:
+ *
+ * - [Lines](https://mui.com/x/react-charts/lines/)
+ * - [Line demonstration](https://mui.com/x/react-charts/line-demo/)
+ *
+ * API:
+ *
+ * - [LineChart API](https://mui.com/x/api/charts/line-chart/)
+ */
+declare const LineChartPro: React.ForwardRefExoticComponent<LineChartProProps & React.RefAttributes<SVGSVGElement>>;
+export { LineChartPro };