Index: node_modules/recharts/es6/cartesian/CartesianGrid.js =================================================================== --- node_modules/recharts/es6/cartesian/CartesianGrid.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/recharts/es6/cartesian/CartesianGrid.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,411 @@ +var _excluded = ["x1", "y1", "x2", "y2", "key"], + _excluded2 = ["offset"], + _excluded3 = ["xAxisId", "yAxisId"], + _excluded4 = ["xAxisId", "yAxisId"]; +function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } +function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } +function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); } +function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; } +function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; } +import * as React from 'react'; +import { warn } from '../util/LogUtils'; +import { isNumber } from '../util/DataUtils'; +import { getCoordinatesOfGrid, getTicksOfAxis } from '../util/ChartUtils'; +import { getTicks } from './getTicks'; +import { defaultCartesianAxisProps } from './CartesianAxis'; +import { useChartHeight, useChartWidth, useOffsetInternal } from '../context/chartLayoutContext'; +import { selectAxisPropsNeededForCartesianGridTicksGenerator } from '../state/selectors/axisSelectors'; +import { useAppSelector } from '../state/hooks'; +import { useIsPanorama } from '../context/PanoramaContext'; +import { resolveDefaultProps } from '../util/resolveDefaultProps'; +import { svgPropertiesNoEvents } from '../util/svgPropertiesNoEvents'; +import { isPositiveNumber } from '../util/isWellBehavedNumber'; +import { ZIndexLayer } from '../zIndex/ZIndexLayer'; +import { DefaultZIndexes } from '../zIndex/DefaultZIndexes'; + +/** + * The { + var { + fill + } = props; + if (!fill || fill === 'none') { + return null; + } + var { + fillOpacity, + x, + y, + width, + height, + ry + } = props; + return /*#__PURE__*/React.createElement("rect", { + x: x, + y: y, + ry: ry, + width: width, + height: height, + stroke: "none", + fill: fill, + fillOpacity: fillOpacity, + className: "recharts-cartesian-grid-bg" + }); +}; +function LineItem(_ref) { + var { + option, + lineItemProps + } = _ref; + var lineItem; + if (/*#__PURE__*/React.isValidElement(option)) { + // @ts-expect-error typescript does not see the props type when cloning an element + lineItem = /*#__PURE__*/React.cloneElement(option, lineItemProps); + } else if (typeof option === 'function') { + lineItem = option(lineItemProps); + } else { + var _svgPropertiesNoEvent; + var { + x1, + y1, + x2, + y2, + key + } = lineItemProps, + others = _objectWithoutProperties(lineItemProps, _excluded); + var _ref2 = (_svgPropertiesNoEvent = svgPropertiesNoEvents(others)) !== null && _svgPropertiesNoEvent !== void 0 ? _svgPropertiesNoEvent : {}, + { + offset: __ + } = _ref2, + restOfFilteredProps = _objectWithoutProperties(_ref2, _excluded2); + lineItem = /*#__PURE__*/React.createElement("line", _extends({}, restOfFilteredProps, { + x1: x1, + y1: y1, + x2: x2, + y2: y2, + fill: "none", + key: key + })); + } + return lineItem; +} +function HorizontalGridLines(props) { + var { + x, + width, + horizontal = true, + horizontalPoints + } = props; + if (!horizontal || !horizontalPoints || !horizontalPoints.length) { + return null; + } + var { + xAxisId, + yAxisId + } = props, + otherLineItemProps = _objectWithoutProperties(props, _excluded3); + var items = horizontalPoints.map((entry, i) => { + var lineItemProps = _objectSpread(_objectSpread({}, otherLineItemProps), {}, { + x1: x, + y1: entry, + x2: x + width, + y2: entry, + key: "line-".concat(i), + index: i + }); + return /*#__PURE__*/React.createElement(LineItem, { + key: "line-".concat(i), + option: horizontal, + lineItemProps: lineItemProps + }); + }); + return /*#__PURE__*/React.createElement("g", { + className: "recharts-cartesian-grid-horizontal" + }, items); +} +function VerticalGridLines(props) { + var { + y, + height, + vertical = true, + verticalPoints + } = props; + if (!vertical || !verticalPoints || !verticalPoints.length) { + return null; + } + var { + xAxisId, + yAxisId + } = props, + otherLineItemProps = _objectWithoutProperties(props, _excluded4); + var items = verticalPoints.map((entry, i) => { + var lineItemProps = _objectSpread(_objectSpread({}, otherLineItemProps), {}, { + x1: entry, + y1: y, + x2: entry, + y2: y + height, + key: "line-".concat(i), + index: i + }); + return /*#__PURE__*/React.createElement(LineItem, { + option: vertical, + lineItemProps: lineItemProps, + key: "line-".concat(i) + }); + }); + return /*#__PURE__*/React.createElement("g", { + className: "recharts-cartesian-grid-vertical" + }, items); +} +function HorizontalStripes(props) { + var { + horizontalFill, + fillOpacity, + x, + y, + width, + height, + horizontalPoints, + horizontal = true + } = props; + if (!horizontal || !horizontalFill || !horizontalFill.length || horizontalPoints == null) { + return null; + } + var roundedSortedHorizontalPoints = horizontalPoints.map(e => Math.round(e + y - y)).sort((a, b) => a - b); + // Why is this condition `!==` instead of `<=` ? + if (y !== roundedSortedHorizontalPoints[0]) { + roundedSortedHorizontalPoints.unshift(0); + } + var items = roundedSortedHorizontalPoints.map((entry, i) => { + // Why do we strip only the last stripe if it is invisible, and not all invisible stripes? + var nextPoint = roundedSortedHorizontalPoints[i + 1]; + var lastStripe = nextPoint == null; + var lineHeight = lastStripe ? y + height - entry : nextPoint - entry; + if (lineHeight <= 0) { + return null; + } + var colorIndex = i % horizontalFill.length; + return /*#__PURE__*/React.createElement("rect", { + key: "react-".concat(i), + y: entry, + x: x, + height: lineHeight, + width: width, + stroke: "none", + fill: horizontalFill[colorIndex], + fillOpacity: fillOpacity, + className: "recharts-cartesian-grid-bg" + }); + }); + return /*#__PURE__*/React.createElement("g", { + className: "recharts-cartesian-gridstripes-horizontal" + }, items); +} +function VerticalStripes(props) { + var { + vertical = true, + verticalFill, + fillOpacity, + x, + y, + width, + height, + verticalPoints + } = props; + if (!vertical || !verticalFill || !verticalFill.length) { + return null; + } + var roundedSortedVerticalPoints = verticalPoints.map(e => Math.round(e + x - x)).sort((a, b) => a - b); + if (x !== roundedSortedVerticalPoints[0]) { + roundedSortedVerticalPoints.unshift(0); + } + var items = roundedSortedVerticalPoints.map((entry, i) => { + var nextPoint = roundedSortedVerticalPoints[i + 1]; + var lastStripe = nextPoint == null; + var lineWidth = lastStripe ? x + width - entry : nextPoint - entry; + if (lineWidth <= 0) { + return null; + } + var colorIndex = i % verticalFill.length; + return /*#__PURE__*/React.createElement("rect", { + key: "react-".concat(i), + x: entry, + y: y, + width: lineWidth, + height: height, + stroke: "none", + fill: verticalFill[colorIndex], + fillOpacity: fillOpacity, + className: "recharts-cartesian-grid-bg" + }); + }); + return /*#__PURE__*/React.createElement("g", { + className: "recharts-cartesian-gridstripes-vertical" + }, items); +} +var defaultVerticalCoordinatesGenerator = (_ref3, syncWithTicks) => { + var { + xAxis, + width, + height, + offset + } = _ref3; + return getCoordinatesOfGrid(getTicks(_objectSpread(_objectSpread(_objectSpread({}, defaultCartesianAxisProps), xAxis), {}, { + ticks: getTicksOfAxis(xAxis, true), + viewBox: { + x: 0, + y: 0, + width, + height + } + })), offset.left, offset.left + offset.width, syncWithTicks); +}; +var defaultHorizontalCoordinatesGenerator = (_ref4, syncWithTicks) => { + var { + yAxis, + width, + height, + offset + } = _ref4; + return getCoordinatesOfGrid(getTicks(_objectSpread(_objectSpread(_objectSpread({}, defaultCartesianAxisProps), yAxis), {}, { + ticks: getTicksOfAxis(yAxis, true), + viewBox: { + x: 0, + y: 0, + width, + height + } + })), offset.top, offset.top + offset.height, syncWithTicks); +}; +export var defaultCartesianGridProps = { + horizontal: true, + vertical: true, + // The ordinates of horizontal grid lines + horizontalPoints: [], + // The abscissas of vertical grid lines + verticalPoints: [], + stroke: '#ccc', + fill: 'none', + // The fill of colors of grid lines + verticalFill: [], + horizontalFill: [], + xAxisId: 0, + yAxisId: 0, + syncWithTicks: false, + zIndex: DefaultZIndexes.grid +}; + +/** + * Renders background grid with lines and fill colors in a Cartesian chart. + * + * @consumes CartesianChartContext + */ +export function CartesianGrid(props) { + var chartWidth = useChartWidth(); + var chartHeight = useChartHeight(); + var offset = useOffsetInternal(); + var propsIncludingDefaults = _objectSpread(_objectSpread({}, resolveDefaultProps(props, defaultCartesianGridProps)), {}, { + x: isNumber(props.x) ? props.x : offset.left, + y: isNumber(props.y) ? props.y : offset.top, + width: isNumber(props.width) ? props.width : offset.width, + height: isNumber(props.height) ? props.height : offset.height + }); + var { + xAxisId, + yAxisId, + x, + y, + width, + height, + syncWithTicks, + horizontalValues, + verticalValues + } = propsIncludingDefaults; + var isPanorama = useIsPanorama(); + var xAxis = useAppSelector(state => selectAxisPropsNeededForCartesianGridTicksGenerator(state, 'xAxis', xAxisId, isPanorama)); + var yAxis = useAppSelector(state => selectAxisPropsNeededForCartesianGridTicksGenerator(state, 'yAxis', yAxisId, isPanorama)); + if (!isPositiveNumber(width) || !isPositiveNumber(height) || !isNumber(x) || !isNumber(y)) { + return null; + } + + /* + * verticalCoordinatesGenerator and horizontalCoordinatesGenerator are defined + * outside the propsIncludingDefaults because they were never part of the original props + * and they were never passed as a prop down to horizontal/vertical custom elements. + * If we add these two to propsIncludingDefaults then we are changing public API. + * Not a bad thing per se but also not necessary. + */ + var verticalCoordinatesGenerator = propsIncludingDefaults.verticalCoordinatesGenerator || defaultVerticalCoordinatesGenerator; + var horizontalCoordinatesGenerator = propsIncludingDefaults.horizontalCoordinatesGenerator || defaultHorizontalCoordinatesGenerator; + var { + horizontalPoints, + verticalPoints + } = propsIncludingDefaults; + + // No horizontal points are specified + if ((!horizontalPoints || !horizontalPoints.length) && typeof horizontalCoordinatesGenerator === 'function') { + var isHorizontalValues = horizontalValues && horizontalValues.length; + var generatorResult = horizontalCoordinatesGenerator({ + yAxis: yAxis ? _objectSpread(_objectSpread({}, yAxis), {}, { + ticks: isHorizontalValues ? horizontalValues : yAxis.ticks + }) : undefined, + width: chartWidth !== null && chartWidth !== void 0 ? chartWidth : width, + height: chartHeight !== null && chartHeight !== void 0 ? chartHeight : height, + offset + }, isHorizontalValues ? true : syncWithTicks); + warn(Array.isArray(generatorResult), "horizontalCoordinatesGenerator should return Array but instead it returned [".concat(typeof generatorResult, "]")); + if (Array.isArray(generatorResult)) { + horizontalPoints = generatorResult; + } + } + + // No vertical points are specified + if ((!verticalPoints || !verticalPoints.length) && typeof verticalCoordinatesGenerator === 'function') { + var isVerticalValues = verticalValues && verticalValues.length; + var _generatorResult = verticalCoordinatesGenerator({ + xAxis: xAxis ? _objectSpread(_objectSpread({}, xAxis), {}, { + ticks: isVerticalValues ? verticalValues : xAxis.ticks + }) : undefined, + width: chartWidth !== null && chartWidth !== void 0 ? chartWidth : width, + height: chartHeight !== null && chartHeight !== void 0 ? chartHeight : height, + offset + }, isVerticalValues ? true : syncWithTicks); + warn(Array.isArray(_generatorResult), "verticalCoordinatesGenerator should return Array but instead it returned [".concat(typeof _generatorResult, "]")); + if (Array.isArray(_generatorResult)) { + verticalPoints = _generatorResult; + } + } + return /*#__PURE__*/React.createElement(ZIndexLayer, { + zIndex: propsIncludingDefaults.zIndex + }, /*#__PURE__*/React.createElement("g", { + className: "recharts-cartesian-grid" + }, /*#__PURE__*/React.createElement(Background, { + fill: propsIncludingDefaults.fill, + fillOpacity: propsIncludingDefaults.fillOpacity, + x: propsIncludingDefaults.x, + y: propsIncludingDefaults.y, + width: propsIncludingDefaults.width, + height: propsIncludingDefaults.height, + ry: propsIncludingDefaults.ry + }), /*#__PURE__*/React.createElement(HorizontalStripes, _extends({}, propsIncludingDefaults, { + horizontalPoints: horizontalPoints + })), /*#__PURE__*/React.createElement(VerticalStripes, _extends({}, propsIncludingDefaults, { + verticalPoints: verticalPoints + })), /*#__PURE__*/React.createElement(HorizontalGridLines, _extends({}, propsIncludingDefaults, { + offset: offset, + horizontalPoints: horizontalPoints, + xAxis: xAxis, + yAxis: yAxis + })), /*#__PURE__*/React.createElement(VerticalGridLines, _extends({}, propsIncludingDefaults, { + offset: offset, + verticalPoints: verticalPoints, + xAxis: xAxis, + yAxis: yAxis + })))); +} +CartesianGrid.displayName = 'CartesianGrid';