diff --git a/.gitignore b/.gitignore index eb549748..4ff81036 100644 --- a/.gitignore +++ b/.gitignore @@ -6,4 +6,4 @@ package-lock.json .idea .vscode yarn.lock -dist \ No newline at end of file +dist diff --git a/README.md b/README.md index 6290869f..0152c721 100644 --- a/README.md +++ b/README.md @@ -93,23 +93,27 @@ const chartConfig = { }; ``` -| Property | Type | Description | -| ----------------------------- | ------------------ | ------------------------------------------------------------------------------------------------------ | -| backgroundGradientFrom | string | Defines the first color in the linear gradient of a chart's background | -| backgroundGradientFromOpacity | Number | Defines the first color opacity in the linear gradient of a chart's background | -| backgroundGradientTo | string | Defines the second color in the linear gradient of a chart's background | -| backgroundGradientToOpacity | Number | Defines the second color opacity in the linear gradient of a chart's background | -| fillShadowGradient | string | Defines the color of the area under data | -| fillShadowGradientOpacity | Number | Defines the initial opacity of the area under data | -| useShadowColorFromDataset | Boolean | Defines the option to use color from dataset to each chart data. Default is false | -| color | function => string | Defines the base color function that is used to calculate colors of labels and sectors used in a chart | -| strokeWidth | Number | Defines the base stroke width in a chart | -| barPercentage | Number | Defines the percent (0-1) of the available width each bar width in a chart | -| barRadius | Number | Defines the radius of each bar | -| propsForBackgroundLines | props | Override styles of the background lines, refer to react-native-svg's Line documentation | -| propsForLabels | props | Override styles of the labels, refer to react-native-svg's Text documentation | -| propsForVerticalLabels | props | Override styles of vertical labels, refer to react-native-svg's Text documentation | -| propsForHorizontalLabels | props | Override styles of horizontal labels, refer to react-native-svg's Text documentation | +| Property | Type | Description | +| ----------------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------ | +| backgroundGradientFrom | string | Defines the first color in the linear gradient of a chart's background | +| backgroundGradientFromOpacity | Number | Defines the first color opacity in the linear gradient of a chart's background | +| backgroundGradientTo | string | Defines the second color in the linear gradient of a chart's background | +| backgroundGradientToOpacity | Number | Defines the second color opacity in the linear gradient of a chart's background | +| fillShadowGradientFrom | string | Defines the first color in the linear gradient of the area under data (can also be specified as `fillShadowGradient`) | +| fillShadowGradientFromOpacity | Number | Defines the first color opacity in the linear gradient of the area under data (can also be specified as `fillShadowGradientOpacity`) | +| fillShadowGradientFromOffset | Number | Defines the first color offset (0-1) in the linear gradient of the area under data | +| fillShadowGradientTo | string | Defines the second color in the linear gradient of the area under data | +| fillShadowGradientToOpacity | Number | Defines the second color opacity in the linear gradient of the area under data | +| fillShadowGradientToOffset | Number | Defines the second color offset (0-1) in the linear gradient of the area under data | +| useShadowColorFromDataset | Boolean | Defines the option to use color from dataset to each chart data. Default is false | +| color | function => string | Defines the base color function that is used to calculate colors of labels and sectors used in a chart | +| strokeWidth | Number | Defines the base stroke width in a chart | +| barPercentage | Number | Defines the percent (0-1) of the available width each bar width in a chart | +| barRadius | Number | Defines the radius of each bar | +| propsForBackgroundLines | props | Override styles of the background lines, refer to react-native-svg's Line documentation | +| propsForLabels | props | Override styles of the labels, refer to react-native-svg's Text documentation | +| propsForVerticalLabels | props | Override styles of vertical labels, refer to react-native-svg's Text documentation | +| propsForHorizontalLabels | props | Override styles of horizontal labels, refer to react-native-svg's Text documentation | ## Responsive charts diff --git a/dist/AbstractChart.d.ts b/dist/AbstractChart.d.ts new file mode 100644 index 00000000..f56a03b7 --- /dev/null +++ b/dist/AbstractChart.d.ts @@ -0,0 +1,338 @@ +import React, { Component } from "react"; +import { ChartConfig, Dataset, PartialBy } from "./HelperTypes"; +export interface AbstractChartProps { + fromZero?: boolean; + fromNumber?: number; + chartConfig?: AbstractChartConfig; + yAxisLabel?: string; + yAxisSuffix?: string; + yLabelsOffset?: number; + yAxisInterval?: number; + xAxisLabel?: string; + xLabelsOffset?: number; + hidePointsAtIndex?: number[]; +} +export interface AbstractChartConfig extends ChartConfig { + count?: number; + data?: Dataset[]; + width?: number; + height?: number; + paddingTop?: number; + paddingRight?: number; + horizontalLabelRotation?: number; + formatYLabel?: (yLabel: string) => string; + labels?: string[]; + horizontalOffset?: number; + stackedBar?: boolean; + verticalLabelRotation?: number; + formatXLabel?: (xLabel: string) => string; + verticalLabelsHeightPercentage?: number; + formatTopBarValue?: (topBarValue: number) => string | number; +} +export type AbstractChartState = {}; +export declare const DEFAULT_X_LABELS_HEIGHT_PERCENTAGE = 0.75; +declare class AbstractChart extends Component { + calcScaler: (data: number[]) => number; + calcBaseHeight: (data: number[], height: number) => number; + calcHeight: (val: number, data: number[], height: number) => number; + getPropsForBackgroundLines(): { + stroke: string; + strokeDasharray: string; + strokeWidth: number; + }; + getPropsForLabels(): { + children?: React.ReactNode; + x?: import("react-native-svg").NumberArray; + y?: import("react-native-svg").NumberArray; + dx?: import("react-native-svg").NumberArray; + dy?: import("react-native-svg").NumberArray; + rotate?: import("react-native-svg").NumberArray; + opacity?: import("react-native-svg").NumberProp; + inlineSize?: import("react-native-svg").NumberProp; + alignmentBaseline?: import("react-native-svg").AlignmentBaseline; + baselineShift?: import("react-native-svg").BaselineShift; + verticalAlign?: import("react-native-svg").NumberProp; + lengthAdjust?: import("react-native-svg").LengthAdjust; + textLength?: import("react-native-svg").NumberProp; + fontData?: null | { + [name: string]: unknown; + }; + fontFeatureSettings?: string; + color?: import("react-native").ColorValue; + fill: import("react-native").ColorValue; + fillOpacity?: import("react-native-svg").NumberProp; + fillRule?: import("react-native-svg").FillRule; + stroke?: import("react-native").ColorValue; + strokeWidth?: import("react-native-svg").NumberProp; + strokeOpacity?: import("react-native-svg").NumberProp; + strokeDasharray?: ReadonlyArray | import("react-native-svg").NumberProp; + strokeDashoffset?: import("react-native-svg").NumberProp; + strokeLinecap?: import("react-native-svg").Linecap; + strokeLinejoin?: import("react-native-svg").Linejoin; + strokeMiterlimit?: import("react-native-svg").NumberProp; + vectorEffect?: import("react-native-svg").VectorEffect; + clipRule?: import("react-native-svg").FillRule; + clipPath?: string; + translate?: import("react-native-svg").NumberArray; + translateX?: import("react-native-svg").NumberProp; + translateY?: import("react-native-svg").NumberProp; + origin?: import("react-native-svg").NumberArray; + originX?: import("react-native-svg").NumberProp; + originY?: import("react-native-svg").NumberProp; + scale?: import("react-native-svg").NumberArray; + scaleX?: import("react-native-svg").NumberProp; + scaleY?: import("react-native-svg").NumberProp; + skew?: import("react-native-svg").NumberArray; + skewX?: import("react-native-svg").NumberProp; + skewY?: import("react-native-svg").NumberProp; + rotation?: import("react-native-svg").NumberProp; + transform?: import("react-native-svg").ColumnMajorTransformMatrix | string | import("react-native").TransformsStyle["transform"]; + pointerEvents?: "box-none" | "none" | "box-only" | "auto"; + onStartShouldSetResponder?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + onMoveShouldSetResponder?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + onResponderEnd?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderGrant?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderReject?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderMove?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderRelease?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderStart?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderTerminationRequest?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + onResponderTerminate?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onStartShouldSetResponderCapture?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + onMoveShouldSetResponderCapture?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + disabled?: boolean; + onPress?: (event: import("react-native").GestureResponderEvent) => void; + onPressIn?: (event: import("react-native").GestureResponderEvent) => void; + onPressOut?: (event: import("react-native").GestureResponderEvent) => void; + onLongPress?: (event: import("react-native").GestureResponderEvent) => void; + delayPressIn?: number; + delayPressOut?: number; + delayLongPress?: number; + id?: string; + marker?: string; + markerStart?: string; + markerMid?: string; + markerEnd?: string; + mask?: string; + filter?: string; + onLayout?: (event: import("react-native").LayoutChangeEvent) => void; + accessibilityLabel?: string; + accessible?: boolean; + testID?: string; + font?: import("react-native-svg").FontObject; + fontStyle?: import("react-native-svg").FontStyle; + fontVariant?: import("react-native-svg").FontVariant; + fontWeight?: import("react-native-svg").FontWeight; + fontStretch?: import("react-native-svg").FontStretch; + fontSize: import("react-native-svg").NumberProp; + fontFamily?: string; + textAnchor?: import("react-native-svg").TextAnchor; + textDecoration?: import("react-native-svg").TextDecoration; + letterSpacing?: import("react-native-svg").NumberProp; + wordSpacing?: import("react-native-svg").NumberProp; + kerning?: import("react-native-svg").NumberProp; + fontVariantLigatures?: import("react-native-svg").FontVariantLigatures; + fontVariationSettings?: string; + }; + getPropsForVerticalLabels(): { + children?: React.ReactNode; + x?: import("react-native-svg").NumberArray; + y?: import("react-native-svg").NumberArray; + dx?: import("react-native-svg").NumberArray; + dy?: import("react-native-svg").NumberArray; + rotate?: import("react-native-svg").NumberArray; + opacity?: import("react-native-svg").NumberProp; + inlineSize?: import("react-native-svg").NumberProp; + alignmentBaseline?: import("react-native-svg").AlignmentBaseline; + baselineShift?: import("react-native-svg").BaselineShift; + verticalAlign?: import("react-native-svg").NumberProp; + lengthAdjust?: import("react-native-svg").LengthAdjust; + textLength?: import("react-native-svg").NumberProp; + fontData?: null | { + [name: string]: unknown; + }; + fontFeatureSettings?: string; + color?: import("react-native").ColorValue; + fill: import("react-native").ColorValue; + fillOpacity?: import("react-native-svg").NumberProp; + fillRule?: import("react-native-svg").FillRule; + stroke?: import("react-native").ColorValue; + strokeWidth?: import("react-native-svg").NumberProp; + strokeOpacity?: import("react-native-svg").NumberProp; + strokeDasharray?: ReadonlyArray | import("react-native-svg").NumberProp; + strokeDashoffset?: import("react-native-svg").NumberProp; + strokeLinecap?: import("react-native-svg").Linecap; + strokeLinejoin?: import("react-native-svg").Linejoin; + strokeMiterlimit?: import("react-native-svg").NumberProp; + vectorEffect?: import("react-native-svg").VectorEffect; + clipRule?: import("react-native-svg").FillRule; + clipPath?: string; + translate?: import("react-native-svg").NumberArray; + translateX?: import("react-native-svg").NumberProp; + translateY?: import("react-native-svg").NumberProp; + origin?: import("react-native-svg").NumberArray; + originX?: import("react-native-svg").NumberProp; + originY?: import("react-native-svg").NumberProp; + scale?: import("react-native-svg").NumberArray; + scaleX?: import("react-native-svg").NumberProp; + scaleY?: import("react-native-svg").NumberProp; + skew?: import("react-native-svg").NumberArray; + skewX?: import("react-native-svg").NumberProp; + skewY?: import("react-native-svg").NumberProp; + rotation?: import("react-native-svg").NumberProp; + transform?: import("react-native-svg").ColumnMajorTransformMatrix | string | import("react-native").TransformsStyle["transform"]; + pointerEvents?: "box-none" | "none" | "box-only" | "auto"; + onStartShouldSetResponder?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + onMoveShouldSetResponder?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + onResponderEnd?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderGrant?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderReject?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderMove?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderRelease?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderStart?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderTerminationRequest?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + onResponderTerminate?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onStartShouldSetResponderCapture?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + onMoveShouldSetResponderCapture?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + disabled?: boolean; + onPress?: (event: import("react-native").GestureResponderEvent) => void; + onPressIn?: (event: import("react-native").GestureResponderEvent) => void; + onPressOut?: (event: import("react-native").GestureResponderEvent) => void; + onLongPress?: (event: import("react-native").GestureResponderEvent) => void; + delayPressIn?: number; + delayPressOut?: number; + delayLongPress?: number; + id?: string; + marker?: string; + markerStart?: string; + markerMid?: string; + markerEnd?: string; + mask?: string; + filter?: string; + onLayout?: (event: import("react-native").LayoutChangeEvent) => void; + accessibilityLabel?: string; + accessible?: boolean; + testID?: string; + font?: import("react-native-svg").FontObject; + fontStyle?: import("react-native-svg").FontStyle; + fontVariant?: import("react-native-svg").FontVariant; + fontWeight?: import("react-native-svg").FontWeight; + fontStretch?: import("react-native-svg").FontStretch; + fontSize?: import("react-native-svg").NumberProp; + fontFamily?: string; + textAnchor?: import("react-native-svg").TextAnchor; + textDecoration?: import("react-native-svg").TextDecoration; + letterSpacing?: import("react-native-svg").NumberProp; + wordSpacing?: import("react-native-svg").NumberProp; + kerning?: import("react-native-svg").NumberProp; + fontVariantLigatures?: import("react-native-svg").FontVariantLigatures; + fontVariationSettings?: string; + }; + getPropsForHorizontalLabels(): { + children?: React.ReactNode; + x?: import("react-native-svg").NumberArray; + y?: import("react-native-svg").NumberArray; + dx?: import("react-native-svg").NumberArray; + dy?: import("react-native-svg").NumberArray; + rotate?: import("react-native-svg").NumberArray; + opacity?: import("react-native-svg").NumberProp; + inlineSize?: import("react-native-svg").NumberProp; + alignmentBaseline?: import("react-native-svg").AlignmentBaseline; + baselineShift?: import("react-native-svg").BaselineShift; + verticalAlign?: import("react-native-svg").NumberProp; + lengthAdjust?: import("react-native-svg").LengthAdjust; + textLength?: import("react-native-svg").NumberProp; + fontData?: null | { + [name: string]: unknown; + }; + fontFeatureSettings?: string; + color?: import("react-native").ColorValue; + fill: import("react-native").ColorValue; + fillOpacity?: import("react-native-svg").NumberProp; + fillRule?: import("react-native-svg").FillRule; + stroke?: import("react-native").ColorValue; + strokeWidth?: import("react-native-svg").NumberProp; + strokeOpacity?: import("react-native-svg").NumberProp; + strokeDasharray?: ReadonlyArray | import("react-native-svg").NumberProp; + strokeDashoffset?: import("react-native-svg").NumberProp; + strokeLinecap?: import("react-native-svg").Linecap; + strokeLinejoin?: import("react-native-svg").Linejoin; + strokeMiterlimit?: import("react-native-svg").NumberProp; + vectorEffect?: import("react-native-svg").VectorEffect; + clipRule?: import("react-native-svg").FillRule; + clipPath?: string; + translate?: import("react-native-svg").NumberArray; + translateX?: import("react-native-svg").NumberProp; + translateY?: import("react-native-svg").NumberProp; + origin?: import("react-native-svg").NumberArray; + originX?: import("react-native-svg").NumberProp; + originY?: import("react-native-svg").NumberProp; + scale?: import("react-native-svg").NumberArray; + scaleX?: import("react-native-svg").NumberProp; + scaleY?: import("react-native-svg").NumberProp; + skew?: import("react-native-svg").NumberArray; + skewX?: import("react-native-svg").NumberProp; + skewY?: import("react-native-svg").NumberProp; + rotation?: import("react-native-svg").NumberProp; + transform?: import("react-native-svg").ColumnMajorTransformMatrix | string | import("react-native").TransformsStyle["transform"]; + pointerEvents?: "box-none" | "none" | "box-only" | "auto"; + onStartShouldSetResponder?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + onMoveShouldSetResponder?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + onResponderEnd?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderGrant?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderReject?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderMove?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderRelease?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderStart?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onResponderTerminationRequest?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + onResponderTerminate?: ((event: import("react-native").GestureResponderEvent) => void) | undefined; + onStartShouldSetResponderCapture?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + onMoveShouldSetResponderCapture?: ((event: import("react-native").GestureResponderEvent) => boolean) | undefined; + disabled?: boolean; + onPress?: (event: import("react-native").GestureResponderEvent) => void; + onPressIn?: (event: import("react-native").GestureResponderEvent) => void; + onPressOut?: (event: import("react-native").GestureResponderEvent) => void; + onLongPress?: (event: import("react-native").GestureResponderEvent) => void; + delayPressIn?: number; + delayPressOut?: number; + delayLongPress?: number; + id?: string; + marker?: string; + markerStart?: string; + markerMid?: string; + markerEnd?: string; + mask?: string; + filter?: string; + onLayout?: (event: import("react-native").LayoutChangeEvent) => void; + accessibilityLabel?: string; + accessible?: boolean; + testID?: string; + font?: import("react-native-svg").FontObject; + fontStyle?: import("react-native-svg").FontStyle; + fontVariant?: import("react-native-svg").FontVariant; + fontWeight?: import("react-native-svg").FontWeight; + fontStretch?: import("react-native-svg").FontStretch; + fontSize?: import("react-native-svg").NumberProp; + fontFamily?: string; + textAnchor?: import("react-native-svg").TextAnchor; + textDecoration?: import("react-native-svg").TextDecoration; + letterSpacing?: import("react-native-svg").NumberProp; + wordSpacing?: import("react-native-svg").NumberProp; + kerning?: import("react-native-svg").NumberProp; + fontVariantLigatures?: import("react-native-svg").FontVariantLigatures; + fontVariationSettings?: string; + }; + renderHorizontalLines: (config: any) => React.JSX.Element[]; + renderHorizontalLine: (config: any) => React.JSX.Element; + renderHorizontalLabels: (config: Omit & { + data: number[]; + }) => React.JSX.Element[]; + renderVerticalLabels: ({ labels, width, height, paddingRight, paddingTop, horizontalOffset, stackedBar, verticalLabelRotation, formatXLabel, verticalLabelsHeightPercentage }: Pick) => React.JSX.Element[]; + renderVerticalLines: ({ data, width, height, paddingTop, paddingRight, verticalLabelsHeightPercentage }: Omit, "data"> & { + data: number[]; + }) => React.JSX.Element[]; + renderVerticalLine: ({ height, paddingTop, paddingRight, verticalLabelsHeightPercentage }: Pick) => React.JSX.Element; + renderDefs: (config: Pick, "width" | "height" | "backgroundGradientFrom" | "backgroundGradientTo" | "useShadowColorFromDataset" | "data" | "backgroundGradientFromOpacity" | "backgroundGradientToOpacity" | "fillShadowGradient" | "fillShadowGradientOpacity" | "fillShadowGradientFrom" | "fillShadowGradientFromOpacity" | "fillShadowGradientFromOffset" | "fillShadowGradientTo" | "fillShadowGradientToOpacity" | "fillShadowGradientToOffset">) => React.JSX.Element; +} +export default AbstractChart; +//# sourceMappingURL=AbstractChart.d.ts.map \ No newline at end of file diff --git a/dist/AbstractChart.d.ts.map b/dist/AbstractChart.d.ts.map new file mode 100644 index 00000000..7bed16ce --- /dev/null +++ b/dist/AbstractChart.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"AbstractChart.d.ts","sourceRoot":"","sources":["../src/AbstractChart.tsx"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/dist/AbstractChart.js b/dist/AbstractChart.js new file mode 100644 index 00000000..f3a455c4 --- /dev/null +++ b/dist/AbstractChart.js @@ -0,0 +1,232 @@ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { + if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i); + ar[i] = from[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from)); +}; +import React, { Component } from "react"; +import { Defs, Line, LinearGradient, Stop, Text } from "react-native-svg"; +export var DEFAULT_X_LABELS_HEIGHT_PERCENTAGE = 0.75; +var AbstractChart = /** @class */ (function (_super) { + __extends(AbstractChart, _super); + function AbstractChart() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.calcScaler = function (data) { + if (_this.props.fromZero && _this.props.fromNumber) { + return Math.max.apply(Math, __spreadArray(__spreadArray([], data, false), [_this.props.fromNumber], false)) - Math.min.apply(Math, __spreadArray(__spreadArray([], data, false), [0], false)) || 1; + } + else if (_this.props.fromZero) { + return Math.max.apply(Math, __spreadArray(__spreadArray([], data, false), [0], false)) - Math.min.apply(Math, __spreadArray(__spreadArray([], data, false), [0], false)) || 1; + } + else if (_this.props.fromNumber) { + return (Math.max.apply(Math, __spreadArray(__spreadArray([], data, false), [_this.props.fromNumber], false)) - Math.min.apply(Math, __spreadArray(__spreadArray([], data, false), [_this.props.fromNumber], false)) || 1); + } + else { + return Math.max.apply(Math, data) - Math.min.apply(Math, data) || 1; + } + }; + _this.calcBaseHeight = function (data, height) { + var min = Math.min.apply(Math, data); + var max = Math.max.apply(Math, data); + if (min >= 0 && max >= 0) { + return height; + } + else if (min < 0 && max <= 0) { + return 0; + } + else if (min < 0 && max > 0) { + return (height * max) / _this.calcScaler(data); + } + }; + _this.calcHeight = function (val, data, height) { + var max = Math.max.apply(Math, data); + var min = Math.min.apply(Math, data); + if (min < 0 && max > 0) { + return height * (val / _this.calcScaler(data)); + } + else if (min >= 0 && max >= 0) { + return _this.props.fromZero + ? height * (val / _this.calcScaler(data)) + : height * ((val - min) / _this.calcScaler(data)); + } + else if (min < 0 && max <= 0) { + return _this.props.fromZero + ? height * (val / _this.calcScaler(data)) + : height * ((val - max) / _this.calcScaler(data)); + } + }; + _this.renderHorizontalLines = function (config) { + var count = config.count, width = config.width, height = config.height, paddingTop = config.paddingTop, paddingRight = config.paddingRight, _a = config.verticalLabelsHeightPercentage, verticalLabelsHeightPercentage = _a === void 0 ? DEFAULT_X_LABELS_HEIGHT_PERCENTAGE : _a; + var basePosition = height * verticalLabelsHeightPercentage; + return __spreadArray([], new Array(count + 1), true).map(function (_, i) { + var y = (basePosition / count) * i + paddingTop; + return (); + }); + }; + _this.renderHorizontalLine = function (config) { + var width = config.width, height = config.height, paddingTop = config.paddingTop, paddingRight = config.paddingRight, _a = config.verticalLabelsHeightPercentage, verticalLabelsHeightPercentage = _a === void 0 ? DEFAULT_X_LABELS_HEIGHT_PERCENTAGE : _a; + return (); + }; + _this.renderHorizontalLabels = function (config) { + var count = config.count, data = config.data, height = config.height, paddingTop = config.paddingTop, paddingRight = config.paddingRight, _a = config.horizontalLabelRotation, horizontalLabelRotation = _a === void 0 ? 0 : _a, _b = config.decimalPlaces, decimalPlaces = _b === void 0 ? 2 : _b, _c = config.formatYLabel, formatYLabel = _c === void 0 ? function (yLabel) { return yLabel; } : _c, _d = config.verticalLabelsHeightPercentage, verticalLabelsHeightPercentage = _d === void 0 ? DEFAULT_X_LABELS_HEIGHT_PERCENTAGE : _d; + var _e = _this.props, _f = _e.yAxisLabel, yAxisLabel = _f === void 0 ? "" : _f, _g = _e.yAxisSuffix, yAxisSuffix = _g === void 0 ? "" : _g, _h = _e.yLabelsOffset, yLabelsOffset = _h === void 0 ? 12 : _h; + return new Array(count === 1 ? 1 : count + 1).fill(1).map(function (_, i) { + var yLabel = String(i * count); + if (count === 1) { + yLabel = "".concat(yAxisLabel).concat(formatYLabel(data[0].toFixed(decimalPlaces))).concat(yAxisSuffix); + } + else { + var label = _this.props.fromZero + ? (_this.calcScaler(data) / count) * i + Math.min.apply(Math, __spreadArray(__spreadArray([], data, false), [0], false)) + : (_this.calcScaler(data) / count) * i + Math.min.apply(Math, data); + yLabel = "".concat(yAxisLabel).concat(formatYLabel(label.toFixed(decimalPlaces))).concat(yAxisSuffix); + } + var basePosition = height * verticalLabelsHeightPercentage; + var x = paddingRight - yLabelsOffset; + var y = count === 1 && _this.props.fromZero + ? paddingTop + 4 + : height * verticalLabelsHeightPercentage - + (basePosition / count) * i + + paddingTop; + return ( + {yLabel} + ); + }); + }; + _this.renderVerticalLabels = function (_a) { + var _b = _a.labels, labels = _b === void 0 ? [] : _b, width = _a.width, height = _a.height, paddingRight = _a.paddingRight, paddingTop = _a.paddingTop, _c = _a.horizontalOffset, horizontalOffset = _c === void 0 ? 0 : _c, _d = _a.stackedBar, stackedBar = _d === void 0 ? false : _d, _e = _a.verticalLabelRotation, verticalLabelRotation = _e === void 0 ? 0 : _e, _f = _a.formatXLabel, formatXLabel = _f === void 0 ? function (xLabel) { return xLabel; } : _f, _g = _a.verticalLabelsHeightPercentage, verticalLabelsHeightPercentage = _g === void 0 ? DEFAULT_X_LABELS_HEIGHT_PERCENTAGE : _g; + var _h = _this.props, _j = _h.xAxisLabel, xAxisLabel = _j === void 0 ? "" : _j, _k = _h.xLabelsOffset, xLabelsOffset = _k === void 0 ? 0 : _k, _l = _h.hidePointsAtIndex, hidePointsAtIndex = _l === void 0 ? [] : _l; + var fontSize = 12; + var fac = 1; + if (stackedBar) { + fac = 0.71; + } + return labels.map(function (label, i) { + if (hidePointsAtIndex.includes(i)) { + return null; + } + var x = (((width - paddingRight) / labels.length) * i + + paddingRight + + horizontalOffset) * + fac; + var y = height * verticalLabelsHeightPercentage + + paddingTop + + fontSize * 2 + + xLabelsOffset; + return ( + {"".concat(formatXLabel(label)).concat(xAxisLabel)} + ); + }); + }; + _this.renderVerticalLines = function (_a) { + var data = _a.data, width = _a.width, height = _a.height, paddingTop = _a.paddingTop, paddingRight = _a.paddingRight, _b = _a.verticalLabelsHeightPercentage, verticalLabelsHeightPercentage = _b === void 0 ? DEFAULT_X_LABELS_HEIGHT_PERCENTAGE : _b; + var _c = _this.props.yAxisInterval, yAxisInterval = _c === void 0 ? 1 : _c; + return __spreadArray([], new Array(Math.ceil(data.length / yAxisInterval)), true).map(function (_, i) { + return (); + }); + }; + _this.renderVerticalLine = function (_a) { + var height = _a.height, paddingTop = _a.paddingTop, paddingRight = _a.paddingRight, _b = _a.verticalLabelsHeightPercentage, verticalLabelsHeightPercentage = _b === void 0 ? DEFAULT_X_LABELS_HEIGHT_PERCENTAGE : _b; + return (); + }; + _this.renderDefs = function (config) { + var width = config.width, height = config.height, backgroundGradientFrom = config.backgroundGradientFrom, backgroundGradientTo = config.backgroundGradientTo, useShadowColorFromDataset = config.useShadowColorFromDataset, data = config.data; + var fromOpacity = config.hasOwnProperty("backgroundGradientFromOpacity") + ? config.backgroundGradientFromOpacity + : 1.0; + var toOpacity = config.hasOwnProperty("backgroundGradientToOpacity") + ? config.backgroundGradientToOpacity + : 1.0; + var fillShadowGradient = config.hasOwnProperty("fillShadowGradient") + ? config.fillShadowGradient + : _this.props.chartConfig.color(1.0); + var fillShadowGradientOpacity = config.hasOwnProperty("fillShadowGradientOpacity") + ? config.fillShadowGradientOpacity + : 0.1; + var fillShadowGradientFrom = config.hasOwnProperty("fillShadowGradientFrom") + ? config.fillShadowGradientFrom + : fillShadowGradient; + var fillShadowGradientFromOpacity = config.hasOwnProperty("fillShadowGradientFromOpacity") + ? config.fillShadowGradientFromOpacity + : fillShadowGradientOpacity; + var fillShadowGradientFromOffset = config.hasOwnProperty("fillShadowGradientFromOffset") + ? config.fillShadowGradientFromOffset + : 0; + var fillShadowGradientTo = config.hasOwnProperty("fillShadowGradientTo") + ? config.fillShadowGradientTo + : _this.props.chartConfig.color(1.0); + var fillShadowGradientToOpacity = config.hasOwnProperty("fillShadowGradientToOpacity") + ? config.fillShadowGradientToOpacity + : 0.1; + var fillShadowGradientToOffset = config.hasOwnProperty("fillShadowGradientToOffset") + ? config.fillShadowGradientToOffset + : 1; + return ( + + + + + {useShadowColorFromDataset ? (data.map(function (dataset, index) { return ( + + + ); })) : ( + + + )} + ); + }; + return _this; + } + AbstractChart.prototype.getPropsForBackgroundLines = function () { + var _a = this.props.chartConfig.propsForBackgroundLines, propsForBackgroundLines = _a === void 0 ? {} : _a; + return __assign({ stroke: this.props.chartConfig.color(0.2), strokeDasharray: "5, 10", strokeWidth: 1 }, propsForBackgroundLines); + }; + AbstractChart.prototype.getPropsForLabels = function () { + var _a = this.props.chartConfig, _b = _a.propsForLabels, propsForLabels = _b === void 0 ? {} : _b, color = _a.color, _c = _a.labelColor, labelColor = _c === void 0 ? color : _c; + return __assign({ fontSize: 12, fill: labelColor(0.8) }, propsForLabels); + }; + AbstractChart.prototype.getPropsForVerticalLabels = function () { + var _a = this.props.chartConfig, _b = _a.propsForVerticalLabels, propsForVerticalLabels = _b === void 0 ? {} : _b, color = _a.color, _c = _a.labelColor, labelColor = _c === void 0 ? color : _c; + return __assign({ fill: labelColor(0.8) }, propsForVerticalLabels); + }; + AbstractChart.prototype.getPropsForHorizontalLabels = function () { + var _a = this.props.chartConfig, _b = _a.propsForHorizontalLabels, propsForHorizontalLabels = _b === void 0 ? {} : _b, color = _a.color, _c = _a.labelColor, labelColor = _c === void 0 ? color : _c; + return __assign({ fill: labelColor(0.8) }, propsForHorizontalLabels); + }; + return AbstractChart; +}(Component)); +export default AbstractChart; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AbstractChart.js","sourceRoot":"","sources":["../src/AbstractChart.tsx"],"names":[],"mappings":"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","sourcesContent":["import React, { Component } from \"react\";\nimport { Defs, Line, LinearGradient, Stop, Text } from \"react-native-svg\";\n\nimport { ChartConfig, Dataset, PartialBy } from \"./HelperTypes\";\n\nexport interface AbstractChartProps {\n  fromZero?: boolean;\n  fromNumber?: number;\n  chartConfig?: AbstractChartConfig;\n  yAxisLabel?: string;\n  yAxisSuffix?: string;\n  yLabelsOffset?: number;\n  yAxisInterval?: number;\n  xAxisLabel?: string;\n  xLabelsOffset?: number;\n  hidePointsAtIndex?: number[];\n}\n\nexport interface AbstractChartConfig extends ChartConfig {\n  count?: number;\n  data?: Dataset[];\n  width?: number;\n  height?: number;\n  paddingTop?: number;\n  paddingRight?: number;\n  horizontalLabelRotation?: number;\n  formatYLabel?: (yLabel: string) => string;\n  labels?: string[];\n  horizontalOffset?: number;\n  stackedBar?: boolean;\n  verticalLabelRotation?: number;\n  formatXLabel?: (xLabel: string) => string;\n  verticalLabelsHeightPercentage?: number;\n  formatTopBarValue?: (topBarValue: number) => string | number;\n}\n\nexport type AbstractChartState = {};\n\nexport const DEFAULT_X_LABELS_HEIGHT_PERCENTAGE = 0.75;\n\nclass AbstractChart<\n  IProps extends AbstractChartProps,\n  IState extends AbstractChartState\n> extends Component<AbstractChartProps & IProps, AbstractChartState & IState> {\n  calcScaler = (data: number[]) => {\n    if (this.props.fromZero && this.props.fromNumber) {\n      return Math.max(...data, this.props.fromNumber) - Math.min(...data, 0) || 1;\n    } else if (this.props.fromZero) {\n      return Math.max(...data, 0) - Math.min(...data, 0) || 1;\n    } else if (this.props.fromNumber) {\n      return (\n        Math.max(...data, this.props.fromNumber) -\n          Math.min(...data, this.props.fromNumber) || 1\n      );\n    } else {\n      return Math.max(...data) - Math.min(...data) || 1;\n    }\n  };\n\n  calcBaseHeight = (data: number[], height: number) => {\n    const min = Math.min(...data);\n    const max = Math.max(...data);\n    if (min >= 0 && max >= 0) {\n      return height;\n    } else if (min < 0 && max <= 0) {\n      return 0;\n    } else if (min < 0 && max > 0) {\n      return (height * max) / this.calcScaler(data);\n    }\n  };\n\n  calcHeight = (val: number, data: number[], height: number) => {\n    const max = Math.max(...data);\n    const min = Math.min(...data);\n\n    if (min < 0 && max > 0) {\n      return height * (val / this.calcScaler(data));\n    } else if (min >= 0 && max >= 0) {\n      return this.props.fromZero\n        ? height * (val / this.calcScaler(data))\n        : height * ((val - min) / this.calcScaler(data));\n    } else if (min < 0 && max <= 0) {\n      return this.props.fromZero\n        ? height * (val / this.calcScaler(data))\n        : height * ((val - max) / this.calcScaler(data));\n    }\n  };\n\n  getPropsForBackgroundLines() {\n    const { propsForBackgroundLines = {} } = this.props.chartConfig;\n    return {\n      stroke: this.props.chartConfig.color(0.2),\n      strokeDasharray: \"5, 10\",\n      strokeWidth: 1,\n      ...propsForBackgroundLines\n    };\n  }\n\n  getPropsForLabels() {\n    const {\n      propsForLabels = {},\n      color,\n      labelColor = color\n    } = this.props.chartConfig;\n    return {\n      fontSize: 12,\n      fill: labelColor(0.8),\n      ...propsForLabels\n    };\n  }\n\n  getPropsForVerticalLabels() {\n    const {\n      propsForVerticalLabels = {},\n      color,\n      labelColor = color\n    } = this.props.chartConfig;\n    return {\n      fill: labelColor(0.8),\n      ...propsForVerticalLabels\n    };\n  }\n\n  getPropsForHorizontalLabels() {\n    const {\n      propsForHorizontalLabels = {},\n      color,\n      labelColor = color\n    } = this.props.chartConfig;\n    return {\n      fill: labelColor(0.8),\n      ...propsForHorizontalLabels\n    };\n  }\n\n  renderHorizontalLines = config => {\n    const {\n      count,\n      width,\n      height,\n      paddingTop,\n      paddingRight,\n      verticalLabelsHeightPercentage = DEFAULT_X_LABELS_HEIGHT_PERCENTAGE\n    } = config;\n    const basePosition = height * verticalLabelsHeightPercentage;\n\n    return [...new Array(count + 1)].map((_, i) => {\n      const y = (basePosition / count) * i + paddingTop;\n      return (\n        <Line\n          key={Math.random()}\n          x1={paddingRight}\n          y1={y}\n          x2={width}\n          y2={y}\n          {...this.getPropsForBackgroundLines()}\n        />\n      );\n    });\n  };\n\n  renderHorizontalLine = config => {\n    const {\n      width,\n      height,\n      paddingTop,\n      paddingRight,\n      verticalLabelsHeightPercentage = DEFAULT_X_LABELS_HEIGHT_PERCENTAGE\n    } = config;\n    return (\n      <Line\n        key={Math.random()}\n        x1={paddingRight}\n        y1={height * verticalLabelsHeightPercentage + paddingTop}\n        x2={width}\n        y2={height * verticalLabelsHeightPercentage + paddingTop}\n        {...this.getPropsForBackgroundLines()}\n      />\n    );\n  };\n\n  renderHorizontalLabels = (\n    config: Omit<AbstractChartConfig, \"data\"> & { data: number[] }\n  ) => {\n    const {\n      count,\n      data,\n      height,\n      paddingTop,\n      paddingRight,\n      horizontalLabelRotation = 0,\n      decimalPlaces = 2,\n      formatYLabel = (yLabel: string) => yLabel,\n      verticalLabelsHeightPercentage = DEFAULT_X_LABELS_HEIGHT_PERCENTAGE\n    } = config;\n\n    const {\n      yAxisLabel = \"\",\n      yAxisSuffix = \"\",\n      yLabelsOffset = 12\n    } = this.props;\n    return new Array(count === 1 ? 1 : count + 1).fill(1).map((_, i) => {\n      let yLabel = String(i * count);\n\n      if (count === 1) {\n        yLabel = `${yAxisLabel}${formatYLabel(\n          data[0].toFixed(decimalPlaces)\n        )}${yAxisSuffix}`;\n      } else {\n        const label = this.props.fromZero\n          ? (this.calcScaler(data) / count) * i + Math.min(...data, 0)\n          : (this.calcScaler(data) / count) * i + Math.min(...data);\n        yLabel = `${yAxisLabel}${formatYLabel(\n          label.toFixed(decimalPlaces)\n        )}${yAxisSuffix}`;\n      }\n\n      const basePosition = height * verticalLabelsHeightPercentage;\n      const x = paddingRight - yLabelsOffset;\n      const y =\n        count === 1 && this.props.fromZero\n          ? paddingTop + 4\n          : height * verticalLabelsHeightPercentage -\n            (basePosition / count) * i +\n            paddingTop;\n      return (\n        <Text\n          rotation={horizontalLabelRotation}\n          origin={`${x}, ${y}`}\n          key={Math.random()}\n          x={x}\n          textAnchor=\"end\"\n          y={y}\n          {...this.getPropsForLabels()}\n          {...this.getPropsForHorizontalLabels()}\n        >\n          {yLabel}\n        </Text>\n      );\n    });\n  };\n\n  renderVerticalLabels = ({\n    labels = [],\n    width,\n    height,\n    paddingRight,\n    paddingTop,\n    horizontalOffset = 0,\n    stackedBar = false,\n    verticalLabelRotation = 0,\n    formatXLabel = xLabel => xLabel,\n    verticalLabelsHeightPercentage = DEFAULT_X_LABELS_HEIGHT_PERCENTAGE\n  }: Pick<\n    AbstractChartConfig,\n    | \"labels\"\n    | \"width\"\n    | \"height\"\n    | \"paddingRight\"\n    | \"paddingTop\"\n    | \"horizontalOffset\"\n    | \"stackedBar\"\n    | \"verticalLabelRotation\"\n    | \"formatXLabel\"\n    | \"verticalLabelsHeightPercentage\"\n  >) => {\n    const {\n      xAxisLabel = \"\",\n      xLabelsOffset = 0,\n      hidePointsAtIndex = []\n    } = this.props;\n\n    const fontSize = 12;\n\n    let fac = 1;\n    if (stackedBar) {\n      fac = 0.71;\n    }\n\n    return labels.map((label, i) => {\n      if (hidePointsAtIndex.includes(i)) {\n        return null;\n      }\n\n      const x =\n        (((width - paddingRight) / labels.length) * i +\n          paddingRight +\n          horizontalOffset) *\n        fac;\n\n      const y =\n        height * verticalLabelsHeightPercentage +\n        paddingTop +\n        fontSize * 2 +\n        xLabelsOffset;\n\n      return (\n        <Text\n          origin={`${x}, ${y}`}\n          rotation={verticalLabelRotation}\n          key={Math.random()}\n          x={x}\n          y={y}\n          textAnchor={verticalLabelRotation === 0 ? \"middle\" : \"start\"}\n          {...this.getPropsForLabels()}\n          {...this.getPropsForVerticalLabels()}\n        >\n          {`${formatXLabel(label)}${xAxisLabel}`}\n        </Text>\n      );\n    });\n  };\n\n  renderVerticalLines = ({\n    data,\n    width,\n    height,\n    paddingTop,\n    paddingRight,\n    verticalLabelsHeightPercentage = DEFAULT_X_LABELS_HEIGHT_PERCENTAGE\n  }: Omit<\n    Pick<\n      AbstractChartConfig,\n      | \"data\"\n      | \"width\"\n      | \"height\"\n      | \"paddingRight\"\n      | \"paddingTop\"\n      | \"verticalLabelsHeightPercentage\"\n    >,\n    \"data\"\n  > & { data: number[] }) => {\n    const { yAxisInterval = 1 } = this.props;\n\n    return [...new Array(Math.ceil(data.length / yAxisInterval))].map(\n      (_, i) => {\n        return (\n          <Line\n            key={Math.random()}\n            x1={Math.floor(\n              ((width - paddingRight) / (data.length / yAxisInterval)) * i +\n                paddingRight\n            )}\n            y1={0}\n            x2={Math.floor(\n              ((width - paddingRight) / (data.length / yAxisInterval)) * i +\n                paddingRight\n            )}\n            y2={height * verticalLabelsHeightPercentage + paddingTop}\n            {...this.getPropsForBackgroundLines()}\n          />\n        );\n      }\n    );\n  };\n\n  renderVerticalLine = ({\n    height,\n    paddingTop,\n    paddingRight,\n    verticalLabelsHeightPercentage = DEFAULT_X_LABELS_HEIGHT_PERCENTAGE\n  }: Pick<\n    AbstractChartConfig,\n    \"height\" | \"paddingRight\" | \"paddingTop\" | \"verticalLabelsHeightPercentage\"\n  >) => (\n    <Line\n      key={Math.random()}\n      x1={Math.floor(paddingRight)}\n      y1={0}\n      x2={Math.floor(paddingRight)}\n      y2={height * verticalLabelsHeightPercentage + paddingTop}\n      {...this.getPropsForBackgroundLines()}\n    />\n  );\n\n  renderDefs = (\n    config: Pick<\n      PartialBy<\n        AbstractChartConfig,\n        | \"backgroundGradientFromOpacity\"\n        | \"backgroundGradientToOpacity\"\n        | \"fillShadowGradient\"\n        | \"fillShadowGradientOpacity\"\n        | \"fillShadowGradientFrom\"\n        | \"fillShadowGradientFromOpacity\"\n        | \"fillShadowGradientFromOffset\"\n        | \"fillShadowGradientTo\"\n        | \"fillShadowGradientToOpacity\"\n        | \"fillShadowGradientToOffset\"\n      >,\n      | \"width\"\n      | \"height\"\n      | \"backgroundGradientFrom\"\n      | \"backgroundGradientTo\"\n      | \"useShadowColorFromDataset\"\n      | \"data\"\n      | \"backgroundGradientFromOpacity\"\n      | \"backgroundGradientToOpacity\"\n      | \"fillShadowGradient\"\n      | \"fillShadowGradientOpacity\"\n      | \"fillShadowGradientFrom\"\n      | \"fillShadowGradientFromOpacity\"\n      | \"fillShadowGradientFromOffset\"\n      | \"fillShadowGradientTo\"\n      | \"fillShadowGradientToOpacity\"\n      | \"fillShadowGradientToOffset\"\n    >\n  ) => {\n    const {\n      width,\n      height,\n      backgroundGradientFrom,\n      backgroundGradientTo,\n      useShadowColorFromDataset,\n      data\n    } = config;\n\n    const fromOpacity = config.hasOwnProperty(\"backgroundGradientFromOpacity\")\n      ? config.backgroundGradientFromOpacity\n      : 1.0;\n    const toOpacity = config.hasOwnProperty(\"backgroundGradientToOpacity\")\n      ? config.backgroundGradientToOpacity\n      : 1.0;\n\n    const fillShadowGradient = config.hasOwnProperty(\"fillShadowGradient\")\n      ? config.fillShadowGradient\n      : this.props.chartConfig.color(1.0);\n\n    const fillShadowGradientOpacity = config.hasOwnProperty(\n      \"fillShadowGradientOpacity\"\n    )\n      ? config.fillShadowGradientOpacity\n      : 0.1;\n\n    const fillShadowGradientFrom = config.hasOwnProperty(\n      \"fillShadowGradientFrom\"\n    )\n      ? config.fillShadowGradientFrom\n      : fillShadowGradient;\n\n    const fillShadowGradientFromOpacity = config.hasOwnProperty(\n      \"fillShadowGradientFromOpacity\"\n    )\n      ? config.fillShadowGradientFromOpacity\n      : fillShadowGradientOpacity;\n\n    const fillShadowGradientFromOffset = config.hasOwnProperty(\n      \"fillShadowGradientFromOffset\"\n    )\n      ? config.fillShadowGradientFromOffset\n      : 0;\n\n    const fillShadowGradientTo = config.hasOwnProperty(\"fillShadowGradientTo\")\n      ? config.fillShadowGradientTo\n      : this.props.chartConfig.color(1.0);\n\n    const fillShadowGradientToOpacity = config.hasOwnProperty(\n      \"fillShadowGradientToOpacity\"\n    )\n      ? config.fillShadowGradientToOpacity\n      : 0.1;\n\n    const fillShadowGradientToOffset = config.hasOwnProperty(\n      \"fillShadowGradientToOffset\"\n    )\n      ? config.fillShadowGradientToOffset\n      : 1;\n\n    return (\n      <Defs>\n        <LinearGradient\n          id=\"backgroundGradient\"\n          x1={0}\n          y1={height}\n          x2={width}\n          y2={0}\n          gradientUnits=\"userSpaceOnUse\"\n        >\n          <Stop\n            offset=\"0\"\n            stopColor={backgroundGradientFrom}\n            stopOpacity={fromOpacity}\n          />\n          <Stop\n            offset=\"1\"\n            stopColor={backgroundGradientTo}\n            stopOpacity={toOpacity}\n          />\n        </LinearGradient>\n        {useShadowColorFromDataset ? (\n          data.map((dataset, index) => (\n            <LinearGradient\n              id={`fillShadowGradientFrom_${index}`}\n              key={`${index}`}\n              x1={0}\n              y1={0}\n              x2={0}\n              y2={height}\n              gradientUnits=\"userSpaceOnUse\"\n            >\n              <Stop\n                offset={fillShadowGradientFromOffset}\n                stopColor={\n                  dataset.color ? dataset.color(1.0) : fillShadowGradientFrom\n                }\n                stopOpacity={fillShadowGradientFromOpacity}\n              />\n              <Stop\n                offset={fillShadowGradientToOffset}\n                stopColor={\n                  dataset.color\n                    ? dataset.color(fillShadowGradientFromOpacity)\n                    : fillShadowGradientFrom\n                }\n                stopOpacity={fillShadowGradientToOpacity || 0}\n              />\n            </LinearGradient>\n          ))\n        ) : (\n          <LinearGradient\n            id=\"fillShadowGradientFrom\"\n            x1={0}\n            y1={0}\n            x2={0}\n            y2={height}\n            gradientUnits=\"userSpaceOnUse\"\n          >\n            <Stop\n              offset={fillShadowGradientFromOffset}\n              stopColor={fillShadowGradientFrom}\n              stopOpacity={fillShadowGradientFromOpacity}\n            />\n            <Stop\n              offset={fillShadowGradientToOffset}\n              stopColor={fillShadowGradientTo || fillShadowGradientFrom}\n              stopOpacity={fillShadowGradientToOpacity || 0}\n            />\n          </LinearGradient>\n        )}\n      </Defs>\n    );\n  };\n}\n\nexport default AbstractChart;\n"]} \ No newline at end of file diff --git a/dist/BarChart.d.ts b/dist/BarChart.d.ts new file mode 100644 index 00000000..0eadd819 --- /dev/null +++ b/dist/BarChart.d.ts @@ -0,0 +1,53 @@ +import React from "react"; +import { ViewStyle } from "react-native"; +import AbstractChart, { AbstractChartConfig, AbstractChartProps } from "./AbstractChart"; +import { ChartData } from "./HelperTypes"; +export interface BarChartProps extends AbstractChartProps { + data: ChartData; + width: number; + height: number; + fromZero?: boolean; + withInnerLines?: boolean; + yAxisLabel: string; + yAxisSuffix: string; + chartConfig: AbstractChartConfig; + style?: Partial; + horizontalLabelRotation?: number; + verticalLabelRotation?: number; + /** + * Show vertical labels - default: True. + */ + withVerticalLabels?: boolean; + /** + * Show horizontal labels - default: True. + */ + withHorizontalLabels?: boolean; + /** + * The number of horizontal lines + */ + segments?: number; + showBarTops?: boolean; + showValuesOnTopOfBars?: boolean; + withCustomBarColorFromData?: boolean; + flatColor?: boolean; +} +type BarChartState = {}; +declare class BarChart extends AbstractChart { + getBarPercentage: () => number; + renderBars: ({ data, width, height, paddingTop, paddingRight, barRadius, withCustomBarColorFromData }: Pick, "width" | "height" | "paddingRight" | "paddingTop" | "barRadius"> & { + data: number[]; + withCustomBarColorFromData: boolean; + }) => React.JSX.Element[]; + renderBarTops: ({ data, width, height, paddingTop, paddingRight }: Pick, "width" | "height" | "paddingRight" | "paddingTop"> & { + data: number[]; + }) => React.JSX.Element[]; + renderColors: ({ data, flatColor }: Pick & { + flatColor: boolean; + }) => React.JSX.Element[]; + renderValuesOnTopOfBars: ({ data, width, height, paddingTop, paddingRight }: Pick, "width" | "height" | "paddingRight" | "paddingTop"> & { + data: number[]; + }) => React.JSX.Element[]; + render(): React.JSX.Element; +} +export default BarChart; +//# sourceMappingURL=BarChart.d.ts.map \ No newline at end of file diff --git a/dist/BarChart.d.ts.map b/dist/BarChart.d.ts.map new file mode 100644 index 00000000..561cd407 --- /dev/null +++ b/dist/BarChart.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"BarChart.d.ts","sourceRoot":"","sources":["../src/BarChart.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAW/C,OAAO,aAAa,EAAE,EACpB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAI1C,MAAM,WAAW,aAAc,SAAQ,kBAAkB;IACvD,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,mBAAmB,CAAC;IACjC,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC3B,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,SAAS,CAAC,EAAE,OAAO,CAAC;CAErB;AAED,KAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,gBAAgB,eAGd;IAEF,UAAU,GAAI,0FAQX,IAAI,CACL,IAAI,CAAC,mBAAmB,EAAE,MAAM,CAAC,EACjC,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,YAAY,GAAG,WAAW,CACjE,GAAG;QACF,IAAI,EAAE,MAAM,EAAE,CAAC;QACf,0BAA0B,EAAE,OAAO,CAAC;KACrC,yBA6BC;IAEF,aAAa,GAAI,mDAMd,IAAI,CACL,IAAI,CAAC,mBAAmB,EAAE,MAAM,CAAC,EACjC,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,YAAY,CACnD,GAAG;QACF,IAAI,EAAE,MAAM,EAAE,CAAC;KAChB,yBAqBC;IAEF,YAAY,GAAI,qBAGb,IAAI,CAAC,mBAAmB,EAAE,MAAM,CAAC,GAAG;QACrC,SAAS,EAAE,OAAO,CAAC;KACpB,yBA2BC;IAEF,uBAAuB,GAAI,mDAMxB,IAAI,CACL,IAAI,CAAC,mBAAmB,EAAE,MAAM,CAAC,EACjC,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,YAAY,CACnD,GAAG;QACF,IAAI,EAAE,MAAM,EAAE,CAAC;KAChB,yBAgCC;IAEF,MAAM;CA0HP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/BarChart.js b/dist/BarChart.js new file mode 100644 index 00000000..9c365c11 --- /dev/null +++ b/dist/BarChart.js @@ -0,0 +1,161 @@ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +import React from "react"; +import { View } from "react-native"; +import { Defs, G, LinearGradient, Rect, Stop, Svg, Text } from "react-native-svg"; +import AbstractChart from "./AbstractChart"; +var barWidth = 32; +var BarChart = /** @class */ (function (_super) { + __extends(BarChart, _super); + function BarChart() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.getBarPercentage = function () { + var _a = _this.props.chartConfig.barPercentage, barPercentage = _a === void 0 ? 1 : _a; + return barPercentage; + }; + _this.renderBars = function (_a) { + var data = _a.data, width = _a.width, height = _a.height, paddingTop = _a.paddingTop, paddingRight = _a.paddingRight, barRadius = _a.barRadius, withCustomBarColorFromData = _a.withCustomBarColorFromData; + var baseHeight = _this.calcBaseHeight(data, height); + return data.map(function (x, i) { + var barHeight = _this.calcHeight(x, data, height); + var barWidth = 32 * _this.getBarPercentage(); + return ( 0 ? baseHeight - barHeight : baseHeight) / 4) * 3 + + paddingTop} rx={barRadius} width={barWidth} height={(Math.abs(barHeight) / 4) * 3} fill={withCustomBarColorFromData + ? "url(#customColor_0_".concat(i, ")") + : "url(#fillShadowGradientFrom)"}/>); + }); + }; + _this.renderBarTops = function (_a) { + var data = _a.data, width = _a.width, height = _a.height, paddingTop = _a.paddingTop, paddingRight = _a.paddingRight; + var baseHeight = _this.calcBaseHeight(data, height); + return data.map(function (x, i) { + var barHeight = _this.calcHeight(x, data, height); + var barWidth = 32 * _this.getBarPercentage(); + return (); + }); + }; + _this.renderColors = function (_a) { + var data = _a.data, flatColor = _a.flatColor; + return data.map(function (dataset, index) { + var _a, _b; + return ( + {(_b = dataset.colors) === null || _b === void 0 ? void 0 : _b.map(function (color, colorIndex) { + var highOpacityColor = color(1.0); + var lowOpacityColor = color(0.1); + return ( + + {flatColor ? () : ()} + ); + })} + ); + }); + }; + _this.renderValuesOnTopOfBars = function (_a) { + var data = _a.data, width = _a.width, height = _a.height, paddingTop = _a.paddingTop, paddingRight = _a.paddingRight; + var baseHeight = _this.calcBaseHeight(data, height); + var renderLabel = function (value) { + if (_this.props.chartConfig.formatTopBarValue) { + return _this.props.chartConfig.formatTopBarValue(value); + } + else { + return value; + } + }; + return data.map(function (x, i) { + var barHeight = _this.calcHeight(x, data, height); + var barWidth = 32 * _this.getBarPercentage(); + return ( + {renderLabel(data[i])} + ); + }); + }; + return _this; + } + BarChart.prototype.render = function () { + var _a; + var _b = this.props, width = _b.width, height = _b.height, data = _b.data, _c = _b.style, style = _c === void 0 ? {} : _c, _d = _b.withHorizontalLabels, withHorizontalLabels = _d === void 0 ? true : _d, _e = _b.withVerticalLabels, withVerticalLabels = _e === void 0 ? true : _e, _f = _b.verticalLabelRotation, verticalLabelRotation = _f === void 0 ? 0 : _f, _g = _b.horizontalLabelRotation, horizontalLabelRotation = _g === void 0 ? 0 : _g, _h = _b.withInnerLines, withInnerLines = _h === void 0 ? true : _h, _j = _b.showBarTops, showBarTops = _j === void 0 ? true : _j, _k = _b.withCustomBarColorFromData, withCustomBarColorFromData = _k === void 0 ? false : _k, _l = _b.showValuesOnTopOfBars, showValuesOnTopOfBars = _l === void 0 ? false : _l, _m = _b.flatColor, flatColor = _m === void 0 ? false : _m, _o = _b.segments, segments = _o === void 0 ? 4 : _o; + var _p = style.borderRadius, borderRadius = _p === void 0 ? 0 : _p, _q = style.paddingTop, paddingTop = _q === void 0 ? 16 : _q, _r = style.paddingRight, paddingRight = _r === void 0 ? 64 : _r; + var config = { + width: width, + height: height, + verticalLabelRotation: verticalLabelRotation, + horizontalLabelRotation: horizontalLabelRotation, + barRadius: (this.props.chartConfig && this.props.chartConfig.barRadius) || 0, + decimalPlaces: (_a = (this.props.chartConfig && this.props.chartConfig.decimalPlaces)) !== null && _a !== void 0 ? _a : 2, + formatYLabel: (this.props.chartConfig && this.props.chartConfig.formatYLabel) || + function (label) { + return label; + }, + formatXLabel: (this.props.chartConfig && this.props.chartConfig.formatXLabel) || + function (label) { + return label; + } + }; + return ( + + {this.renderDefs(__assign(__assign({}, config), this.props.chartConfig))} + {this.renderColors(__assign(__assign({}, this.props.chartConfig), { flatColor: flatColor, data: this.props.data.datasets }))} + + + {withInnerLines + ? this.renderHorizontalLines(__assign(__assign({}, config), { count: segments, paddingTop: paddingTop })) + : null} + + + {withHorizontalLabels + ? this.renderHorizontalLabels(__assign(__assign({}, config), { count: segments, data: data.datasets[0].data, paddingTop: paddingTop, paddingRight: paddingRight })) + : null} + + + {withVerticalLabels + ? this.renderVerticalLabels(__assign(__assign({}, config), { labels: data.labels, paddingRight: paddingRight, paddingTop: paddingTop, horizontalOffset: barWidth * this.getBarPercentage() })) + : null} + + + {this.renderBars(__assign(__assign({}, config), { data: data.datasets[0].data, paddingTop: paddingTop, paddingRight: paddingRight, withCustomBarColorFromData: withCustomBarColorFromData }))} + + + {showValuesOnTopOfBars && + this.renderValuesOnTopOfBars(__assign(__assign({}, config), { data: data.datasets[0].data, paddingTop: paddingTop, paddingRight: paddingRight }))} + + + {showBarTops && + this.renderBarTops(__assign(__assign({}, config), { data: data.datasets[0].data, paddingTop: paddingTop, paddingRight: paddingRight }))} + + + ); + }; + return BarChart; +}(AbstractChart)); +export default BarChart; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BarChart.js","sourceRoot":"","sources":["../src/BarChart.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,IAAI,EAAa,MAAM,cAAc,CAAC;AAC/C,OAAO,EACL,IAAI,EACJ,CAAC,EACD,cAAc,EACd,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,IAAI,EACL,MAAM,kBAAkB,CAAC;AAE1B,OAAO,aAGN,MAAM,iBAAiB,CAAC;AAGzB,IAAM,QAAQ,GAAG,EAAE,CAAC;AAmCpB;IAAuB,4BAA2C;IAAlE;;QACE,sBAAgB,GAAG;YACT,IAAA,KAAsB,KAAI,CAAC,KAAK,CAAC,WAAW,cAA3B,EAAjB,aAAa,mBAAG,CAAC,KAAA,CAA4B;YACrD,OAAO,aAAa,CAAC;QACvB,CAAC,CAAC;QAEF,gBAAU,GAAG,UAAC,EAcb;gBAbC,IAAI,UAAA,EACJ,KAAK,WAAA,EACL,MAAM,YAAA,EACN,UAAU,gBAAA,EACV,YAAY,kBAAA,EACZ,SAAS,eAAA,EACT,0BAA0B,gCAAA;YAQ1B,IAAM,UAAU,GAAG,KAAI,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAErD,OAAO,IAAI,CAAC,GAAG,CAAC,UAAC,CAAC,EAAE,CAAC;gBACnB,IAAM,SAAS,GAAG,KAAI,CAAC,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;gBACnD,IAAM,QAAQ,GAAG,EAAE,GAAG,KAAI,CAAC,gBAAgB,EAAE,CAAC;gBAC9C,OAAO,CACL,CAAC,IAAI,CACH,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CACnB,CAAC,CAAC,CACA,YAAY;wBACZ,CAAC,CAAC,GAAG,CAAC,KAAK,GAAG,YAAY,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM;wBAC1C,QAAQ,GAAG,CACb,CAAC,CACD,CAAC,CAAC,CACA,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;wBAC/D,UACF,CAAC,CACD,EAAE,CAAC,CAAC,SAAS,CAAC,CACd,KAAK,CAAC,CAAC,QAAQ,CAAC,CAChB,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CACtC,IAAI,CAAC,CACH,0BAA0B;wBACxB,CAAC,CAAC,6BAAsB,CAAC,MAAG;wBAC5B,CAAC,CAAC,8BACN,CAAC,EACD,CACH,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;QAEF,mBAAa,GAAG,UAAC,EAWhB;gBAVC,IAAI,UAAA,EACJ,KAAK,WAAA,EACL,MAAM,YAAA,EACN,UAAU,gBAAA,EACV,YAAY,kBAAA;YAOZ,IAAM,UAAU,GAAG,KAAI,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAErD,OAAO,IAAI,CAAC,GAAG,CAAC,UAAC,CAAC,EAAE,CAAC;gBACnB,IAAM,SAAS,GAAG,KAAI,CAAC,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;gBACnD,IAAM,QAAQ,GAAG,EAAE,GAAG,KAAI,CAAC,gBAAgB,EAAE,CAAC;gBAC9C,OAAO,CACL,CAAC,IAAI,CACH,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CACnB,CAAC,CAAC,CACA,YAAY;wBACZ,CAAC,CAAC,GAAG,CAAC,KAAK,GAAG,YAAY,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM;wBAC1C,QAAQ,GAAG,CACb,CAAC,CACD,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,CACnD,KAAK,CAAC,CAAC,QAAQ,CAAC,CAChB,MAAM,CAAC,CAAC,CAAC,CAAC,CACV,IAAI,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EACxC,CACH,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;QAEF,kBAAY,GAAG,UAAC,EAKf;gBAJC,IAAI,UAAA,EACJ,SAAS,eAAA;YAIT,OAAO,IAAI,CAAC,GAAG,CAAC,UAAC,OAAO,EAAE,KAAK;;gBAAK,OAAA,CAClC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAA,OAAO,CAAC,GAAG,mCAAI,KAAK,CAAC,CAC9B;QAAA,CAAC,MAAA,OAAO,CAAC,MAAM,0CAAE,GAAG,CAAC,UAAC,KAAK,EAAE,UAAU;wBACrC,IAAM,gBAAgB,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;wBACpC,IAAM,eAAe,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;wBAEnC,OAAO,CACL,CAAC,cAAc,CACb,EAAE,CAAC,CAAC,sBAAe,KAAK,cAAI,UAAU,CAAE,CAAC,CACzC,GAAG,CAAC,CAAC,UAAG,KAAK,cAAI,UAAU,CAAE,CAAC,CAC9B,EAAE,CAAC,CAAC,CAAC,CAAC,CACN,EAAE,CAAC,CAAC,CAAC,CAAC,CACN,EAAE,CAAC,CAAC,CAAC,CAAC,CACN,EAAE,CAAC,CAAC,CAAC,CAAC,CAEN;cAAA,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,gBAAgB,CAAC,CAAC,WAAW,CAAC,GAAG,EAC7D;cAAA,CAAC,SAAS,CAAC,CAAC,CAAC,CACX,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,gBAAgB,CAAC,CAAC,WAAW,CAAC,GAAG,EAAG,CACjE,CAAC,CAAC,CAAC,CACA,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,eAAe,CAAC,CAAC,WAAW,CAAC,GAAG,EAAG,CAChE,CACL;YAAA,EAAE,cAAc,CAAC,CAClB,CAAC;oBACJ,CAAC,CAAC,CACJ;MAAA,EAAE,IAAI,CAAC,CACR,CAAA;aAAA,CAAC,CAAC;QACL,CAAC,CAAC;QAEF,6BAAuB,GAAG,UAAC,EAW1B;gBAVC,IAAI,UAAA,EACJ,KAAK,WAAA,EACL,MAAM,YAAA,EACN,UAAU,gBAAA,EACV,YAAY,kBAAA;YAOZ,IAAM,UAAU,GAAG,KAAI,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAErD,IAAM,WAAW,GAAG,UAAC,KAAa;gBAChC,IAAG,KAAI,CAAC,KAAK,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;oBAC5C,OAAO,KAAI,CAAC,KAAK,CAAC,WAAW,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAA;gBACxD,CAAC;qBACI,CAAC;oBACJ,OAAO,KAAK,CAAA;gBACd,CAAC;YACH,CAAC,CAAA;YACD,OAAO,IAAI,CAAC,GAAG,CAAC,UAAC,CAAC,EAAE,CAAC;gBACnB,IAAM,SAAS,GAAG,KAAI,CAAC,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;gBACnD,IAAM,QAAQ,GAAG,EAAE,GAAG,KAAI,CAAC,gBAAgB,EAAE,CAAC;gBAC9C,OAAO,CACL,CAAC,IAAI,CACH,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CACnB,CAAC,CAAC,CACA,YAAY;wBACZ,CAAC,CAAC,GAAG,CAAC,KAAK,GAAG,YAAY,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM;wBAC1C,QAAQ,GAAG,CAEb,CAAC,CACD,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC,CACvD,IAAI,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CACxC,QAAQ,CAAC,IAAI,CACb,UAAU,CAAC,QAAQ,CAEnB;UAAA,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CACvB;QAAA,EAAE,IAAI,CAAC,CACR,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;;IA4HJ,CAAC;IA1HC,yBAAM,GAAN;;QACQ,IAAA,KAeF,IAAI,CAAC,KAAK,EAdZ,KAAK,WAAA,EACL,MAAM,YAAA,EACN,IAAI,UAAA,EACJ,aAAU,EAAV,KAAK,mBAAG,EAAE,KAAA,EACV,4BAA2B,EAA3B,oBAAoB,mBAAG,IAAI,KAAA,EAC3B,0BAAyB,EAAzB,kBAAkB,mBAAG,IAAI,KAAA,EACzB,6BAAyB,EAAzB,qBAAqB,mBAAG,CAAC,KAAA,EACzB,+BAA2B,EAA3B,uBAAuB,mBAAG,CAAC,KAAA,EAC3B,sBAAqB,EAArB,cAAc,mBAAG,IAAI,KAAA,EACrB,mBAAkB,EAAlB,WAAW,mBAAG,IAAI,KAAA,EAClB,kCAAkC,EAAlC,0BAA0B,mBAAG,KAAK,KAAA,EAClC,6BAA6B,EAA7B,qBAAqB,mBAAG,KAAK,KAAA,EAC7B,iBAAiB,EAAjB,SAAS,mBAAG,KAAK,KAAA,EACjB,gBAAY,EAAZ,QAAQ,mBAAG,CAAC,KACA,CAAC;QAEP,IAAA,KAAyD,KAAK,aAA9C,EAAhB,YAAY,mBAAG,CAAC,KAAA,EAAE,KAAuC,KAAK,WAA7B,EAAf,UAAU,mBAAG,EAAE,KAAA,EAAE,KAAsB,KAAK,aAAV,EAAjB,YAAY,mBAAG,EAAE,KAAA,CAAW;QAEvE,IAAM,MAAM,GAAG;YACb,KAAK,OAAA;YACL,MAAM,QAAA;YACN,qBAAqB,uBAAA;YACrB,uBAAuB,yBAAA;YACvB,SAAS,EACP,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC;YACnE,aAAa,EACX,MAAA,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,aAAa,CAAC,mCAAI,CAAC;YACvE,YAAY,EACV,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,CAAC;gBAC/D,UAAU,KAAK;oBACb,OAAO,KAAK,CAAC;gBACf,CAAC;YACH,YAAY,EACV,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,CAAC;gBAC/D,UAAU,KAAK;oBACb,OAAO,KAAK,CAAC;gBACf,CAAC;SACJ,CAAC;QAEF,OAAO,CACL,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CACjB;QAAA,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAChC;UAAA,CAAC,IAAI,CAAC,UAAU,uBACX,MAAM,GACN,IAAI,CAAC,KAAK,CAAC,WAAW,EACzB,CACF;UAAA,CAAC,IAAI,CAAC,YAAY,uBACb,IAAI,CAAC,KAAK,CAAC,WAAW,KACzB,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,IAC9B,CACF;UAAA,CAAC,IAAI,CACH,KAAK,CAAC,MAAM,CACZ,MAAM,CAAC,CAAC,MAAM,CAAC,CACf,EAAE,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CACzB,EAAE,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CACzB,IAAI,CAAC,0BAA0B,EAEjC;UAAA,CAAC,CAAC,CACA;YAAA,CAAC,cAAc;gBACb,CAAC,CAAC,IAAI,CAAC,qBAAqB,uBACvB,MAAM,KACT,KAAK,EAAE,QAAQ,EACf,UAAU,YAAA,IACV;gBACF,CAAC,CAAC,IAAI,CACV;UAAA,EAAE,CAAC,CACH;UAAA,CAAC,CAAC,CACA;YAAA,CAAC,oBAAoB;gBACnB,CAAC,CAAC,IAAI,CAAC,sBAAsB,uBACxB,MAAM,KACT,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,EAC3B,UAAU,EAAE,UAAoB,EAChC,YAAY,EAAE,YAAsB,IACpC;gBACF,CAAC,CAAC,IAAI,CACV;UAAA,EAAE,CAAC,CACH;UAAA,CAAC,CAAC,CACA;YAAA,CAAC,kBAAkB;gBACjB,CAAC,CAAC,IAAI,CAAC,oBAAoB,uBACtB,MAAM,KACT,MAAM,EAAE,IAAI,CAAC,MAAM,EACnB,YAAY,EAAE,YAAsB,EACpC,UAAU,EAAE,UAAoB,EAChC,gBAAgB,EAAE,QAAQ,GAAG,IAAI,CAAC,gBAAgB,EAAE,IACpD;gBACF,CAAC,CAAC,IAAI,CACV;UAAA,EAAE,CAAC,CACH;UAAA,CAAC,CAAC,CACA;YAAA,CAAC,IAAI,CAAC,UAAU,uBACX,MAAM,KACT,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,EAC3B,UAAU,EAAE,UAAoB,EAChC,YAAY,EAAE,YAAsB,EACpC,0BAA0B,EAAE,0BAA0B,IACtD,CACJ;UAAA,EAAE,CAAC,CACH;UAAA,CAAC,CAAC,CACA;YAAA,CAAC,qBAAqB;gBACpB,IAAI,CAAC,uBAAuB,uBACvB,MAAM,KACT,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,EAC3B,UAAU,EAAE,UAAoB,EAChC,YAAY,EAAE,YAAsB,IACpC,CACN;UAAA,EAAE,CAAC,CACH;UAAA,CAAC,CAAC,CACA;YAAA,CAAC,WAAW;gBACV,IAAI,CAAC,aAAa,uBACb,MAAM,KACT,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,EAC3B,UAAU,EAAE,UAAoB,EAChC,YAAY,EAAE,YAAsB,IACpC,CACN;UAAA,EAAE,CAAC,CACL;QAAA,EAAE,GAAG,CACP;MAAA,EAAE,IAAI,CAAC,CACR,CAAC;IACJ,CAAC;IACH,eAAC;AAAD,CAAC,AA9RD,CAAuB,aAAa,GA8RnC;AAED,eAAe,QAAQ,CAAC","sourcesContent":["import React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport {\n  Defs,\n  G,\n  LinearGradient,\n  Rect,\n  Stop,\n  Svg,\n  Text\n} from \"react-native-svg\";\n\nimport AbstractChart, {\n  AbstractChartConfig,\n  AbstractChartProps\n} from \"./AbstractChart\";\nimport { ChartData } from \"./HelperTypes\";\n\nconst barWidth = 32;\n\nexport interface BarChartProps extends AbstractChartProps {\n  data: ChartData;\n  width: number;\n  height: number;\n  fromZero?: boolean;\n  withInnerLines?: boolean;\n  yAxisLabel: string;\n  yAxisSuffix: string;\n  chartConfig: AbstractChartConfig;\n  style?: Partial<ViewStyle>;\n  horizontalLabelRotation?: number;\n  verticalLabelRotation?: number;\n  /**\n   * Show vertical labels - default: True.\n   */\n  withVerticalLabels?: boolean;\n  /**\n   * Show horizontal labels - default: True.\n   */\n  withHorizontalLabels?: boolean;\n  /**\n   * The number of horizontal lines\n   */\n  segments?: number;\n  showBarTops?: boolean;\n  showValuesOnTopOfBars?: boolean;\n  withCustomBarColorFromData?: boolean;\n  flatColor?: boolean;\n  \n}\n\ntype BarChartState = {};\n\nclass BarChart extends AbstractChart<BarChartProps, BarChartState> {\n  getBarPercentage = () => {\n    const { barPercentage = 1 } = this.props.chartConfig;\n    return barPercentage;\n  };\n\n  renderBars = ({\n    data,\n    width,\n    height,\n    paddingTop,\n    paddingRight,\n    barRadius,\n    withCustomBarColorFromData\n  }: Pick<\n    Omit<AbstractChartConfig, \"data\">,\n    \"width\" | \"height\" | \"paddingRight\" | \"paddingTop\" | \"barRadius\"\n  > & {\n    data: number[];\n    withCustomBarColorFromData: boolean;\n  }) => {\n    const baseHeight = this.calcBaseHeight(data, height);\n\n    return data.map((x, i) => {\n      const barHeight = this.calcHeight(x, data, height);\n      const barWidth = 32 * this.getBarPercentage();\n      return (\n        <Rect\n          key={Math.random()}\n          x={\n            paddingRight +\n            (i * (width - paddingRight)) / data.length +\n            barWidth / 2\n          }\n          y={\n            ((barHeight > 0 ? baseHeight - barHeight : baseHeight) / 4) * 3 +\n            paddingTop\n          }\n          rx={barRadius}\n          width={barWidth}\n          height={(Math.abs(barHeight) / 4) * 3}\n          fill={\n            withCustomBarColorFromData\n              ? `url(#customColor_0_${i})`\n              : \"url(#fillShadowGradientFrom)\"\n          }\n        />\n      );\n    });\n  };\n\n  renderBarTops = ({\n    data,\n    width,\n    height,\n    paddingTop,\n    paddingRight\n  }: Pick<\n    Omit<AbstractChartConfig, \"data\">,\n    \"width\" | \"height\" | \"paddingRight\" | \"paddingTop\"\n  > & {\n    data: number[];\n  }) => {\n    const baseHeight = this.calcBaseHeight(data, height);\n\n    return data.map((x, i) => {\n      const barHeight = this.calcHeight(x, data, height);\n      const barWidth = 32 * this.getBarPercentage();\n      return (\n        <Rect\n          key={Math.random()}\n          x={\n            paddingRight +\n            (i * (width - paddingRight)) / data.length +\n            barWidth / 2\n          }\n          y={((baseHeight - barHeight) / 4) * 3 + paddingTop}\n          width={barWidth}\n          height={2}\n          fill={this.props.chartConfig.color(0.6)}\n        />\n      );\n    });\n  };\n\n  renderColors = ({\n    data,\n    flatColor\n  }: Pick<AbstractChartConfig, \"data\"> & {\n    flatColor: boolean;\n  }) => {\n    return data.map((dataset, index) => (\n      <Defs key={dataset.key ?? index}>\n        {dataset.colors?.map((color, colorIndex) => {\n          const highOpacityColor = color(1.0);\n          const lowOpacityColor = color(0.1);\n\n          return (\n            <LinearGradient\n              id={`customColor_${index}_${colorIndex}`}\n              key={`${index}_${colorIndex}`}\n              x1={0}\n              y1={0}\n              x2={0}\n              y2={1}\n            >\n              <Stop offset=\"0\" stopColor={highOpacityColor} stopOpacity=\"1\" />\n              {flatColor ? (\n                <Stop offset=\"1\" stopColor={highOpacityColor} stopOpacity=\"1\" />\n              ) : (\n                  <Stop offset=\"1\" stopColor={lowOpacityColor} stopOpacity=\"0\" />\n                )}\n            </LinearGradient>\n          );\n        })}\n      </Defs>\n    ));\n  };\n\n  renderValuesOnTopOfBars = ({\n    data,\n    width,\n    height,\n    paddingTop,\n    paddingRight\n  }: Pick<\n    Omit<AbstractChartConfig, \"data\">,\n    \"width\" | \"height\" | \"paddingRight\" | \"paddingTop\"\n  > & {\n    data: number[];\n  }) => {\n    const baseHeight = this.calcBaseHeight(data, height);\n\n    const renderLabel = (value: number) => {\n      if(this.props.chartConfig.formatTopBarValue) {\n        return this.props.chartConfig.formatTopBarValue(value)\n      }\n      else {\n        return value\n      }\n    }\n    return data.map((x, i) => {\n      const barHeight = this.calcHeight(x, data, height);\n      const barWidth = 32 * this.getBarPercentage();\n      return (\n        <Text\n          key={Math.random()}\n          x={\n            paddingRight +\n            (i * (width - paddingRight)) / data.length +\n            barWidth / 1\n            \n          }\n          y={((baseHeight - barHeight) / 4) * 3 + paddingTop - 1}\n          fill={this.props.chartConfig.color(0.6)}\n          fontSize=\"12\"\n          textAnchor=\"middle\"\n        >\n          {renderLabel(data[i])}\n        </Text>\n      );\n    });\n  };\n\n  render() {\n    const {\n      width,\n      height,\n      data,\n      style = {},\n      withHorizontalLabels = true,\n      withVerticalLabels = true,\n      verticalLabelRotation = 0,\n      horizontalLabelRotation = 0,\n      withInnerLines = true,\n      showBarTops = true,\n      withCustomBarColorFromData = false,\n      showValuesOnTopOfBars = false,\n      flatColor = false,\n      segments = 4\n    } = this.props;\n\n    const { borderRadius = 0, paddingTop = 16, paddingRight = 64 } = style;\n\n    const config = {\n      width,\n      height,\n      verticalLabelRotation,\n      horizontalLabelRotation,\n      barRadius:\n        (this.props.chartConfig && this.props.chartConfig.barRadius) || 0,\n      decimalPlaces:\n        (this.props.chartConfig && this.props.chartConfig.decimalPlaces) ?? 2,\n      formatYLabel:\n        (this.props.chartConfig && this.props.chartConfig.formatYLabel) ||\n        function (label) {\n          return label;\n        },\n      formatXLabel:\n        (this.props.chartConfig && this.props.chartConfig.formatXLabel) ||\n        function (label) {\n          return label;\n        }\n    };\n\n    return (\n      <View style={style}>\n        <Svg height={height} width={width}>\n          {this.renderDefs({\n            ...config,\n            ...this.props.chartConfig\n          })}\n          {this.renderColors({\n            ...this.props.chartConfig,\n            flatColor: flatColor,\n            data: this.props.data.datasets\n          })}\n          <Rect\n            width=\"100%\"\n            height={height}\n            rx={Number(borderRadius)}\n            ry={Number(borderRadius)}\n            fill=\"url(#backgroundGradient)\"\n          />\n          <G>\n            {withInnerLines\n              ? this.renderHorizontalLines({\n                ...config,\n                count: segments,\n                paddingTop\n              })\n              : null}\n          </G>\n          <G>\n            {withHorizontalLabels\n              ? this.renderHorizontalLabels({\n                ...config,\n                count: segments,\n                data: data.datasets[0].data,\n                paddingTop: paddingTop as number,\n                paddingRight: paddingRight as number\n              })\n              : null}\n          </G>\n          <G>\n            {withVerticalLabels\n              ? this.renderVerticalLabels({\n                ...config,\n                labels: data.labels,\n                paddingRight: paddingRight as number,\n                paddingTop: paddingTop as number,\n                horizontalOffset: barWidth * this.getBarPercentage()\n              })\n              : null}\n          </G>\n          <G>\n            {this.renderBars({\n              ...config,\n              data: data.datasets[0].data,\n              paddingTop: paddingTop as number,\n              paddingRight: paddingRight as number,\n              withCustomBarColorFromData: withCustomBarColorFromData\n            })}\n          </G>\n          <G>\n            {showValuesOnTopOfBars &&\n              this.renderValuesOnTopOfBars({\n                ...config,\n                data: data.datasets[0].data,\n                paddingTop: paddingTop as number,\n                paddingRight: paddingRight as number\n              })}\n          </G>\n          <G>\n            {showBarTops &&\n              this.renderBarTops({\n                ...config,\n                data: data.datasets[0].data,\n                paddingTop: paddingTop as number,\n                paddingRight: paddingRight as number\n              })}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default BarChart;\n"]} \ No newline at end of file diff --git a/dist/HelperTypes.d.ts b/dist/HelperTypes.d.ts new file mode 100644 index 00000000..2a9f7256 --- /dev/null +++ b/dist/HelperTypes.d.ts @@ -0,0 +1,161 @@ +import { TextStyle, ViewStyle } from "react-native"; +import { CircleProps, TextProps } from "react-native-svg"; +export interface Dataset { + /** The data corresponding to the x-axis label. */ + data: number[]; + /** A function returning the color of the stroke given an input opacity value. */ + color?: (opacity: number) => string; + /** A function returning array of the colors of the stroke given an input opacity value for each data value. */ + colors?: Array<(opacity: number) => string>; + /** The width of the stroke. Defaults to 2. */ + strokeWidth?: number; + /** A boolean indicating whether to render dots for this line */ + withDots?: boolean; + /** Override of LineChart's withScrollableDot property just for this dataset */ + withScrollableDot?: boolean; + /** Unique key **/ + key?: string | number; + /** Stroke Dash Array */ + strokeDashArray?: number[]; + /** Stroke Dash Offset */ + strokeDashOffset?: number; +} +export interface ChartData { + /** The x-axis labels */ + labels: string[]; + datasets: Dataset[]; +} +export interface ChartConfig { + backgroundColor?: string; + /** + * Defines the first color in the linear gradient of a chart's background + */ + backgroundGradientFrom?: string; + /** + * Defines the first color opacity in the linear gradient of a chart's background + */ + backgroundGradientFromOpacity?: number; + /** + * Defines the second color in the linear gradient of a chart's background + */ + backgroundGradientTo?: string; + /** + * Defines the second color opacity in the linear gradient of a chart's background + */ + backgroundGradientToOpacity?: number; + /** + * Defines the previous options to maintain backwards compatibility + */ + fillShadowGradient?: string; + fillShadowGradientOpacity?: number; + /** + * Defines the first color in the linear gradient of the area under data + */ + fillShadowGradientFrom?: string; + /** + * Defines the first color opacity in the linear gradient of the area under data + */ + fillShadowGradientFromOpacity?: number; + /** + * Defines the first color offset in the linear gradient of the area under data + */ + fillShadowGradientFromOffset?: number; + /** + * Defines the second color in the linear gradient of the area under data + */ + fillShadowGradientTo?: string; + /** + * Defines the second color opacity in the linear gradient of the area under data + */ + fillShadowGradientToOpacity?: number; + /** + * Defines the second color offset in the linear gradient of the area under data + */ + fillShadowGradientToOffset?: number; + /** + * Defines the option to use color from dataset to each chart data + */ + useShadowColorFromDataset?: boolean; + /** + * Defines the base color function that is used to calculate colors of labels and sectors used in a chart + */ + color?: (opacity: number, index?: number) => string; + /** + * Defines the function that is used to calculate the color of the labels used in a chart. + */ + labelColor?: (opacity: number) => string; + /** + * Defines the base stroke width in a chart + */ + strokeWidth?: number; + /** + * Defines the percent (0-1) of the available width each bar width in a chart + */ + barPercentage?: number; + barRadius?: number; + /** + * Override styles of the background lines, refer to react-native-svg's Line documentation + */ + propsForBackgroundLines?: object; + /** + * Override styles of the labels, refer to react-native-svg's Text documentation + */ + propsForLabels?: TextProps; + /** + * Override styles of vertical labels, refer to react-native-svg's Text documentation + */ + propsForVerticalLabels?: TextProps; + /** + * Override styles of horizontal labels, refer to react-native-svg's Text documentation + */ + propsForHorizontalLabels?: TextProps; + /** + * Override styles of the dots, refer to react-native-svg's Text documentation + */ + propsForDots?: CircleProps; + decimalPlaces?: number; + style?: Partial; + /** + * Define stroke line join type + */ + linejoinType?: "miter" | "bevel" | "round"; + /** + * Define fill color for scrollable dot + */ + scrollableDotFill?: string; + /** + * Define stroke color for scrollable dot + */ + scrollableDotStrokeColor?: string; + /** + * Define stroke width for scrollable dot + */ + scrollableDotStrokeWidth?: number; + /** + * Define radius for scrollable dot + */ + scrollableDotRadius?: number; + /** + * Override style for additional info view upper scrollable dot + */ + scrollableInfoViewStyle?: Partial; + /** + * Override text style for additional info view upper scrollable dot + */ + scrollableInfoTextStyle?: Partial; + scrollableInfoTextDecorator?: (value: number) => string; + /** + * Set Info View offset + */ + scrollableInfoOffset?: number; + /** + * Set Info View size + */ + scrollableInfoSize?: Size; +} +export interface Size { + width: number; + height: number; +} +export type PartialBy = Omit & Partial>; +//# sourceMappingURL=HelperTypes.d.ts.map \ No newline at end of file diff --git a/dist/HelperTypes.d.ts.map b/dist/HelperTypes.d.ts.map new file mode 100644 index 00000000..9bccf45d --- /dev/null +++ b/dist/HelperTypes.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"HelperTypes.d.ts","sourceRoot":"","sources":["../src/HelperTypes.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/dist/HelperTypes.js b/dist/HelperTypes.js new file mode 100644 index 00000000..01642b6a --- /dev/null +++ b/dist/HelperTypes.js @@ -0,0 +1,2 @@ +export {}; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/dist/PieChart.d.ts b/dist/PieChart.d.ts new file mode 100644 index 00000000..ddaf92b6 --- /dev/null +++ b/dist/PieChart.d.ts @@ -0,0 +1,30 @@ +import React from "react"; +import { ViewStyle } from "react-native"; +import AbstractChart, { AbstractChartProps } from "./AbstractChart"; +export interface PieChartProps extends AbstractChartProps { + data: Array; + width: number; + height: number; + accessor: string; + backgroundColor: string; + paddingLeft: string; + center?: Array; + absolute?: boolean; + hasLegend?: boolean; + style?: Partial; + avoidFalseZero?: boolean; + chartWidthPercentage: number; + showLabelPrefix: boolean; + editor: boolean; +} +type PieChartState = { + data: Array; + calculating: Array; +}; +declare class PieChart extends AbstractChart { + componentDidUpdate(prevProps: any): void; + constructor(props: any); + render(): React.JSX.Element; +} +export default PieChart; +//# sourceMappingURL=PieChart.d.ts.map \ No newline at end of file diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map new file mode 100644 index 00000000..0a7e5385 --- /dev/null +++ b/dist/PieChart.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAmB,MAAM,OAAO,CAAC;AACxC,OAAO,EAAQ,SAAS,EAAsB,MAAM,cAAc,CAAC;AAGnE,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAGpE,MAAM,WAAW,aAAc,SAAQ,kBAAkB;IACvD,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC3B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBA+BhB,KAAK,KAAA;IAajB,MAAM;CAkSP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js new file mode 100644 index 00000000..f3f25591 --- /dev/null +++ b/dist/PieChart.js @@ -0,0 +1,283 @@ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { + if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i); + ar[i] = from[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from)); +}; +import { isObject } from "lodash"; +import Pie from "paths-js/pie"; +import React from "react"; +import { View, Text as NativeText } from "react-native"; +import { G, Path, Rect, Svg, Text } from "react-native-svg"; +import AbstractChart from "./AbstractChart"; +import { hslToRgba } from "./Utils"; +var compareDataArrays = function (a, b) { + //TODO: remove values field from a and b + //TODO: get the sum of values to make sure percentages stay the same + var sumA = a.reduce(function (accumulator, item) { + return accumulator + item.value; + }, 0); + var sumB = b.reduce(function (accumulator, item) { + return accumulator + item.value; + }, 0); + return (sumA === sumB && + a.length === b.length && + a.every(function (value, index) { + var aCopy = __assign(__assign({}, value), { values: null }); + var bCopy = __assign(__assign({}, b[index]), { values: null }); + return JSON.stringify(aCopy) === JSON.stringify(bCopy); + })); +}; +var PieChart = /** @class */ (function (_super) { + __extends(PieChart, _super); + function PieChart(props) { + var _this = _super.call(this, props) || this; + var calculating = []; + for (var i = 0; i < _this.props.data.length; i++) { + calculating[i] = { label: _this.props.data[i], calculating: true }; + } + _this.state = __assign(__assign({ calculating: calculating }, props), { labelData: _this.props.data }); + return _this; + } + PieChart.prototype.componentDidUpdate = function (prevProps) { + if (this.props.width !== prevProps.width || + this.props.height !== prevProps.height || + this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || + !compareDataArrays(this.props.data, prevProps.data)) { + var calculating = []; + for (var i = 0; i < this.props.data.length; i++) { + calculating[i] = { label: this.props.data[i], calculating: true }; + } + if (this.state.calculating.filter(function (i) { return i.calculating === true; }).length === + 0 && + this.props.width === prevProps.width && + compareDataArrays(this.props.data, prevProps.data)) { + this.setState(__assign(__assign({ calculating: calculating }, this.props), this.state)); + } + else { + this.setState(__assign({ calculating: calculating }, this.props)); + } + } + }; + PieChart.prototype.render = function () { + var _this = this; + var _a = this.props, _b = _a.style, style = _b === void 0 ? {} : _b, backgroundColor = _a.backgroundColor, _c = _a.absolute, absolute = _c === void 0 ? false : _c, _d = _a.hasLegend, hasLegend = _d === void 0 ? true : _d, _e = _a.avoidFalseZero, avoidFalseZero = _e === void 0 ? false : _e; + var calculations = this.state.calculating.map(function (item, index) { + var _a = item.label, name = _a.name, legendFontFamily = _a.legendFontFamily, legendFontSize = _a.legendFontSize, legendFontWeight = _a.legendFontWeight, value = _a.value; + if (item.calculating && _this.props.hasLegend) { + if (_this.props.absolute === false) { + value = "55%"; + } + if (_this.props.showLabelPrefix === false) { + value = ""; + } + if (!isObject(value)) { + return ( + {"".concat(value, " ").concat(name)} + ); + } + else { + return ( + + {//@ts-ignore + "".concat(value.whole, "% ").concat(name)} + + ); + } + } + }); + var _f = style.borderRadius, borderRadius = _f === void 0 ? 0 : _f; + var chartWidthPercentage = this.props.chartWidthPercentage * 0.01; + var radius; + if (this.props.height / 2.5 < + (this.props.width * chartWidthPercentage) / 2) { + radius = this.props.height / 2.5; + chartWidthPercentage = 2 * (radius / this.props.width); + } + else { + radius = this.props.width * (chartWidthPercentage / 2); + } + if (chartWidthPercentage === 1) { + chartWidthPercentage = 0.5; + } + var chart = Pie({ + center: this.props.center || [0, 0], + r: 0, + R: radius, + data: this.state.data, + accessor: function (x) { + return x[_this.props.accessor]; + } + }); + var total = this.state.data.reduce(function (sum, item) { + if (isObject(item[_this.props.accessor])) { + return sum + item[_this.props.accessor].whole; + } + else { + return sum + item[_this.props.accessor]; + } + }, 0); + var uppedIndices = []; + if (!absolute) { + var divisor_1 = total / 100.0; + var wholeTotal_1 = 0; + chart.curves.forEach(function (c, i) { + if (!isObject(c.item.values)) { + var percentage = c.item[_this.props.accessor] / divisor_1; + var pieces = percentage.toString().split("."); + var whole = parseInt(pieces[0]); + var decimal = parseFloat("." + pieces[1]); + if (isNaN(decimal)) { + decimal = 0; + } + wholeTotal_1 += whole; + //had to create a new object here to use for percentages, chart wouldn't render when assigning the object to c.item[this.props.accessor] + c.item.values = { + index: i, + whole: whole, + decimal: decimal + }; + } + else { + wholeTotal_1 += c.item.values.whole; + } + }); + var hamiltonDiff = 100 - wholeTotal_1; + var sortedCurves = __spreadArray([], chart.curves, true).sort(function (a, b) { + return a.item.values.decimal < b.item.values.decimal ? 1 : -1; + }); + var _loop_1 = function (i) { + var uppedVal = sortedCurves[i].item.values.whole; + sortedCurves.some(function (item) { + if (item.item.values.whole === uppedVal) { + uppedIndices.push(item.item.values.index); + chart.curves[item.item.values.index].item.values.whole += 1; + return true; + } + }); + }; + for (var i = 0; i < hamiltonDiff; i++) { + _loop_1(i); + } + } + var chartCurvesSorted = __spreadArray([], chart.curves, true).filter(function (item) { return item.item.otherSlice !== true; }); + var otherSlice = __spreadArray([], chart.curves, true).find(function (item) { return item.item.otherSlice === true; }); + if (!absolute) { + chartCurvesSorted = chartCurvesSorted.sort(function (a, b) { + return a.item.values.whole < b.item.values.whole ? 1 : -1; + }); + } + if (otherSlice) { + chartCurvesSorted.push(otherSlice); + } + var slices = chartCurvesSorted.map(function (c, i) { + var _a; + var value; + if (absolute) { + if (_this.props.showLabelPrefix) { + value = c.item[_this.props.accessor]; + } + else { + value = ""; + } + } + else { + //calculate percentage using Hamilton's method + if (total === 0) { + value = 0 + "%"; + } + else { + var item = c.item.values; + var percentage = item.whole; + if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) { + value = "<1%"; + } + else { + value = percentage + "%"; + } + } + } + var textColor = _this.state.calculating[i] + ? c.item.legendFontColor + : "transparent"; + if (typeof ((_a = c === null || c === void 0 ? void 0 : c.item) === null || _a === void 0 ? void 0 : _a.color) === "string" && c.item.color.includes('hsl')) { + c.item.color = hslToRgba(c.item.color); + } + return ( + + {hasLegend ? () : null} + {hasLegend ? ( + {"".concat(value, " ").concat(c.item.name)} + ) : null} + ); + }); + return ( + + + {this.renderDefs(__assign({ width: this.props.height, height: this.props.height }, this.props.chartConfig))} + + + + {slices} + + + {calculations} + ); + }; + return PieChart; +}(AbstractChart)); +export default PieChart; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PieChart.js","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"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","sourcesContent":["import { isObject } from \"lodash\";\nimport Pie from \"paths-js/pie\";\nimport React, { Fragment } from \"react\";\nimport { View, ViewStyle, Text as NativeText } from \"react-native\";\nimport { G, Path, Rect, Svg, Text } from \"react-native-svg\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\nimport { hslToRgba } from \"./Utils\";\n\nexport interface PieChartProps extends AbstractChartProps {\n  data: Array<any>;\n  width: number;\n  height: number;\n  accessor: string;\n  backgroundColor: string;\n  paddingLeft: string;\n  center?: Array<number>;\n  absolute?: boolean;\n  hasLegend?: boolean;\n  style?: Partial<ViewStyle>;\n  avoidFalseZero?: boolean;\n  chartWidthPercentage: number;\n  showLabelPrefix: boolean;\n  editor: boolean;\n}\n\ntype PieChartState = {\n  data: Array<any>;\n  calculating: Array<any>;\n};\n\nconst compareDataArrays = (a, b) => {\n  //TODO: remove values field from a and b\n  //TODO: get the sum of values to make sure percentages stay the same\n  let sumA = a.reduce((accumulator, item) => {\n    return accumulator + item.value;\n  }, 0);\n\n  let sumB = b.reduce((accumulator, item) => {\n    return accumulator + item.value;\n  }, 0);\n\n  return (\n    sumA === sumB &&\n    a.length === b.length &&\n    a.every((value, index) => {\n      const aCopy = {\n        ...value,\n        values: null\n      };\n      const bCopy = {\n        ...b[index],\n        values: null\n      };\n      return JSON.stringify(aCopy) === JSON.stringify(bCopy);\n    })\n  );\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.height !== prevProps.height ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      !compareDataArrays(this.props.data, prevProps.data)\n    ) {\n      let calculating = [];\n      for (let i = 0; i < this.props.data.length; i++) {\n        calculating[i] = { label: this.props.data[i], calculating: true };\n      }\n      if (\n        this.state.calculating.filter(i => i.calculating === true).length ===\n          0 &&\n        this.props.width === prevProps.width &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          ...this.props\n        });\n      }\n    }\n  }\n\n  constructor(props) {\n    super(props);\n    let calculating = [];\n    for (let i = 0; i < this.props.data.length; i++) {\n      calculating[i] = { label: this.props.data[i], calculating: true };\n    }\n    this.state = {\n      calculating,\n      ...props,\n      labelData: this.props.data\n    };\n  }\n\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\n\n    const calculations = this.state.calculating.map((item, index) => {\n      let {\n        name,\n        legendFontFamily,\n        legendFontSize,\n        legendFontWeight,\n        value\n      } = item.label;\n      if (item.calculating && this.props.hasLegend) {\n        if (this.props.absolute === false) {\n          value = \"55%\";\n        }\n        if (this.props.showLabelPrefix === false) {\n          value = \"\";\n        }\n        if (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n            >\n              <NativeText\n                style={{\n                  fontFamily: legendFontFamily,\n                  fontSize: legendFontSize,\n                  fontWeight: legendFontWeight,\n                  color: \"transparent\"\n                }}\n              >{`${value} ${name}`}</NativeText>\n            </View>\n          );\n        } else {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n            >\n              <NativeText\n                style={{\n                  fontFamily: legendFontFamily,\n                  fontSize: legendFontSize,\n                  fontWeight: legendFontWeight,\n                  color: \"transparent\"\n                }}\n              >\n                {//@ts-ignore\n                `${value.whole}% ${name}`}\n              </NativeText>\n            </View>\n          );\n        }\n      }\n    });\n\n    const { borderRadius = 0 } = style;\n\n    let chartWidthPercentage = this.props.chartWidthPercentage * 0.01;\n\n    let radius: number;\n\n    if (\n      this.props.height / 2.5 <\n      (this.props.width * chartWidthPercentage) / 2\n    ) {\n      radius = this.props.height / 2.5;\n      chartWidthPercentage = 2 * (radius / this.props.width);\n    } else {\n      radius = this.props.width * (chartWidthPercentage / 2);\n    }\n\n    if (chartWidthPercentage === 1) {\n      chartWidthPercentage = 0.5;\n    }\n\n    let chart = Pie({\n      center: this.props.center || [0, 0],\n      r: 0,\n      R: radius,\n      data: this.state.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.state.data.reduce((sum, item) => {\n      if (isObject(item[this.props.accessor])) {\n        return sum + item[this.props.accessor].whole;\n      } else {\n        return sum + item[this.props.accessor];\n      }\n    }, 0);\n\n    let uppedIndices = [];\n\n    if (!absolute) {\n      const divisor = total / 100.0;\n      let wholeTotal = 0;\n      chart.curves.forEach((c, i) => {\n        if (!isObject(c.item.values)) {\n          const percentage = c.item[this.props.accessor] / divisor;\n          const pieces = percentage.toString().split(\".\");\n          let whole = parseInt(pieces[0]);\n          let decimal = parseFloat(\".\" + pieces[1]);\n          if (isNaN(decimal)) {\n            decimal = 0;\n          }\n          wholeTotal += whole;\n          //had to create a new object here to use for percentages, chart wouldn't render when assigning the object to c.item[this.props.accessor]\n          c.item.values = {\n            index: i,\n            whole,\n            decimal\n          };\n        } else {\n          wholeTotal += c.item.values.whole;\n        }\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item.values.decimal < b.item.values.decimal ? 1 : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        let uppedVal = sortedCurves[i].item.values.whole;\n        sortedCurves.some(item => {\n          if (item.item.values.whole === uppedVal) {\n            uppedIndices.push(item.item.values.index);\n            chart.curves[item.item.values.index].item.values.whole += 1;\n            return true;\n          }\n        });\n      }\n    }\n\n    let chartCurvesSorted = [...chart.curves].filter(\n      item => item.item.otherSlice !== true\n    );\n    let otherSlice = [...chart.curves].find(\n      item => item.item.otherSlice === true\n    );\n\n    if (!absolute) {\n      chartCurvesSorted = chartCurvesSorted.sort((a, b) =>\n        a.item.values.whole < b.item.values.whole ? 1 : -1\n      );\n    }\n\n    if (otherSlice) {\n      chartCurvesSorted.push(otherSlice);\n    }\n\n    const slices = chartCurvesSorted.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        if (this.props.showLabelPrefix) {\n          value = c.item[this.props.accessor];\n        } else {\n          value = \"\";\n        }\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item.values;\n          let percentage = item.whole;\n\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      let textColor = this.state.calculating[i]\n        ? c.item.legendFontColor\n        : \"transparent\";\n\n      if (typeof c?.item?.color === \"string\" && c.item.color.includes('hsl')) {\n        c.item.color = hslToRgba(c.item.color)\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            // fill={textColor}\n            onPress={c.item.action}\n            //@ts-ignore\n            onClick={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width={16}\n              height={16}\n              fill={c.item.color}\n              rx={Number(8)}\n              ry={Number(8)}\n              x={\n                this.props.width / (100 / (chartWidthPercentage * 100) + 0.5) -\n                24\n              }\n              y={\n                -(this.props.height / 2.5) +\n                ((this.props.height * 0.8) / this.state.data.length) * i +\n                12\n              }\n              onPress={c.item.action}\n              //@ts-ignore\n              onClick={c.item.action}\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={textColor}\n              fontSize={c.item.legendFontSize}\n              fontFamily={c.item.legendFontFamily}\n              fontWeight={c.item.legendFontWeight}\n              x={this.props.width / (100 / (chartWidthPercentage * 100) + 0.5)}\n              y={\n                -(this.props.height / 2.5) +\n                ((this.props.height * 0.8) / this.state.data.length) * i +\n                12 * 2\n              }\n              onPress={c.item.action}\n              //@ts-ignore\n              onClick={c.item.action}\n            >\n              {`${value} ${c.item.name}`}\n            </Text>\n          ) : null}\n        </G>\n      );\n    });\n\n    return (\n      <View\n        style={{\n          width: this.props.width,\n          height: this.props.height,\n          padding: 0,\n          ...style\n        }}\n      >\n        <Svg\n          width={this.props.width}\n          height={this.props.height}\n          style={{ paddingRight: 16 }}\n        >\n          <G>\n            {this.renderDefs({\n              width: this.props.height,\n              height: this.props.height,\n              ...this.props.chartConfig\n            })}\n          </G>\n          <Rect\n            width=\"100%\"\n            height={this.props.height}\n            rx={Number(borderRadius)}\n            ry={Number(borderRadius)}\n            fill={backgroundColor}\n          />\n          <G\n            x={\n              (this.props.width * chartWidthPercentage) / 2 +\n              Number(this.props.paddingLeft ? this.props.paddingLeft : 0)\n            }\n            y={this.props.height / 2}\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} \ No newline at end of file diff --git a/dist/ProgressChart.d.ts b/dist/ProgressChart.d.ts new file mode 100644 index 00000000..8d2e151f --- /dev/null +++ b/dist/ProgressChart.d.ts @@ -0,0 +1,33 @@ +import React from "react"; +import { ViewStyle } from "react-native"; +import AbstractChart, { AbstractChartConfig, AbstractChartProps } from "./AbstractChart"; +export type ProgressChartData = Array | { + labels?: Array; + colors?: Array; + data: Array; +}; +export interface ProgressChartProps extends AbstractChartProps { + data: ProgressChartData; + width: number; + height: number; + center?: Array; + absolute?: boolean; + hasLegend?: boolean; + style?: Partial; + chartConfig?: AbstractChartConfig; + hideLegend?: boolean; + strokeWidth?: number; + radius?: number; + withCustomBarColorFromData?: boolean; +} +type ProgressChartState = {}; +declare class ProgressChart extends AbstractChart { + static defaultProps: { + style: {}; + strokeWidth: number; + radius: number; + }; + render(): React.JSX.Element; +} +export default ProgressChart; +//# sourceMappingURL=ProgressChart.d.ts.map \ No newline at end of file diff --git a/dist/ProgressChart.d.ts.map b/dist/ProgressChart.d.ts.map new file mode 100644 index 00000000..ca4d9140 --- /dev/null +++ b/dist/ProgressChart.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"ProgressChart.d.ts","sourceRoot":"","sources":["../src/ProgressChart.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,aAAa,EAAE,EACpB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AAEzB,MAAM,MAAM,iBAAiB,GACzB,KAAK,CAAC,MAAM,CAAC,GACb;IAAE,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAE5E,MAAM,WAAW,kBAAmB,SAAQ,kBAAkB;IAC5D,IAAI,EAAE,iBAAiB,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC3B,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACtC;AAED,KAAK,kBAAkB,GAAG,EAAE,CAAC;AAE7B,cAAM,aAAc,SAAQ,aAAa,CACvC,kBAAkB,EAClB,kBAAkB,CACnB;IACC,OAAc,YAAY;;;;MAA8C;IAExE,MAAM;CAuLP;AAED,eAAe,aAAa,CAAC"} \ No newline at end of file diff --git a/dist/ProgressChart.js b/dist/ProgressChart.js new file mode 100644 index 00000000..c8a245e8 --- /dev/null +++ b/dist/ProgressChart.js @@ -0,0 +1,134 @@ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +import Pie from "paths-js/pie"; +import React from "react"; +import { View } from "react-native"; +import { G, Path, Rect, Svg, Text } from "react-native-svg"; +import AbstractChart from "./AbstractChart"; +var ProgressChart = /** @class */ (function (_super) { + __extends(ProgressChart, _super); + function ProgressChart() { + return _super !== null && _super.apply(this, arguments) || this; + } + ProgressChart.prototype.render = function () { + var _this = this; + var _a = this.props, width = _a.width, height = _a.height, style = _a.style, data = _a.data, hideLegend = _a.hideLegend, strokeWidth = _a.strokeWidth, radius = _a.radius; + var _b = style.borderRadius, borderRadius = _b === void 0 ? 0 : _b, _c = style.margin, margin = _c === void 0 ? 0 : _c, _d = style.marginRight, marginRight = _d === void 0 ? 0 : _d; + if (Array.isArray(data)) { + data = { + data: data + }; + } + var pies = data.data.map(function (pieData, i) { + var r = ((height / 2 - 32) / + (Array.isArray(data) ? data.length : data.data.length)) * + i + + radius; + return Pie({ + r: r, + R: r, + center: [0, 0], + data: [pieData, 1 - pieData], + accessor: function (x) { + return x; + } + }); + }); + var pieBackgrounds = data.data.map(function (pieData, i) { + var r = ((height / 2 - 32) / + (Array.isArray(data) ? data.length : data.data.length)) * + i + + radius; + return Pie({ + r: r, + R: r, + center: [0, 0], + data: [0.999, 0.001], + accessor: function (x) { + return x; + } + }); + }); + var withLabel = function (i) { + return data.labels && data.labels[i]; + }; + var withColor = function (i) { + return data.colors && data.colors[i]; + }; + var legend = !hideLegend && (<> + + {pies.map(function (_, i) { + return (); + })} + + + {pies.map(function (_, i) { + return ( + {withLabel(i) + ? "".concat(data.labels[i], " ").concat(Math.round(100 * data.data[i]), "%") + : "".concat(Math.round(100 * data.data[i]), "%")} + ); + })} + + ); + return ( + + {this.renderDefs(__assign({ width: this.props.height, height: this.props.height }, this.props.chartConfig))} + + + + {pieBackgrounds.map(function (pie, i) { + return (); + })} + + + {pies.map(function (pie, i) { + return (); + })} + + {legend} + + + ); + }; + ProgressChart.defaultProps = { style: {}, strokeWidth: 16, radius: 32 }; + return ProgressChart; +}(AbstractChart)); +export default ProgressChart; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ProgressChart.js","sourceRoot":"","sources":["../src/ProgressChart.tsx"],"names":[],"mappings":"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","sourcesContent":["import Pie from \"paths-js/pie\";\nimport React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport { G, Path, Rect, Svg, Text } from \"react-native-svg\";\n\nimport AbstractChart, {\n  AbstractChartConfig,\n  AbstractChartProps\n} from \"./AbstractChart\";\n\nexport type ProgressChartData =\n  | Array<number>\n  | { labels?: Array<string>; colors?: Array<string>; data: Array<number> };\n\nexport interface ProgressChartProps extends AbstractChartProps {\n  data: ProgressChartData;\n  width: number;\n  height: number;\n  center?: Array<number>;\n  absolute?: boolean;\n  hasLegend?: boolean;\n  style?: Partial<ViewStyle>;\n  chartConfig?: AbstractChartConfig;\n  hideLegend?: boolean;\n  strokeWidth?: number;\n  radius?: number;\n  withCustomBarColorFromData?: boolean;\n}\n\ntype ProgressChartState = {};\n\nclass ProgressChart extends AbstractChart<\n  ProgressChartProps,\n  ProgressChartState\n> {\n  public static defaultProps = { style: {}, strokeWidth: 16, radius: 32 };\n\n  render() {\n    let {\n      width,\n      height,\n      style,\n      data,\n      hideLegend,\n      strokeWidth,\n      radius\n    } = this.props;\n\n    const { borderRadius = 0, margin = 0, marginRight = 0 } = style;\n\n    if (Array.isArray(data)) {\n      data = {\n        data\n      };\n    }\n\n    const pies = data.data.map((pieData, i) => {\n      const r =\n        ((height / 2 - 32) /\n          (Array.isArray(data) ? data.length : data.data.length)) *\n          i +\n        radius;\n\n      return Pie({\n        r,\n        R: r,\n        center: [0, 0],\n        data: [pieData, 1 - pieData],\n        accessor(x: string) {\n          return x;\n        }\n      });\n    });\n\n    const pieBackgrounds = data.data.map((pieData, i) => {\n      const r =\n        ((height / 2 - 32) /\n          (Array.isArray(data) ? data.length : data.data.length)) *\n          i +\n        radius;\n      return Pie({\n        r,\n        R: r,\n        center: [0, 0],\n        data: [0.999, 0.001],\n        accessor(x: string) {\n          return x;\n        }\n      });\n    });\n\n    const withLabel = (i: number) =>\n      (data as any).labels && (data as any).labels[i];\n\n    const withColor = (i: number) =>\n      (data as any).colors && (data as any).colors[i];\n\n    const legend = !hideLegend && (\n      <>\n        <G>\n          {pies.map((_, i) => {\n            return (\n              <Rect\n                key={Math.random()}\n                width=\"16px\"\n                height=\"16px\"\n                fill={\n                  this.props.withCustomBarColorFromData\n                    ? withColor(i)\n                    : this.props.chartConfig.color(0.2 * (i + 1), i)\n                }\n                rx={8}\n                ry={8}\n                x={this.props.width / 2.5 - 24}\n                y={\n                  -(this.props.height / 2.5) +\n                  ((this.props.height * 0.8) /\n                    (Array.isArray(data) ? data.length : data.data.length)) *\n                    i +\n                  12\n                }\n              />\n            );\n          })}\n        </G>\n        <G>\n          {pies.map((_, i) => {\n            return (\n              <Text\n                key={Math.random()}\n                x={this.props.width / 2.5}\n                y={\n                  -(this.props.height / 2.5) +\n                  ((this.props.height * 0.8) /\n                    (Array.isArray(data) ? data.length : data.data.length)) *\n                    i +\n                  12 * 2\n                }\n                {...this.getPropsForLabels()}\n              >\n                {withLabel(i)\n                  ? `${(data as any).labels[i]} ${Math.round(\n                      100 * (data as any).data[i]\n                    )}%`\n                  : `${Math.round(100 * (data as any).data[i])}%`}\n              </Text>\n            );\n          })}\n        </G>\n      </>\n    );\n\n    return (\n      <View\n        style={{\n          width,\n          height,\n          padding: 0,\n          ...style\n        }}\n      >\n        <Svg\n          width={width - (margin as number) * 2 - (marginRight as number)}\n          height={height}\n        >\n          {this.renderDefs({\n            width: this.props.height,\n            height: this.props.height,\n            ...this.props.chartConfig\n          })}\n          <Rect\n            width=\"100%\"\n            height={this.props.height}\n            rx={Number(borderRadius)}\n            ry={Number(borderRadius)}\n            fill=\"url(#backgroundGradient)\"\n          />\n          <G\n            x={this.props.width / (hideLegend ? 2 : 2.5)}\n            y={this.props.height / 2}\n          >\n            <G>\n              {pieBackgrounds.map((pie, i) => {\n                return (\n                  <Path\n                    key={Math.random()}\n                    d={pie.curves[0].sector.path.print()}\n                    strokeWidth={strokeWidth}\n                    stroke={this.props.chartConfig.color(0.2, i)}\n                  />\n                );\n              })}\n            </G>\n            <G>\n              {pies.map((pie, i) => {\n                return (\n                  <Path\n                    key={Math.random()}\n                    strokeLinecap=\"round\"\n                    strokeLinejoin=\"round\"\n                    d={pie.curves[0].sector.path.print()}\n                    strokeWidth={strokeWidth}\n                    stroke={\n                      this.props.withCustomBarColorFromData\n                        ? withColor(i)\n                        : this.props.chartConfig.color(\n                            (i / pies.length) * 0.5 + 0.5,\n                            i\n                          )\n                    }\n                  />\n                );\n              })}\n            </G>\n            {legend}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default ProgressChart;\n"]} \ No newline at end of file diff --git a/dist/StackedBarChart.d.ts b/dist/StackedBarChart.d.ts new file mode 100644 index 00000000..5658de57 --- /dev/null +++ b/dist/StackedBarChart.d.ts @@ -0,0 +1,66 @@ +import React from "react"; +import { ViewStyle } from "react-native"; +import AbstractChart, { AbstractChartConfig, AbstractChartProps } from "./AbstractChart"; +export interface StackedBarChartData { + labels: string[]; + legend: string[]; + data: number[][]; + barColors: string[]; +} +export interface StackedBarChartProps extends AbstractChartProps { + /** + * E.g. + * ```javascript + * const data = { + * labels: ["Test1", "Test2"], + * legend: ["L1", "L2", "L3"], + * data: [[60, 60, 60], [30, 30, 60]], + * barColors: ["#dfe4ea", "#ced6e0", "#a4b0be"] + * }; + * ``` + */ + data: StackedBarChartData; + width: number; + height: number; + chartConfig: AbstractChartConfig; + hideLegend: boolean; + style?: Partial; + barPercentage?: number; + decimalPlaces?: number; + /** + * Show vertical labels - default: True. + */ + withVerticalLabels?: boolean; + /** + * Show horizontal labels - default: True. + */ + withHorizontalLabels?: boolean; + /** + * The number of horizontal lines + */ + segments?: number; + percentile?: boolean; + /** + * Percentage of the chart height, dedicated to vertical labels + * (space below chart) + */ + verticalLabelsHeightPercentage?: number; + formatYLabel?: (yLabel: string) => string; +} +type StackedBarChartState = {}; +declare class StackedBarChart extends AbstractChart { + getBarPercentage: () => number; + getBarRadius: (ret: string | any[], x: string | any[]) => number; + renderBars: ({ data, width, height, paddingTop, paddingRight, border, colors, stackedBar, verticalLabelsHeightPercentage }: Pick, "width" | "height" | "paddingRight" | "paddingTop" | "stackedBar" | "verticalLabelsHeightPercentage"> & { + border: number; + colors: string[]; + data: number[][]; + }) => any[][]; + renderLegend: ({ legend, colors, width, height }: Pick & { + legend: string[]; + colors: string[]; + }) => React.JSX.Element[]; + render(): React.JSX.Element; +} +export default StackedBarChart; +//# sourceMappingURL=StackedBarChart.d.ts.map \ No newline at end of file diff --git a/dist/StackedBarChart.d.ts.map b/dist/StackedBarChart.d.ts.map new file mode 100644 index 00000000..c8044860 --- /dev/null +++ b/dist/StackedBarChart.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"StackedBarChart.d.ts","sourceRoot":"","sources":["../src/StackedBarChart.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,aAAa,EAAE,EACpB,mBAAmB,EACnB,kBAAkB,EAEnB,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC9D;;;;;;;;;;OAUG;IACH,IAAI,EAAE,mBAAmB,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,mBAAmB,CAAC;IACjC,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,8BAA8B,CAAC,EAAE,MAAM,CAAC;IAExC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CAC3C;AAED,KAAK,oBAAoB,GAAG,EAAE,CAAC;AAE/B,cAAM,eAAgB,SAAQ,aAAa,CACzC,oBAAoB,EACpB,oBAAoB,CACrB;IACC,gBAAgB,eAGd;IAEF,YAAY,GAAI,KAAK,MAAM,GAAG,GAAG,EAAE,EAAE,GAAG,MAAM,GAAG,GAAG,EAAE,YAIpD;IAEF,UAAU,GAAI,+GAUX,IAAI,CACL,IAAI,CAAC,mBAAmB,EAAE,MAAM,CAAC,EAC/B,OAAO,GACP,QAAQ,GACR,cAAc,GACd,YAAY,GACZ,YAAY,GACZ,gCAAgC,CACnC,GAAG;QACF,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;KAClB,aAqDI;IAEL,YAAY,GAAI,mCAKb,IAAI,CAAC,mBAAmB,EAAE,OAAO,GAAG,QAAQ,CAAC,GAAG;QACjD,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,MAAM,EAAE,MAAM,EAAE,CAAC;KAClB,yBAsBI;IAEL,MAAM;CAsHP;AAED,eAAe,eAAe,CAAC"} \ No newline at end of file diff --git a/dist/StackedBarChart.js b/dist/StackedBarChart.js new file mode 100644 index 00000000..2722a1b3 --- /dev/null +++ b/dist/StackedBarChart.js @@ -0,0 +1,144 @@ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +import React from "react"; +import { View } from "react-native"; +import { G, Rect, Svg, Text } from "react-native-svg"; +import AbstractChart, { DEFAULT_X_LABELS_HEIGHT_PERCENTAGE } from "./AbstractChart"; +var StackedBarChart = /** @class */ (function (_super) { + __extends(StackedBarChart, _super); + function StackedBarChart() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.getBarPercentage = function () { + var _a = _this.props.chartConfig.barPercentage, barPercentage = _a === void 0 ? 1 : _a; + return barPercentage; + }; + _this.getBarRadius = function (ret, x) { + return _this.props.chartConfig.barRadius && ret.length === x.length - 1 + ? _this.props.chartConfig.barRadius + : 0; + }; + _this.renderBars = function (_a) { + var data = _a.data, width = _a.width, height = _a.height, paddingTop = _a.paddingTop, paddingRight = _a.paddingRight, border = _a.border, colors = _a.colors, _b = _a.stackedBar, stackedBar = _b === void 0 ? false : _b, verticalLabelsHeightPercentage = _a.verticalLabelsHeightPercentage; + return data.map(function (x, i) { + var barWidth = 32 * _this.getBarPercentage(); + var ret = []; + var h = 0; + var st = paddingTop; + var fac = 1; + if (stackedBar) { + fac = 0.7; + } + var sum = _this.props.percentile ? x.reduce(function (a, b) { return a + b; }, 0) : border; + var barsAreaHeight = height * verticalLabelsHeightPercentage; + for (var z = 0; z < x.length; z++) { + h = barsAreaHeight * (x[z] / sum); + var y = barsAreaHeight - h + st; + var xC = (paddingRight + + (i * (width - paddingRight)) / data.length + + barWidth / 2) * + fac; + ret.push(); + if (!_this.props.hideLegend) { + ret.push( 15 ? y + 15 : y + 7} {..._this.getPropsForLabels()}> + {x[z]} + ); + } + st -= h; + } + return ret; + }); + }; + _this.renderLegend = function (_a) { + var legend = _a.legend, colors = _a.colors, width = _a.width, height = _a.height; + return legend.map(function (x, i) { + return ( + + + {x} + + ); + }); + }; + return _this; + } + StackedBarChart.prototype.render = function () { + var paddingTop = 15; + var paddingRight = 50; + var barWidth = 32 * this.getBarPercentage(); + var _a = this.props, width = _a.width, height = _a.height, _b = _a.style, style = _b === void 0 ? {} : _b, data = _a.data, _c = _a.withHorizontalLabels, withHorizontalLabels = _c === void 0 ? true : _c, _d = _a.withVerticalLabels, withVerticalLabels = _d === void 0 ? true : _d, _e = _a.segments, segments = _e === void 0 ? 4 : _e, decimalPlaces = _a.decimalPlaces, _f = _a.percentile, percentile = _f === void 0 ? false : _f, _g = _a.verticalLabelsHeightPercentage, verticalLabelsHeightPercentage = _g === void 0 ? DEFAULT_X_LABELS_HEIGHT_PERCENTAGE : _g, _h = _a.formatYLabel, formatYLabel = _h === void 0 ? function (yLabel) { + return yLabel; + } : _h, _j = _a.hideLegend, hideLegend = _j === void 0 ? false : _j; + var _k = style.borderRadius, borderRadius = _k === void 0 ? 0 : _k; + var config = { + width: width, + height: height + }; + var border = 0; + var max = 0; + for (var i = 0; i < data.data.length; i++) { + var actual = data.data[i].reduce(function (pv, cv) { return pv + cv; }, 0); + if (actual > max) { + max = actual; + } + } + if (percentile) { + border = 100; + } + else { + border = max; + } + var showLegend = !hideLegend && data.legend && data.legend.length != 0; + var stackedBar = showLegend; + return ( + + {this.renderDefs(__assign(__assign({}, config), this.props.chartConfig))} + + + {this.renderHorizontalLines(__assign(__assign({}, config), { count: segments, paddingTop: paddingTop, verticalLabelsHeightPercentage: verticalLabelsHeightPercentage }))} + + + {withHorizontalLabels + ? this.renderHorizontalLabels(__assign(__assign({}, config), { count: segments, data: [0, border], paddingTop: paddingTop, paddingRight: paddingRight, decimalPlaces: decimalPlaces, verticalLabelsHeightPercentage: verticalLabelsHeightPercentage, formatYLabel: formatYLabel })) + : null} + + + {withVerticalLabels + ? this.renderVerticalLabels(__assign(__assign({}, config), { labels: data.labels, paddingRight: paddingRight + 28, stackedBar: stackedBar, paddingTop: paddingTop, horizontalOffset: barWidth, verticalLabelsHeightPercentage: verticalLabelsHeightPercentage })) + : null} + + + {this.renderBars(__assign(__assign({}, config), { data: data.data, border: border, colors: this.props.data.barColors, paddingTop: paddingTop, paddingRight: paddingRight + 20, stackedBar: stackedBar, verticalLabelsHeightPercentage: verticalLabelsHeightPercentage }))} + + {showLegend && + this.renderLegend(__assign(__assign({}, config), { legend: data.legend, colors: this.props.data.barColors }))} + + ); + }; + return StackedBarChart; +}(AbstractChart)); +export default StackedBarChart; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StackedBarChart.js","sourceRoot":"","sources":["../src/StackedBarChart.tsx"],"names":[],"mappings":"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","sourcesContent":["import React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport { G, Rect, Svg, Text } from \"react-native-svg\";\n\nimport AbstractChart, {\n  AbstractChartConfig,\n  AbstractChartProps,\n  DEFAULT_X_LABELS_HEIGHT_PERCENTAGE\n} from \"./AbstractChart\";\n\nexport interface StackedBarChartData {\n  labels: string[];\n  legend: string[];\n  data: number[][];\n  barColors: string[];\n}\n\nexport interface StackedBarChartProps extends AbstractChartProps {\n  /**\n   * E.g.\n   * ```javascript\n   * const data = {\n   *   labels: [\"Test1\", \"Test2\"],\n   *   legend: [\"L1\", \"L2\", \"L3\"],\n   *   data: [[60, 60, 60], [30, 30, 60]],\n   *   barColors: [\"#dfe4ea\", \"#ced6e0\", \"#a4b0be\"]\n   * };\n   * ```\n   */\n  data: StackedBarChartData;\n  width: number;\n  height: number;\n  chartConfig: AbstractChartConfig;\n  hideLegend: boolean;\n  style?: Partial<ViewStyle>;\n  barPercentage?: number;\n  decimalPlaces?: number;\n  /**\n   * Show vertical labels - default: True.\n   */\n  withVerticalLabels?: boolean;\n  /**\n   * Show horizontal labels - default: True.\n   */\n  withHorizontalLabels?: boolean;\n  /**\n   * The number of horizontal lines\n   */\n  segments?: number;\n\n  percentile?: boolean;\n\n  /**\n   * Percentage of the chart height, dedicated to vertical labels\n   * (space below chart)\n   */\n  verticalLabelsHeightPercentage?: number;\n\n  formatYLabel?: (yLabel: string) => string;\n}\n\ntype StackedBarChartState = {};\n\nclass StackedBarChart extends AbstractChart<\n  StackedBarChartProps,\n  StackedBarChartState\n> {\n  getBarPercentage = () => {\n    const { barPercentage = 1 } = this.props.chartConfig;\n    return barPercentage;\n  };\n\n  getBarRadius = (ret: string | any[], x: string | any[]) => {\n    return this.props.chartConfig.barRadius && ret.length === x.length - 1\n      ? this.props.chartConfig.barRadius\n      : 0;\n  };\n\n  renderBars = ({\n    data,\n    width,\n    height,\n    paddingTop,\n    paddingRight,\n    border,\n    colors,\n    stackedBar = false,\n    verticalLabelsHeightPercentage\n  }: Pick<\n    Omit<AbstractChartConfig, \"data\">,\n    | \"width\"\n    | \"height\"\n    | \"paddingRight\"\n    | \"paddingTop\"\n    | \"stackedBar\"\n    | \"verticalLabelsHeightPercentage\"\n  > & {\n    border: number;\n    colors: string[];\n    data: number[][];\n  }) =>\n    data.map((x, i) => {\n      const barWidth = 32 * this.getBarPercentage();\n      const ret = [];\n      let h = 0;\n      let st = paddingTop;\n\n      let fac = 1;\n      if (stackedBar) {\n        fac = 0.7;\n      }\n      const sum = this.props.percentile ? x.reduce((a, b) => a + b, 0) : border;\n      const barsAreaHeight = height * verticalLabelsHeightPercentage;\n      for (let z = 0; z < x.length; z++) {\n        h = barsAreaHeight * (x[z] / sum);\n        const y = barsAreaHeight - h + st;\n        const xC =\n          (paddingRight +\n            (i * (width - paddingRight)) / data.length +\n            barWidth / 2) *\n          fac;\n\n        ret.push(\n          <Rect\n            key={Math.random()}\n            x={xC}\n            y={y}\n            rx={this.getBarRadius(ret, x)}\n            ry={this.getBarRadius(ret, x)}\n            width={barWidth}\n            height={h}\n            fill={colors[z]}\n          />\n        );\n\n        if (!this.props.hideLegend) {\n          ret.push(\n            <Text\n              key={Math.random()}\n              x={xC + 7 + barWidth / 2}\n              textAnchor=\"end\"\n              y={h > 15 ? y + 15 : y + 7}\n              {...this.getPropsForLabels()}\n            >\n              {x[z]}\n            </Text>\n          );\n        }\n\n        st -= h;\n      }\n\n      return ret;\n    });\n\n  renderLegend = ({\n    legend,\n    colors,\n    width,\n    height\n  }: Pick<AbstractChartConfig, \"width\" | \"height\"> & {\n    legend: string[];\n    colors: string[];\n  }) =>\n    legend.map((x, i) => {\n      return (\n        <G key={Math.random()}>\n          <Rect\n            width=\"16px\"\n            height=\"16px\"\n            fill={colors[i]}\n            rx={8}\n            ry={8}\n            x={width * 0.71}\n            y={height * 0.7 - i * 50}\n          />\n          <Text\n            x={width * 0.78}\n            y={height * 0.76 - i * 50}\n            {...this.getPropsForLabels()}\n          >\n            {x}\n          </Text>\n        </G>\n      );\n    });\n\n  render() {\n    const paddingTop = 15;\n    const paddingRight = 50;\n    const barWidth = 32 * this.getBarPercentage();\n\n    const {\n      width,\n      height,\n      style = {},\n      data,\n      withHorizontalLabels = true,\n      withVerticalLabels = true,\n      segments = 4,\n      decimalPlaces,\n      percentile = false,\n      verticalLabelsHeightPercentage = DEFAULT_X_LABELS_HEIGHT_PERCENTAGE,\n      formatYLabel = (yLabel: string) => {\n        return yLabel;\n      },\n      hideLegend = false\n    } = this.props;\n\n    const { borderRadius = 0 } = style;\n    const config = {\n      width,\n      height\n    };\n\n    let border = 0;\n\n    let max = 0;\n    for (let i = 0; i < data.data.length; i++) {\n      const actual = data.data[i].reduce((pv, cv) => pv + cv, 0);\n      if (actual > max) {\n        max = actual;\n      }\n    }\n\n    if (percentile) {\n      border = 100;\n    } else {\n      border = max;\n    }\n\n    const showLegend = !hideLegend && data.legend && data.legend.length != 0;\n    const stackedBar = showLegend;\n\n    return (\n      <View style={style}>\n        <Svg height={height} width={width}>\n          {this.renderDefs({\n            ...config,\n            ...this.props.chartConfig\n          })}\n          <Rect\n            width=\"100%\"\n            height={height}\n            rx={Number(borderRadius)}\n            ry={Number(borderRadius)}\n            fill=\"url(#backgroundGradient)\"\n          />\n          <G>\n            {this.renderHorizontalLines({\n              ...config,\n              count: segments,\n              paddingTop,\n              verticalLabelsHeightPercentage\n            })}\n          </G>\n          <G>\n            {withHorizontalLabels\n              ? this.renderHorizontalLabels({\n                  ...config,\n                  count: segments,\n                  data: [0, border],\n                  paddingTop,\n                  paddingRight,\n                  decimalPlaces,\n                  verticalLabelsHeightPercentage,\n                  formatYLabel\n                })\n              : null}\n          </G>\n          <G>\n            {withVerticalLabels\n              ? this.renderVerticalLabels({\n                  ...config,\n                  labels: data.labels,\n                  paddingRight: paddingRight + 28,\n                  stackedBar,\n                  paddingTop,\n                  horizontalOffset: barWidth,\n                  verticalLabelsHeightPercentage\n                })\n              : null}\n          </G>\n          <G>\n            {this.renderBars({\n              ...config,\n              data: data.data,\n              border,\n              colors: this.props.data.barColors,\n              paddingTop,\n              paddingRight: paddingRight + 20,\n              stackedBar,\n              verticalLabelsHeightPercentage\n            })}\n          </G>\n          {showLegend &&\n            this.renderLegend({\n              ...config,\n              legend: data.legend,\n              colors: this.props.data.barColors\n            })}\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default StackedBarChart;\n"]} \ No newline at end of file diff --git a/dist/TextWidthFinder.d.ts b/dist/TextWidthFinder.d.ts new file mode 100644 index 00000000..a965f0b7 --- /dev/null +++ b/dist/TextWidthFinder.d.ts @@ -0,0 +1 @@ +//# sourceMappingURL=TextWidthFinder.d.ts.map \ No newline at end of file diff --git a/dist/TextWidthFinder.d.ts.map b/dist/TextWidthFinder.d.ts.map new file mode 100644 index 00000000..b150c7a3 --- /dev/null +++ b/dist/TextWidthFinder.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"TextWidthFinder.d.ts","sourceRoot":"","sources":["../src/TextWidthFinder.tsx"],"names":[],"mappings":""} \ No newline at end of file diff --git a/dist/TextWidthFinder.js b/dist/TextWidthFinder.js new file mode 100644 index 00000000..bd441034 --- /dev/null +++ b/dist/TextWidthFinder.js @@ -0,0 +1,19 @@ +// import React, {useEffect, useState} from "react"; +// import { View, ViewStyle, Text } from "react-native"; +// export default function TextWidthFinder( { content }) { +// const [displayValue, setDisplayValue] = useState('flex') +// useEffect(() => { +// console.log('effect') +// }, [displayValue]) +// const onLayout = e => { +// console.log(e); +// console.log(content) +// setDisplayValue('none') +// }; +// return ( +// +// {content} +// +// ); +// } +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVGV4dFdpZHRoRmluZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL1RleHRXaWR0aEZpbmRlci50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0RBQW9EO0FBQ3BELHdEQUF3RDtBQUV4RCwwREFBMEQ7QUFDMUQsNkRBQTZEO0FBRTdELHNCQUFzQjtBQUN0Qiw0QkFBNEI7QUFDNUIsdUJBQXVCO0FBRXZCLDRCQUE0QjtBQUM1QixzQkFBc0I7QUFDdEIsMkJBQTJCO0FBQzNCLDhCQUE4QjtBQUM5QixPQUFPO0FBQ1AsYUFBYTtBQUNiLDBGQUEwRjtBQUMxRiwrQkFBK0I7QUFDL0IsY0FBYztBQUNkLE9BQU87QUFDUCxJQUFJIiwic291cmNlc0NvbnRlbnQiOlsiLy8gaW1wb3J0IFJlYWN0LCB7dXNlRWZmZWN0LCB1c2VTdGF0ZX0gZnJvbSBcInJlYWN0XCI7XG4vLyBpbXBvcnQgeyBWaWV3LCBWaWV3U3R5bGUsIFRleHQgfSBmcm9tIFwicmVhY3QtbmF0aXZlXCI7XG5cbi8vIGV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIFRleHRXaWR0aEZpbmRlciggeyBjb250ZW50IH0pIHtcbi8vICAgY29uc3QgW2Rpc3BsYXlWYWx1ZSwgc2V0RGlzcGxheVZhbHVlXSA9IHVzZVN0YXRlKCdmbGV4JylcblxuLy8gICB1c2VFZmZlY3QoKCkgPT4ge1xuLy8gICAgIGNvbnNvbGUubG9nKCdlZmZlY3QnKVxuLy8gICB9LCBbZGlzcGxheVZhbHVlXSlcblxuLy8gICBjb25zdCBvbkxheW91dCA9IGUgPT4ge1xuLy8gICAgIGNvbnNvbGUubG9nKGUpO1xuLy8gICAgIGNvbnNvbGUubG9nKGNvbnRlbnQpXG4vLyAgICAgc2V0RGlzcGxheVZhbHVlKCdub25lJylcbi8vICAgfTtcbi8vICAgcmV0dXJuIChcbi8vICAgICA8VmlldyBvbkxheW91dD17b25MYXlvdXR9IHN0eWxlPXt7YWxpZ25TZWxmOiAnZmxleC1zdGFydCcsIGRpc3BsYXk6IGRpc3BsYXlWYWx1ZX19PlxuLy8gICAgICAgPFRleHQ+e2NvbnRlbnR9PC9UZXh0PlxuLy8gICAgIDwvVmlldz5cbi8vICAgKTtcbi8vIH1cbiJdfQ== \ No newline at end of file diff --git a/dist/Utils.d.ts b/dist/Utils.d.ts new file mode 100644 index 00000000..e1cce281 --- /dev/null +++ b/dist/Utils.d.ts @@ -0,0 +1,3 @@ +export declare function mapValue(x: number, in_min: number, in_max: number, out_min: number, out_max: number): number; +export declare function hslToRgba(hslString: string): string; +//# sourceMappingURL=Utils.d.ts.map \ No newline at end of file diff --git a/dist/Utils.d.ts.map b/dist/Utils.d.ts.map new file mode 100644 index 00000000..59832dd6 --- /dev/null +++ b/dist/Utils.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Utils.d.ts","sourceRoot":"","sources":["../src/Utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,UAGhB;AAGD,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CA6BnD"} \ No newline at end of file diff --git a/dist/Utils.js b/dist/Utils.js new file mode 100644 index 00000000..9aba9db7 --- /dev/null +++ b/dist/Utils.js @@ -0,0 +1,35 @@ +export function mapValue(x, in_min, in_max, out_min, out_max) { + return ((x - in_min) * (out_max - out_min)) / (in_max - in_min) + out_min; +} +export function hslToRgba(hslString) { + var _a, _b, _c, _d, _e, _f; + var matches = hslString.match(/hsla?\((\d+\.?\d*),\s*(\d+\.?\d*)%,\s*(\d+\.?\d*)%(?:,\s*([\d.]+)\s*)?\)/i); + if (!matches) { + return '#000000'; + } + var h = parseFloat(matches[1]); + var s = parseFloat(matches[2]) / 100; + var l = parseFloat(matches[3]) / 100; + var a = matches[4] ? parseFloat(matches[4]) : 1; + var c = (1 - Math.abs(2 * l - 1)) * s; + var x = c * (1 - Math.abs(((h / 60) % 2) - 1)); + var m = l - c / 2; + var r, g, b; + if (h < 60) + _a = [c, x, 0], r = _a[0], g = _a[1], b = _a[2]; + else if (h < 120) + _b = [x, c, 0], r = _b[0], g = _b[1], b = _b[2]; + else if (h < 180) + _c = [0, c, x], r = _c[0], g = _c[1], b = _c[2]; + else if (h < 240) + _d = [0, x, c], r = _d[0], g = _d[1], b = _d[2]; + else if (h < 300) + _e = [x, 0, c], r = _e[0], g = _e[1], b = _e[2]; + else + _f = [c, 0, x], r = _f[0], g = _f[1], b = _f[2]; + r = Math.round((r + m) * 255); + g = Math.round((g + m) * 255); + b = Math.round((b + m) * 255); + return "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(a, ")"); +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/dist/contribution-graph/ContributionGraph.d.ts b/dist/contribution-graph/ContributionGraph.d.ts new file mode 100644 index 00000000..b8c191a8 --- /dev/null +++ b/dist/contribution-graph/ContributionGraph.d.ts @@ -0,0 +1,62 @@ +import React from "react"; +import { RectProps } from "react-native-svg"; +import AbstractChart from "../AbstractChart"; +import { ContributionGraphProps, ContributionGraphState } from "."; +export type ContributionChartValue = { + value: number; + title: string; + tooltipDataAttrs: TooltipDataAttrs; + date: Date; +}; +export type TooltipDataAttrs = (value: ContributionChartValue) => Partial | Partial; +declare class ContributionGraph extends AbstractChart { + constructor(props: ContributionGraphProps); + UNSAFE_componentWillReceiveProps(nextProps: ContributionGraphProps): void; + getSquareSizeWithGutter(): number; + getMonthLabelSize(): number; + getStartDate(): Date; + getEndDate(): Date; + getStartDateWithEmptyDays(): Date; + getNumEmptyDaysAtStart(): number; + getNumEmptyDaysAtEnd(): number; + getWeekCount(): number; + getWeekWidth(): number; + getWidth(): number; + getHeight(): number; + getValueCache(values: ContributionChartValue[]): { + valueCache: {}; + minValue: number; + maxValue: number; + }; + getValueForIndex(index: number): any; + getClassNameForIndex(index: number): string; + getTitleForIndex(index: number): any; + getTooltipDataAttrsForIndex(index: number): any; + getTooltipDataAttrsForValue(value: ContributionChartValue): Partial; + getTransformForWeek(weekIndex: number): number[]; + getTransformForMonthLabels(): string; + getTransformForAllWeeks(): string; + getViewBox(): string; + getSquareCoordinates(dayIndex: number): number[]; + getMonthLabelCoordinates(weekIndex: number): number[]; + renderSquare(dayIndex: number, index: number): React.JSX.Element; + handleDayPress(index: number): void; + renderWeek(weekIndex: number): React.JSX.Element; + renderAllWeeks(): any; + renderMonthLabels(): any; + static defaultProps: { + numDays: number; + endDate: Date; + gutterSize: number; + squareSize: number; + horizontal: boolean; + showMonthLabels: boolean; + showOutOfRangeDays: boolean; + accessor: string; + classForValue: (value: any) => "black" | "#8cc665"; + style: {}; + }; + render(): React.JSX.Element; +} +export default ContributionGraph; +//# sourceMappingURL=ContributionGraph.d.ts.map \ No newline at end of file diff --git a/dist/contribution-graph/ContributionGraph.d.ts.map b/dist/contribution-graph/ContributionGraph.d.ts.map new file mode 100644 index 00000000..37e69238 --- /dev/null +++ b/dist/contribution-graph/ContributionGraph.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"ContributionGraph.d.ts","sourceRoot":"","sources":["../../src/contribution-graph/ContributionGraph.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAW,SAAS,EAAa,MAAM,kBAAkB,CAAC;AAEjE,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAY7C,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,GAAG,CAAC;AAMnE,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,IAAI,EAAE,IAAI,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAC7B,KAAK,EAAE,sBAAsB,KAC1B,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;AAE7C,cAAM,iBAAkB,SAAQ,aAAa,CAC3C,sBAAsB,EACtB,sBAAsB,CACvB;gBACa,KAAK,EAAE,sBAAsB;IAYzC,gCAAgC,CAAC,SAAS,EAAE,sBAAsB;IAYlE,uBAAuB;IAIvB,iBAAiB;IAWjB,YAAY;IAIZ,UAAU;IAIV,yBAAyB;IAIzB,sBAAsB;IAItB,oBAAoB;IAIpB,YAAY;IAQZ,YAAY;IAIZ,QAAQ;IAOR,SAAS;IAMT,aAAa,CAAC,MAAM,EAAE,sBAAsB,EAAE;;;;;IA+B9C,gBAAgB,CAAC,KAAK,EAAE,MAAM;IAO9B,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAsBlC,gBAAgB,CAAC,KAAK,EAAE,MAAM;IAQ9B,2BAA2B,CAAC,KAAK,EAAE,MAAM;IAWzC,2BAA2B,CAAC,KAAK,EAAE,sBAAsB;IAUzD,mBAAmB,CAAC,SAAS,EAAE,MAAM;IAOrC,0BAA0B;IAO1B,uBAAuB;IAOvB,UAAU;IAOV,oBAAoB,CAAC,QAAQ,EAAE,MAAM;IAOrC,wBAAwB,CAAC,SAAS,EAAE,MAAM;IAc1C,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IA6B5C,cAAc,CAAC,KAAK,EAAE,MAAM;IAiB5B,UAAU,CAAC,SAAS,EAAE,MAAM;IAW5B,cAAc;IAMd,iBAAiB;IA8BjB,OAAc,YAAY;;;;;;;;;;;MAWxB;IAEF,MAAM;CA+BP;AAED,eAAe,iBAAiB,CAAC"} \ No newline at end of file diff --git a/dist/contribution-graph/ContributionGraph.js b/dist/contribution-graph/ContributionGraph.js new file mode 100644 index 00000000..69610274 --- /dev/null +++ b/dist/contribution-graph/ContributionGraph.js @@ -0,0 +1,298 @@ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +import _ from "lodash"; +import React from "react"; +import { View } from "react-native"; +import { G, Rect, Svg, Text } from "react-native-svg"; +import AbstractChart from "../AbstractChart"; +import { mapValue } from "../Utils"; +import { convertToDate, getBeginningTimeForDate, shiftDate } from "./DateHelpers"; +import { DAYS_IN_WEEK, MILLISECONDS_IN_ONE_DAY, MONTH_LABELS } from "./constants"; +var SQUARE_SIZE = 20; +var MONTH_LABEL_GUTTER_SIZE = 8; +var paddingLeft = 32; +var ContributionGraph = /** @class */ (function (_super) { + __extends(ContributionGraph, _super); + function ContributionGraph(props) { + var _this = _super.call(this, props) || this; + var _a = _this.getValueCache(props.values), maxValue = _a.maxValue, minValue = _a.minValue, valueCache = _a.valueCache; + _this.state = { + maxValue: maxValue, + minValue: minValue, + valueCache: valueCache + }; + return _this; + } + ContributionGraph.prototype.UNSAFE_componentWillReceiveProps = function (nextProps) { + var _a = this.getValueCache(nextProps.values), maxValue = _a.maxValue, minValue = _a.minValue, valueCache = _a.valueCache; + this.setState({ + maxValue: maxValue, + minValue: minValue, + valueCache: valueCache + }); + }; + ContributionGraph.prototype.getSquareSizeWithGutter = function () { + return (this.props.squareSize || SQUARE_SIZE) + this.props.gutterSize; + }; + ContributionGraph.prototype.getMonthLabelSize = function () { + var _a = this.props.squareSize, squareSize = _a === void 0 ? SQUARE_SIZE : _a; + if (!this.props.showMonthLabels) { + return 0; + } + if (this.props.horizontal) { + return squareSize + MONTH_LABEL_GUTTER_SIZE; + } + return 2 * (squareSize + MONTH_LABEL_GUTTER_SIZE); + }; + ContributionGraph.prototype.getStartDate = function () { + return shiftDate(this.getEndDate(), -this.props.numDays + 1); // +1 because endDate is inclusive + }; + ContributionGraph.prototype.getEndDate = function () { + return getBeginningTimeForDate(convertToDate(this.props.endDate)); + }; + ContributionGraph.prototype.getStartDateWithEmptyDays = function () { + return shiftDate(this.getStartDate(), -this.getNumEmptyDaysAtStart()); + }; + ContributionGraph.prototype.getNumEmptyDaysAtStart = function () { + return this.getStartDate().getDay(); + }; + ContributionGraph.prototype.getNumEmptyDaysAtEnd = function () { + return DAYS_IN_WEEK - 1 - this.getEndDate().getDay(); + }; + ContributionGraph.prototype.getWeekCount = function () { + var numDaysRoundedToWeek = this.props.numDays + + this.getNumEmptyDaysAtStart() + + this.getNumEmptyDaysAtEnd(); + return Math.ceil(numDaysRoundedToWeek / DAYS_IN_WEEK); + }; + ContributionGraph.prototype.getWeekWidth = function () { + return DAYS_IN_WEEK * this.getSquareSizeWithGutter(); + }; + ContributionGraph.prototype.getWidth = function () { + return (this.getWeekCount() * this.getSquareSizeWithGutter() - + this.props.gutterSize); + }; + ContributionGraph.prototype.getHeight = function () { + return (this.getWeekWidth() + (this.getMonthLabelSize() - this.props.gutterSize)); + }; + ContributionGraph.prototype.getValueCache = function (values) { + var _this = this; + var minValue = Infinity, maxValue = -Infinity; + return { + valueCache: values.reduce(function (memo, value) { + var date = convertToDate(value.date); + var index = Math.floor((date.valueOf() - _this.getStartDateWithEmptyDays().valueOf()) / + MILLISECONDS_IN_ONE_DAY); + minValue = Math.min(value[_this.props.accessor], minValue); + maxValue = Math.max(value[_this.props.accessor], maxValue); + memo[index] = { + value: value, + title: _this.props.titleForValue + ? _this.props.titleForValue(value) + : null, + tooltipDataAttrs: _this.getTooltipDataAttrsForValue(value) + }; + return memo; + }, {}), + minValue: minValue, + maxValue: maxValue + }; + }; + ContributionGraph.prototype.getValueForIndex = function (index) { + if (this.state.valueCache[index]) { + return this.state.valueCache[index].value; + } + return null; + }; + ContributionGraph.prototype.getClassNameForIndex = function (index) { + if (this.state.valueCache[index]) { + if (this.state.valueCache[index].value) { + var count = this.state.valueCache[index].value[this.props.accessor]; + if (count) { + var opacity = mapValue(count, this.state.maxValue === this.state.minValue ? 0 : this.state.minValue, isNaN(this.state.maxValue) ? 1 : this.state.maxValue, 0.15 + 0.05, // + 0.05 to make smaller values a bit more visible + 1); + return this.props.chartConfig.color(opacity); + } + } + } + return this.props.chartConfig.color(0.15); + }; + ContributionGraph.prototype.getTitleForIndex = function (index) { + if (this.state.valueCache[index]) { + return this.state.valueCache[index].title; + } + return this.props.titleForValue ? this.props.titleForValue(null) : null; + }; + ContributionGraph.prototype.getTooltipDataAttrsForIndex = function (index) { + var _a; + if (this.state.valueCache[index]) { + return this.state.valueCache[index].tooltipDataAttrs; + } + return this.getTooltipDataAttrsForValue((_a = { + date: null + }, + _a[this.props.accessor] = null, + _a)); + }; + ContributionGraph.prototype.getTooltipDataAttrsForValue = function (value) { + var tooltipDataAttrs = this.props.tooltipDataAttrs; + if (typeof tooltipDataAttrs === "function") { + return tooltipDataAttrs(value); + } + return tooltipDataAttrs; + }; + ContributionGraph.prototype.getTransformForWeek = function (weekIndex) { + if (this.props.horizontal) { + return [weekIndex * this.getSquareSizeWithGutter(), 50]; + } + return [10, weekIndex * this.getSquareSizeWithGutter()]; + }; + ContributionGraph.prototype.getTransformForMonthLabels = function () { + if (this.props.horizontal) { + return null; + } + return "".concat(this.getWeekWidth() + MONTH_LABEL_GUTTER_SIZE, ", 0"); + }; + ContributionGraph.prototype.getTransformForAllWeeks = function () { + if (this.props.horizontal) { + return "0, ".concat(this.getMonthLabelSize() - 100); + } + return null; + }; + ContributionGraph.prototype.getViewBox = function () { + if (this.props.horizontal) { + return "".concat(this.getWidth(), " ").concat(this.getHeight()); + } + return "".concat(this.getHeight(), " ").concat(this.getWidth()); + }; + ContributionGraph.prototype.getSquareCoordinates = function (dayIndex) { + if (this.props.horizontal) { + return [0, dayIndex * this.getSquareSizeWithGutter()]; + } + return [dayIndex * this.getSquareSizeWithGutter(), 0]; + }; + ContributionGraph.prototype.getMonthLabelCoordinates = function (weekIndex) { + if (this.props.horizontal) { + return [ + weekIndex * this.getSquareSizeWithGutter(), + this.getMonthLabelSize() - MONTH_LABEL_GUTTER_SIZE + ]; + } + var verticalOffset = -2; + return [ + 0, + (weekIndex + 1) * this.getSquareSizeWithGutter() + verticalOffset + ]; + }; + ContributionGraph.prototype.renderSquare = function (dayIndex, index) { + var _this = this; + var indexOutOfRange = index < this.getNumEmptyDaysAtStart() || + index >= this.getNumEmptyDaysAtStart() + this.props.numDays; + if (indexOutOfRange && !this.props.showOutOfRangeDays) { + return null; + } + var _a = this.getSquareCoordinates(dayIndex), x = _a[0], y = _a[1]; + var _b = this.props.squareSize, squareSize = _b === void 0 ? SQUARE_SIZE : _b; + return (); + }; + ContributionGraph.prototype.handleDayPress = function (index) { + var _a; + if (!this.props.onDayPress) { + return; + } + this.props.onDayPress(this.state.valueCache[index] && this.state.valueCache[index].value + ? this.state.valueCache[index].value + : (_a = {}, + _a[this.props.accessor] = 0, + _a.date = new Date(this.getStartDate().valueOf() + index * MILLISECONDS_IN_ONE_DAY), + _a)); + }; + ContributionGraph.prototype.renderWeek = function (weekIndex) { + var _this = this; + var _a = this.getTransformForWeek(weekIndex), x = _a[0], y = _a[1]; + return ( + {_.range(DAYS_IN_WEEK).map(function (dayIndex) { + return _this.renderSquare(dayIndex, weekIndex * DAYS_IN_WEEK + dayIndex); + })} + ); + }; + ContributionGraph.prototype.renderAllWeeks = function () { + var _this = this; + return _.range(this.getWeekCount()).map(function (weekIndex) { + return _this.renderWeek(weekIndex); + }); + }; + ContributionGraph.prototype.renderMonthLabels = function () { + var _this = this; + if (!this.props.showMonthLabels) { + return null; + } + var weekRange = _.range(this.getWeekCount() - 1); // don't render for last week, because label will be cut off + return weekRange.map(function (weekIndex) { + var endOfWeek = shiftDate(_this.getStartDateWithEmptyDays(), (weekIndex + 1) * DAYS_IN_WEEK); + var _a = _this.getMonthLabelCoordinates(weekIndex), x = _a[0], y = _a[1]; + return endOfWeek.getDate() >= 1 && endOfWeek.getDate() <= DAYS_IN_WEEK ? ( + {_this.props.getMonthLabel + ? _this.props.getMonthLabel(endOfWeek.getMonth()) + : MONTH_LABELS[endOfWeek.getMonth()]} + ) : null; + }); + }; + ContributionGraph.prototype.render = function () { + var style = this.props.style; + var _a = style.borderRadius, borderRadius = _a === void 0 ? 0 : _a; + if (!borderRadius && this.props.chartConfig.style) { + var stupidXo = this.props.chartConfig.style.borderRadius; + borderRadius = stupidXo; + } + return ( + + {this.renderDefs(__assign({ width: this.props.width, height: this.props.height }, this.props.chartConfig))} + + {this.renderMonthLabels()} + {this.renderAllWeeks()} + + ); + }; + ContributionGraph.defaultProps = { + numDays: 200, + endDate: new Date(), + gutterSize: 1, + squareSize: SQUARE_SIZE, + horizontal: true, + showMonthLabels: true, + showOutOfRangeDays: false, + accessor: "count", + classForValue: function (value) { return (value ? "black" : "#8cc665"); }, + style: {} + }; + return ContributionGraph; +}(AbstractChart)); +export default ContributionGraph; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ContributionGraph.js","sourceRoot":"","sources":["../../src/contribution-graph/ContributionGraph.tsx"],"names":[],"mappings":"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","sourcesContent":["import _ from \"lodash\";\nimport React from \"react\";\nimport { View } from \"react-native\";\nimport { G, Rect, RectProps, Svg, Text } from \"react-native-svg\";\n\nimport AbstractChart from \"../AbstractChart\";\nimport { mapValue } from \"../Utils\";\nimport {\n  convertToDate,\n  getBeginningTimeForDate,\n  shiftDate\n} from \"./DateHelpers\";\nimport {\n  DAYS_IN_WEEK,\n  MILLISECONDS_IN_ONE_DAY,\n  MONTH_LABELS\n} from \"./constants\";\nimport { ContributionGraphProps, ContributionGraphState } from \".\";\n\nconst SQUARE_SIZE = 20;\nconst MONTH_LABEL_GUTTER_SIZE = 8;\nconst paddingLeft = 32;\n\nexport type ContributionChartValue = {\n  value: number;\n  title: string;\n  tooltipDataAttrs: TooltipDataAttrs;\n  date: Date;\n};\n\nexport type TooltipDataAttrs = (\n  value: ContributionChartValue\n) => Partial<RectProps> | Partial<RectProps>;\n\nclass ContributionGraph extends AbstractChart<\n  ContributionGraphProps,\n  ContributionGraphState\n> {\n  constructor(props: ContributionGraphProps) {\n    super(props);\n\n    let { maxValue, minValue, valueCache } = this.getValueCache(props.values);\n\n    this.state = {\n      maxValue,\n      minValue,\n      valueCache\n    };\n  }\n\n  UNSAFE_componentWillReceiveProps(nextProps: ContributionGraphProps) {\n    let { maxValue, minValue, valueCache } = this.getValueCache(\n      nextProps.values\n    );\n\n    this.setState({\n      maxValue,\n      minValue,\n      valueCache\n    });\n  }\n\n  getSquareSizeWithGutter() {\n    return (this.props.squareSize || SQUARE_SIZE) + this.props.gutterSize;\n  }\n\n  getMonthLabelSize() {\n    let { squareSize = SQUARE_SIZE } = this.props;\n    if (!this.props.showMonthLabels) {\n      return 0;\n    }\n    if (this.props.horizontal) {\n      return squareSize + MONTH_LABEL_GUTTER_SIZE;\n    }\n    return 2 * (squareSize + MONTH_LABEL_GUTTER_SIZE);\n  }\n\n  getStartDate() {\n    return shiftDate(this.getEndDate(), -this.props.numDays + 1); // +1 because endDate is inclusive\n  }\n\n  getEndDate() {\n    return getBeginningTimeForDate(convertToDate(this.props.endDate));\n  }\n\n  getStartDateWithEmptyDays() {\n    return shiftDate(this.getStartDate(), -this.getNumEmptyDaysAtStart());\n  }\n\n  getNumEmptyDaysAtStart() {\n    return this.getStartDate().getDay();\n  }\n\n  getNumEmptyDaysAtEnd() {\n    return DAYS_IN_WEEK - 1 - this.getEndDate().getDay();\n  }\n\n  getWeekCount() {\n    const numDaysRoundedToWeek =\n      this.props.numDays +\n      this.getNumEmptyDaysAtStart() +\n      this.getNumEmptyDaysAtEnd();\n    return Math.ceil(numDaysRoundedToWeek / DAYS_IN_WEEK);\n  }\n\n  getWeekWidth() {\n    return DAYS_IN_WEEK * this.getSquareSizeWithGutter();\n  }\n\n  getWidth() {\n    return (\n      this.getWeekCount() * this.getSquareSizeWithGutter() -\n      this.props.gutterSize\n    );\n  }\n\n  getHeight() {\n    return (\n      this.getWeekWidth() + (this.getMonthLabelSize() - this.props.gutterSize)\n    );\n  }\n\n  getValueCache(values: ContributionChartValue[]) {\n    let minValue = Infinity,\n      maxValue = -Infinity;\n\n    return {\n      valueCache: values.reduce((memo, value) => {\n        const date = convertToDate(value.date);\n\n        const index = Math.floor(\n          (date.valueOf() - this.getStartDateWithEmptyDays().valueOf()) /\n            MILLISECONDS_IN_ONE_DAY\n        );\n\n        minValue = Math.min(value[this.props.accessor], minValue);\n        maxValue = Math.max(value[this.props.accessor], maxValue);\n\n        memo[index] = {\n          value,\n          title: this.props.titleForValue\n            ? this.props.titleForValue(value)\n            : null,\n          tooltipDataAttrs: this.getTooltipDataAttrsForValue(value)\n        };\n\n        return memo;\n      }, {}),\n      minValue,\n      maxValue\n    };\n  }\n\n  getValueForIndex(index: number) {\n    if (this.state.valueCache[index]) {\n      return this.state.valueCache[index].value;\n    }\n    return null;\n  }\n\n  getClassNameForIndex(index: number) {\n    if (this.state.valueCache[index]) {\n      if (this.state.valueCache[index].value) {\n        const count = this.state.valueCache[index].value[this.props.accessor];\n\n        if (count) {\n          const opacity = mapValue(\n            count,\n            this.state.maxValue === this.state.minValue ? 0: this.state.minValue,\n            isNaN(this.state.maxValue) ? 1 : this.state.maxValue,\n            0.15 + 0.05, // + 0.05 to make smaller values a bit more visible\n            1\n          );\n\n          return this.props.chartConfig.color(opacity);\n        }\n      }\n    }\n\n    return this.props.chartConfig.color(0.15);\n  }\n\n  getTitleForIndex(index: number) {\n    if (this.state.valueCache[index]) {\n      return this.state.valueCache[index].title;\n    }\n\n    return this.props.titleForValue ? this.props.titleForValue(null) : null;\n  }\n\n  getTooltipDataAttrsForIndex(index: number) {\n    if (this.state.valueCache[index]) {\n      return this.state.valueCache[index].tooltipDataAttrs;\n    }\n\n    return this.getTooltipDataAttrsForValue({\n      date: null,\n      [this.props.accessor]: null\n    } as ContributionChartValue);\n  }\n\n  getTooltipDataAttrsForValue(value: ContributionChartValue) {\n    const { tooltipDataAttrs } = this.props;\n\n    if (typeof tooltipDataAttrs === \"function\") {\n      return tooltipDataAttrs(value);\n    }\n\n    return tooltipDataAttrs;\n  }\n\n  getTransformForWeek(weekIndex: number) {\n    if (this.props.horizontal) {\n      return [weekIndex * this.getSquareSizeWithGutter(), 50];\n    }\n    return [10, weekIndex * this.getSquareSizeWithGutter()];\n  }\n\n  getTransformForMonthLabels() {\n    if (this.props.horizontal) {\n      return null;\n    }\n    return `${this.getWeekWidth() + MONTH_LABEL_GUTTER_SIZE}, 0`;\n  }\n\n  getTransformForAllWeeks() {\n    if (this.props.horizontal) {\n      return `0, ${this.getMonthLabelSize() - 100}`;\n    }\n    return null;\n  }\n\n  getViewBox() {\n    if (this.props.horizontal) {\n      return `${this.getWidth()} ${this.getHeight()}`;\n    }\n    return `${this.getHeight()} ${this.getWidth()}`;\n  }\n\n  getSquareCoordinates(dayIndex: number) {\n    if (this.props.horizontal) {\n      return [0, dayIndex * this.getSquareSizeWithGutter()];\n    }\n    return [dayIndex * this.getSquareSizeWithGutter(), 0];\n  }\n\n  getMonthLabelCoordinates(weekIndex: number) {\n    if (this.props.horizontal) {\n      return [\n        weekIndex * this.getSquareSizeWithGutter(),\n        this.getMonthLabelSize() - MONTH_LABEL_GUTTER_SIZE\n      ];\n    }\n    const verticalOffset = -2;\n    return [\n      0,\n      (weekIndex + 1) * this.getSquareSizeWithGutter() + verticalOffset\n    ];\n  }\n\n  renderSquare(dayIndex: number, index: number) {\n    const indexOutOfRange =\n      index < this.getNumEmptyDaysAtStart() ||\n      index >= this.getNumEmptyDaysAtStart() + this.props.numDays;\n\n    if (indexOutOfRange && !this.props.showOutOfRangeDays) {\n      return null;\n    }\n\n    const [x, y] = this.getSquareCoordinates(dayIndex);\n    const { squareSize = SQUARE_SIZE } = this.props;\n\n    return (\n      <Rect\n        key={index}\n        width={squareSize}\n        height={squareSize}\n        x={x + paddingLeft}\n        y={y}\n        title={this.getTitleForIndex(index)}\n        fill={this.getClassNameForIndex(index)}\n        onPress={() => {\n          this.handleDayPress(index);\n        }}\n        {...this.getTooltipDataAttrsForIndex(index)}\n      />\n    );\n  }\n\n  handleDayPress(index: number) {\n    if (!this.props.onDayPress) {\n      return;\n    }\n\n    this.props.onDayPress(\n      this.state.valueCache[index] && this.state.valueCache[index].value\n        ? this.state.valueCache[index].value\n        : {\n            [this.props.accessor]: 0,\n            date: new Date(\n              this.getStartDate().valueOf() + index * MILLISECONDS_IN_ONE_DAY\n            )\n          }\n    );\n  }\n\n  renderWeek(weekIndex: number) {\n    const [x, y] = this.getTransformForWeek(weekIndex);\n    return (\n      <G key={weekIndex} x={x} y={y}>\n        {_.range(DAYS_IN_WEEK).map(dayIndex =>\n          this.renderSquare(dayIndex, weekIndex * DAYS_IN_WEEK + dayIndex)\n        )}\n      </G>\n    );\n  }\n\n  renderAllWeeks() {\n    return _.range(this.getWeekCount()).map(weekIndex =>\n      this.renderWeek(weekIndex)\n    );\n  }\n\n  renderMonthLabels() {\n    if (!this.props.showMonthLabels) {\n      return null;\n    }\n\n    const weekRange = _.range(this.getWeekCount() - 1); // don't render for last week, because label will be cut off\n\n    return weekRange.map(weekIndex => {\n      const endOfWeek = shiftDate(\n        this.getStartDateWithEmptyDays(),\n        (weekIndex + 1) * DAYS_IN_WEEK\n      );\n\n      const [x, y] = this.getMonthLabelCoordinates(weekIndex);\n\n      return endOfWeek.getDate() >= 1 && endOfWeek.getDate() <= DAYS_IN_WEEK ? (\n        <Text\n          key={weekIndex}\n          x={x + paddingLeft}\n          y={y + 8}\n          {...this.getPropsForLabels()}\n        >\n          {this.props.getMonthLabel\n            ? this.props.getMonthLabel(endOfWeek.getMonth())\n            : MONTH_LABELS[endOfWeek.getMonth()]}\n        </Text>\n      ) : null;\n    });\n  }\n\n  public static defaultProps = {\n    numDays: 200,\n    endDate: new Date(),\n    gutterSize: 1,\n    squareSize: SQUARE_SIZE,\n    horizontal: true,\n    showMonthLabels: true,\n    showOutOfRangeDays: false,\n    accessor: \"count\",\n    classForValue: value => (value ? \"black\" : \"#8cc665\"),\n    style: {}\n  };\n\n  render() {\n    const { style } = this.props;\n\n    let { borderRadius = 0 } = style;\n\n    if (!borderRadius && this.props.chartConfig.style) {\n      const stupidXo = this.props.chartConfig.style.borderRadius;\n      borderRadius = stupidXo;\n    }\n\n    return (\n      <View style={style}>\n        <Svg height={this.props.height} width={this.props.width}>\n          {this.renderDefs({\n            width: this.props.width,\n            height: this.props.height,\n            ...this.props.chartConfig\n          })}\n          <Rect\n            width=\"100%\"\n            height={this.props.height}\n            rx={Number(borderRadius)}\n            ry={Number(borderRadius)}\n            fill=\"url(#backgroundGradient)\"\n          />\n          <G>{this.renderMonthLabels()}</G>\n          <G>{this.renderAllWeeks()}</G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default ContributionGraph;\n"]} \ No newline at end of file diff --git a/dist/contribution-graph/DateHelpers.d.ts b/dist/contribution-graph/DateHelpers.d.ts new file mode 100644 index 00000000..e2264678 --- /dev/null +++ b/dist/contribution-graph/DateHelpers.d.ts @@ -0,0 +1,4 @@ +export declare function shiftDate(date: Date, numDays: number): Date; +export declare function getBeginningTimeForDate(date: Date): Date; +export declare function convertToDate(obj: string | number | Date): Date; +//# sourceMappingURL=DateHelpers.d.ts.map \ No newline at end of file diff --git a/dist/contribution-graph/DateHelpers.d.ts.map b/dist/contribution-graph/DateHelpers.d.ts.map new file mode 100644 index 00000000..3377ff47 --- /dev/null +++ b/dist/contribution-graph/DateHelpers.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"DateHelpers.d.ts","sourceRoot":"","sources":["../../src/contribution-graph/DateHelpers.ts"],"names":[],"mappings":"AACA,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,QAIpD;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,QAEjD;AAGD,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,QAExD"} \ No newline at end of file diff --git a/dist/contribution-graph/DateHelpers.js b/dist/contribution-graph/DateHelpers.js new file mode 100644 index 00000000..da306162 --- /dev/null +++ b/dist/contribution-graph/DateHelpers.js @@ -0,0 +1,14 @@ +// returns a new date shifted a certain number of days (can be negative) +export function shiftDate(date, numDays) { + var newDate = new Date(date); + newDate.setDate(newDate.getDate() + numDays); + return newDate; +} +export function getBeginningTimeForDate(date) { + return new Date(date.getFullYear(), date.getMonth(), date.getDate()); +} +// obj can be a parseable string, a millisecond timestamp, or a Date object +export function convertToDate(obj) { + return obj instanceof Date ? obj : new Date(obj); +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGF0ZUhlbHBlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJpYnV0aW9uLWdyYXBoL0RhdGVIZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHdFQUF3RTtBQUN4RSxNQUFNLFVBQVUsU0FBUyxDQUFDLElBQVUsRUFBRSxPQUFlO0lBQ25ELElBQU0sT0FBTyxHQUFHLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQy9CLE9BQU8sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxHQUFHLE9BQU8sQ0FBQyxDQUFDO0lBQzdDLE9BQU8sT0FBTyxDQUFDO0FBQ2pCLENBQUM7QUFFRCxNQUFNLFVBQVUsdUJBQXVCLENBQUMsSUFBVTtJQUNoRCxPQUFPLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsRUFBRSxJQUFJLENBQUMsUUFBUSxFQUFFLEVBQUUsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7QUFDdkUsQ0FBQztBQUVELDJFQUEyRTtBQUMzRSxNQUFNLFVBQVUsYUFBYSxDQUFDLEdBQTJCO0lBQ3ZELE9BQU8sR0FBRyxZQUFZLElBQUksQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNuRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gcmV0dXJucyBhIG5ldyBkYXRlIHNoaWZ0ZWQgYSBjZXJ0YWluIG51bWJlciBvZiBkYXlzIChjYW4gYmUgbmVnYXRpdmUpXG5leHBvcnQgZnVuY3Rpb24gc2hpZnREYXRlKGRhdGU6IERhdGUsIG51bURheXM6IG51bWJlcikge1xuICBjb25zdCBuZXdEYXRlID0gbmV3IERhdGUoZGF0ZSk7XG4gIG5ld0RhdGUuc2V0RGF0ZShuZXdEYXRlLmdldERhdGUoKSArIG51bURheXMpO1xuICByZXR1cm4gbmV3RGF0ZTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldEJlZ2lubmluZ1RpbWVGb3JEYXRlKGRhdGU6IERhdGUpIHtcbiAgcmV0dXJuIG5ldyBEYXRlKGRhdGUuZ2V0RnVsbFllYXIoKSwgZGF0ZS5nZXRNb250aCgpLCBkYXRlLmdldERhdGUoKSk7XG59XG5cbi8vIG9iaiBjYW4gYmUgYSBwYXJzZWFibGUgc3RyaW5nLCBhIG1pbGxpc2Vjb25kIHRpbWVzdGFtcCwgb3IgYSBEYXRlIG9iamVjdFxuZXhwb3J0IGZ1bmN0aW9uIGNvbnZlcnRUb0RhdGUob2JqOiBzdHJpbmcgfCBudW1iZXIgfCBEYXRlKSB7XG4gIHJldHVybiBvYmogaW5zdGFuY2VvZiBEYXRlID8gb2JqIDogbmV3IERhdGUob2JqKTtcbn1cbiJdfQ== \ No newline at end of file diff --git a/dist/contribution-graph/constants.d.ts b/dist/contribution-graph/constants.d.ts new file mode 100644 index 00000000..8b779037 --- /dev/null +++ b/dist/contribution-graph/constants.d.ts @@ -0,0 +1,17 @@ +export declare const MILLISECONDS_IN_ONE_DAY: number; +export declare const DAYS_IN_WEEK = 7; +export declare const MONTH_LABELS: { + 0: string; + 1: string; + 2: string; + 3: string; + 4: string; + 5: string; + 6: string; + 7: string; + 8: string; + 9: string; + 10: string; + 11: string; +}; +//# sourceMappingURL=constants.d.ts.map \ No newline at end of file diff --git a/dist/contribution-graph/constants.d.ts.map b/dist/contribution-graph/constants.d.ts.map new file mode 100644 index 00000000..a6c65653 --- /dev/null +++ b/dist/contribution-graph/constants.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/contribution-graph/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,QAAsB,CAAC;AAE3D,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,eAAO,MAAM,YAAY;;;;;;;;;;;;;CAaxB,CAAC"} \ No newline at end of file diff --git a/dist/contribution-graph/constants.js b/dist/contribution-graph/constants.js new file mode 100644 index 00000000..7bc386b2 --- /dev/null +++ b/dist/contribution-graph/constants.js @@ -0,0 +1,17 @@ +export var MILLISECONDS_IN_ONE_DAY = 24 * 60 * 60 * 1000; +export var DAYS_IN_WEEK = 7; +export var MONTH_LABELS = { + 0: "Jan", + 1: "Feb", + 2: "Mar", + 3: "Apr", + 4: "May", + 5: "Jun", + 6: "Jul", + 7: "Aug", + 8: "Sep", + 9: "Oct", + 10: "Nov", + 11: "Dec" +}; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyaWJ1dGlvbi1ncmFwaC9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLElBQU0sdUJBQXVCLEdBQUcsRUFBRSxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDO0FBRTNELE1BQU0sQ0FBQyxJQUFNLFlBQVksR0FBRyxDQUFDLENBQUM7QUFFOUIsTUFBTSxDQUFDLElBQU0sWUFBWSxHQUFHO0lBQzFCLENBQUMsRUFBRSxLQUFLO0lBQ1IsQ0FBQyxFQUFFLEtBQUs7SUFDUixDQUFDLEVBQUUsS0FBSztJQUNSLENBQUMsRUFBRSxLQUFLO0lBQ1IsQ0FBQyxFQUFFLEtBQUs7SUFDUixDQUFDLEVBQUUsS0FBSztJQUNSLENBQUMsRUFBRSxLQUFLO0lBQ1IsQ0FBQyxFQUFFLEtBQUs7SUFDUixDQUFDLEVBQUUsS0FBSztJQUNSLENBQUMsRUFBRSxLQUFLO0lBQ1IsRUFBRSxFQUFFLEtBQUs7SUFDVCxFQUFFLEVBQUUsS0FBSztDQUNWLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgTUlMTElTRUNPTkRTX0lOX09ORV9EQVkgPSAyNCAqIDYwICogNjAgKiAxMDAwO1xuXG5leHBvcnQgY29uc3QgREFZU19JTl9XRUVLID0gNztcblxuZXhwb3J0IGNvbnN0IE1PTlRIX0xBQkVMUyA9IHtcbiAgMDogXCJKYW5cIixcbiAgMTogXCJGZWJcIixcbiAgMjogXCJNYXJcIixcbiAgMzogXCJBcHJcIixcbiAgNDogXCJNYXlcIixcbiAgNTogXCJKdW5cIixcbiAgNjogXCJKdWxcIixcbiAgNzogXCJBdWdcIixcbiAgODogXCJTZXBcIixcbiAgOTogXCJPY3RcIixcbiAgMTA6IFwiTm92XCIsXG4gIDExOiBcIkRlY1wiXG59O1xuIl19 \ No newline at end of file diff --git a/dist/contribution-graph/index.d.ts b/dist/contribution-graph/index.d.ts new file mode 100644 index 00000000..79669fdb --- /dev/null +++ b/dist/contribution-graph/index.d.ts @@ -0,0 +1,32 @@ +import { ViewStyle } from "react-native"; +import { AbstractChartProps } from "../AbstractChart"; +import ContributionGraph, { ContributionChartValue, TooltipDataAttrs } from "./ContributionGraph"; +export interface ContributionGraphProps extends AbstractChartProps { + values: Array; + endDate: Date; + numDays: number; + width: number; + height: number; + gutterSize?: number; + squareSize?: number; + horizontal?: boolean; + showMonthLabels?: boolean; + showOutOfRangeDays?: boolean; + accessor?: string; + getMonthLabel?: (monthIndex: number) => string; + onDayPress?: (data: { + count: number; + date: Date; + }) => void; + classForValue?: (value: string) => string; + style?: Partial; + titleForValue?: (value: ContributionChartValue) => string; + tooltipDataAttrs: TooltipDataAttrs; +} +export type ContributionGraphState = { + maxValue: number; + minValue: number; + valueCache: object; +}; +export default ContributionGraph; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/dist/contribution-graph/index.d.ts.map b/dist/contribution-graph/index.d.ts.map new file mode 100644 index 00000000..6859f099 --- /dev/null +++ b/dist/contribution-graph/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contribution-graph/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,iBAAiB,EAAE,EACxB,sBAAsB,EACtB,gBAAgB,EACjB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,sBAAuB,SAAQ,kBAAkB;IAChE,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACnB,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;IAC/C,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAE,KAAK,IAAI,CAAC;IAC3D,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC3B,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,MAAM,CAAC;IAC1D,gBAAgB,EAAE,gBAAgB,CAAC;CACpC;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAe,iBAAiB,CAAC"} \ No newline at end of file diff --git a/dist/contribution-graph/index.js b/dist/contribution-graph/index.js new file mode 100644 index 00000000..faaf1fe8 --- /dev/null +++ b/dist/contribution-graph/index.js @@ -0,0 +1,3 @@ +import ContributionGraph from "./ContributionGraph"; +export default ContributionGraph; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJpYnV0aW9uLWdyYXBoL2luZGV4LnRzeCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLGlCQUdOLE1BQU0scUJBQXFCLENBQUM7QUE0QjdCLGVBQWUsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBWaWV3U3R5bGUgfSBmcm9tIFwicmVhY3QtbmF0aXZlXCI7XG5cbmltcG9ydCB7IEFic3RyYWN0Q2hhcnRQcm9wcyB9IGZyb20gXCIuLi9BYnN0cmFjdENoYXJ0XCI7XG5pbXBvcnQgQ29udHJpYnV0aW9uR3JhcGgsIHtcbiAgQ29udHJpYnV0aW9uQ2hhcnRWYWx1ZSxcbiAgVG9vbHRpcERhdGFBdHRyc1xufSBmcm9tIFwiLi9Db250cmlidXRpb25HcmFwaFwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIENvbnRyaWJ1dGlvbkdyYXBoUHJvcHMgZXh0ZW5kcyBBYnN0cmFjdENoYXJ0UHJvcHMge1xuICB2YWx1ZXM6IEFycmF5PGFueT47XG4gIGVuZERhdGU6IERhdGU7XG4gIG51bURheXM6IG51bWJlcjtcbiAgd2lkdGg6IG51bWJlcjtcbiAgaGVpZ2h0OiBudW1iZXI7XG4gIGd1dHRlclNpemU/OiBudW1iZXI7XG4gIHNxdWFyZVNpemU/OiBudW1iZXI7XG4gIGhvcml6b250YWw/OiBib29sZWFuO1xuICBzaG93TW9udGhMYWJlbHM/OiBib29sZWFuO1xuICBzaG93T3V0T2ZSYW5nZURheXM/OiBib29sZWFuO1xuICBhY2Nlc3Nvcj86IHN0cmluZztcbiAgZ2V0TW9udGhMYWJlbD86IChtb250aEluZGV4OiBudW1iZXIpID0+IHN0cmluZztcbiAgb25EYXlQcmVzcz86IChkYXRhOiB7IGNvdW50OiBudW1iZXI7IGRhdGU6IERhdGUgfSkgPT4gdm9pZDtcbiAgY2xhc3NGb3JWYWx1ZT86ICh2YWx1ZTogc3RyaW5nKSA9PiBzdHJpbmc7XG4gIHN0eWxlPzogUGFydGlhbDxWaWV3U3R5bGU+O1xuICB0aXRsZUZvclZhbHVlPzogKHZhbHVlOiBDb250cmlidXRpb25DaGFydFZhbHVlKSA9PiBzdHJpbmc7XG4gIHRvb2x0aXBEYXRhQXR0cnM6IFRvb2x0aXBEYXRhQXR0cnM7XG59XG5cbmV4cG9ydCB0eXBlIENvbnRyaWJ1dGlvbkdyYXBoU3RhdGUgPSB7XG4gIG1heFZhbHVlOiBudW1iZXI7XG4gIG1pblZhbHVlOiBudW1iZXI7XG4gIHZhbHVlQ2FjaGU6IG9iamVjdDtcbn07XG5cbmV4cG9ydCBkZWZhdWx0IENvbnRyaWJ1dGlvbkdyYXBoO1xuIl19 \ No newline at end of file diff --git a/dist/index.d.ts b/dist/index.d.ts new file mode 100644 index 00000000..e36bf34e --- /dev/null +++ b/dist/index.d.ts @@ -0,0 +1,9 @@ +import AbstractChart from "./AbstractChart"; +import BarChart from "./BarChart"; +import PieChart from "./PieChart"; +import ProgressChart from "./ProgressChart"; +import StackedBarChart from "./StackedBarChart"; +import ContributionGraph from "./contribution-graph"; +import LineChart from "./line-chart"; +export { AbstractChart, BarChart, LineChart, PieChart, ProgressChart, ContributionGraph, StackedBarChart }; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/dist/index.d.ts.map b/dist/index.d.ts.map new file mode 100644 index 00000000..3ca37f97 --- /dev/null +++ b/dist/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,QAAQ,MAAM,YAAY,CAAC;AAClC,OAAO,QAAQ,MAAM,YAAY,CAAC;AAClC,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,eAAe,MAAM,mBAAmB,CAAC;AAChD,OAAO,iBAAiB,MAAM,sBAAsB,CAAC;AACrD,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC,OAAO,EACL,aAAa,EACb,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,aAAa,EACb,iBAAiB,EACjB,eAAe,EAChB,CAAC"} \ No newline at end of file diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 00000000..07b1fbbb --- /dev/null +++ b/dist/index.js @@ -0,0 +1,9 @@ +import AbstractChart from "./AbstractChart"; +import BarChart from "./BarChart"; +import PieChart from "./PieChart"; +import ProgressChart from "./ProgressChart"; +import StackedBarChart from "./StackedBarChart"; +import ContributionGraph from "./contribution-graph"; +import LineChart from "./line-chart"; +export { AbstractChart, BarChart, LineChart, PieChart, ProgressChart, ContributionGraph, StackedBarChart }; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxhQUFhLE1BQU0saUJBQWlCLENBQUM7QUFDNUMsT0FBTyxRQUFRLE1BQU0sWUFBWSxDQUFDO0FBQ2xDLE9BQU8sUUFBUSxNQUFNLFlBQVksQ0FBQztBQUNsQyxPQUFPLGFBQWEsTUFBTSxpQkFBaUIsQ0FBQztBQUM1QyxPQUFPLGVBQWUsTUFBTSxtQkFBbUIsQ0FBQztBQUNoRCxPQUFPLGlCQUFpQixNQUFNLHNCQUFzQixDQUFDO0FBQ3JELE9BQU8sU0FBUyxNQUFNLGNBQWMsQ0FBQztBQUVyQyxPQUFPLEVBQ0wsYUFBYSxFQUNiLFFBQVEsRUFDUixTQUFTLEVBQ1QsUUFBUSxFQUNSLGFBQWEsRUFDYixpQkFBaUIsRUFDakIsZUFBZSxFQUNoQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IEFic3RyYWN0Q2hhcnQgZnJvbSBcIi4vQWJzdHJhY3RDaGFydFwiO1xuaW1wb3J0IEJhckNoYXJ0IGZyb20gXCIuL0JhckNoYXJ0XCI7XG5pbXBvcnQgUGllQ2hhcnQgZnJvbSBcIi4vUGllQ2hhcnRcIjtcbmltcG9ydCBQcm9ncmVzc0NoYXJ0IGZyb20gXCIuL1Byb2dyZXNzQ2hhcnRcIjtcbmltcG9ydCBTdGFja2VkQmFyQ2hhcnQgZnJvbSBcIi4vU3RhY2tlZEJhckNoYXJ0XCI7XG5pbXBvcnQgQ29udHJpYnV0aW9uR3JhcGggZnJvbSBcIi4vY29udHJpYnV0aW9uLWdyYXBoXCI7XG5pbXBvcnQgTGluZUNoYXJ0IGZyb20gXCIuL2xpbmUtY2hhcnRcIjtcblxuZXhwb3J0IHtcbiAgQWJzdHJhY3RDaGFydCxcbiAgQmFyQ2hhcnQsXG4gIExpbmVDaGFydCxcbiAgUGllQ2hhcnQsXG4gIFByb2dyZXNzQ2hhcnQsXG4gIENvbnRyaWJ1dGlvbkdyYXBoLFxuICBTdGFja2VkQmFyQ2hhcnRcbn07XG4iXX0= \ No newline at end of file diff --git a/dist/line-chart/LegendItem.d.ts b/dist/line-chart/LegendItem.d.ts new file mode 100644 index 00000000..50726f2d --- /dev/null +++ b/dist/line-chart/LegendItem.d.ts @@ -0,0 +1,14 @@ +import React from "react"; +import { TextProps } from "react-native-svg"; +type Color = string; +export type LegendItemProps = { + baseLegendItemX: number; + index: number; + legendOffset: number; + legendText: string; + iconColor: Color; + labelProps: TextProps; +}; +export declare const LegendItem: (props: LegendItemProps) => React.JSX.Element; +export {}; +//# sourceMappingURL=LegendItem.d.ts.map \ No newline at end of file diff --git a/dist/line-chart/LegendItem.d.ts.map b/dist/line-chart/LegendItem.d.ts.map new file mode 100644 index 00000000..b33194db --- /dev/null +++ b/dist/line-chart/LegendItem.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"LegendItem.d.ts","sourceRoot":"","sources":["../../src/line-chart/LegendItem.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACzD,KAAK,KAAK,GAAG,MAAM,CAAC;AAMpB,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,KAAK,CAAC;IACjB,UAAU,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,OAAO,eAAe,sBAmChD,CAAC"} \ No newline at end of file diff --git a/dist/line-chart/LegendItem.js b/dist/line-chart/LegendItem.js new file mode 100644 index 00000000..c1040090 --- /dev/null +++ b/dist/line-chart/LegendItem.js @@ -0,0 +1,23 @@ +import React from "react"; +import { Rect, Text } from "react-native-svg"; +var CIRCLE_WIDTH = 16; +var PADDING_LEFT = 4; +var CHARACTER_WIDTH = 6; +export var LegendItem = function (props) { + var baseLegendItemX = props.baseLegendItemX, index = props.index; + /* half the height of the legend Rect, minus half the height of the circle to align the + circle from its center, rather than its top. */ + var centerAlignedCircle = props.legendOffset / 2 - CIRCLE_WIDTH / 2; + // 65% of the legend container height centers the text in relation to the circles + var centerAlignedText = props.legendOffset * 0.65; + // to center the legendItem on the baseLegendItemX + var textLengthOffset = (props.legendText.length * CHARACTER_WIDTH) / 2; + var legendItemNumber = index + 1; + return (<> + + + {props.legendText} + + ); +}; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/dist/line-chart/LineChart.d.ts b/dist/line-chart/LineChart.d.ts new file mode 100644 index 00000000..34366eff --- /dev/null +++ b/dist/line-chart/LineChart.d.ts @@ -0,0 +1,223 @@ +import React from "react"; +import { Animated, TextInput, ViewStyle } from "react-native"; +import AbstractChart, { AbstractChartConfig, AbstractChartProps } from "../AbstractChart"; +import { ChartData, Dataset } from "../HelperTypes"; +export interface LineChartData extends ChartData { + legend?: string[]; +} +export interface LineChartProps extends AbstractChartProps { + /** + * Data for the chart. + * + * Example from [docs](https://github.com/indiespirit/react-native-chart-kit#line-chart): + * + * ```javascript + * const data = { + * labels: ['January', 'February', 'March', 'April', 'May', 'June'], + * datasets: [{ + * data: [ 20, 45, 28, 80, 99, 43 ], + * color: (opacity = 1) => `rgba(134, 65, 244, ${opacity})`, // optional + * strokeWidth: 2 // optional + * }], + * legend: ["Rainy Days", "Sunny Days", "Snowy Days"] // optional + * } + * ``` + */ + data: LineChartData; + /** + * Width of the chart, use 'Dimensions' library to get the width of your screen for responsive. + */ + width: number; + /** + * Height of the chart. + */ + height: number; + /** + * Show dots on the line - default: True. + */ + withDots?: boolean; + /** + * Show shadow for line - default: True. + */ + withShadow?: boolean; + /** + * Show inner dashed lines - default: True. + */ + withScrollableDot?: boolean; + withInnerLines?: boolean; + /** + * Show outer dashed lines - default: True. + */ + withOuterLines?: boolean; + /** + * Show vertical lines - default: True. + */ + withVerticalLines?: boolean; + /** + * Show horizontal lines - default: True. + */ + withHorizontalLines?: boolean; + /** + * Show vertical labels - default: True. + */ + withVerticalLabels?: boolean; + /** + * Show horizontal labels - default: True. + */ + withHorizontalLabels?: boolean; + /** + * Render charts from 0 not from the minimum value. - default: False. + */ + fromZero?: boolean; + /** + * Prepend text to horizontal labels -- default: ''. + */ + yAxisLabel?: string; + /** + * Append text to horizontal labels -- default: ''. + */ + yAxisSuffix?: string; + /** + * Prepend text to vertical labels -- default: ''. + */ + xAxisLabel?: string; + /** + * Configuration object for the chart, see example: + * + * ```javascript + * const chartConfig = { + * backgroundGradientFrom: "#1E2923", + * backgroundGradientFromOpacity: 0, + * backgroundGradientTo: "#08130D", + * backgroundGradientToOpacity: 0.5, + * color: (opacity = 1) => `rgba(26, 255, 146, ${opacity})`, + * labelColor: (opacity = 1) => `rgba(26, 255, 146, ${opacity})`, + * strokeWidth: 2, // optional, default 3 + * barPercentage: 0.5 + * }; + * ``` + */ + chartConfig?: AbstractChartConfig; + /** + * Divide axis quantity by the input number -- default: 1. + */ + yAxisInterval?: number; + /** + * Defines if chart is transparent + */ + transparent?: boolean; + /** + * This function takes a [whole bunch](https://github.com/indiespirit/react-native-chart-kit/blob/master/src/line-chart.js#L266) + * of stuff and can render extra elements, + * such as data point info or additional markup. + */ + decorator?: Function; + /** + * Callback that is called when a data point is clicked. + */ + onDataPointClick?: (data: { + index: number; + value: number; + dataset: Dataset; + x: number; + y: number; + getColor: (opacity: number) => string; + }) => void; + /** + * Style of the container view of the chart. + */ + style?: Partial; + /** + * Add this prop to make the line chart smooth and curvy. + * + * [Example](https://github.com/indiespirit/react-native-chart-kit#bezier-line-chart) + */ + bezier?: boolean; + /** + * Defines the dot color function that is used to calculate colors of dots in a line chart. + * Takes `(dataPoint, dataPointIndex)` as arguments. + */ + getDotColor?: (dataPoint: any, index: number) => string; + /** + * Renders additional content for dots in a line chart. + * Takes `({x, y, index})` as arguments. + */ + renderDotContent?: (params: { + x: number; + y: number; + index: number; + indexData: number; + }) => React.ReactNode; + /** + * Rotation angle of the horizontal labels - default 0 (degrees). + */ + horizontalLabelRotation?: number; + /** + * Rotation angle of the vertical labels - default 0 (degrees). + */ + verticalLabelRotation?: number; + /** + * Offset for Y axis labels. + */ + yLabelsOffset?: number; + /** + * Offset for X axis labels. + */ + xLabelsOffset?: number; + /** + * Array of indices of the data points you don't want to display. + */ + hidePointsAtIndex?: number[]; + /** + * This function change the format of the display value of the Y label. + * Takes the y value as argument and should return the desirable string. + */ + formatYLabel?: (yValue: string) => string; + /** + * This function change the format of the display value of the X label. + * Takes the X value as argument and should return the desirable string. + */ + formatXLabel?: (xValue: string) => string; + /** + * Provide props for a data point dot. + */ + getDotProps?: (dataPoint: any, index: number) => object; + /** + * The number of horizontal lines + */ + segments?: number; +} +type LineChartState = { + scrollableDotHorizontalOffset: Animated.Value; +}; +declare class LineChart extends AbstractChart { + label: React.RefObject; + state: { + scrollableDotHorizontalOffset: Animated.Value; + }; + getColor: (dataset: Dataset, opacity: number) => string; + getStrokeWidth: (dataset: Dataset) => number; + getDatas: (data: Dataset[]) => number[]; + getPropsForDots: (x: any, i: number) => object; + renderDots: ({ data, width, height, paddingTop, paddingRight, onDataPointClick }: Pick & { + onDataPointClick: LineChartProps["onDataPointClick"]; + }) => React.ReactNode[]; + renderScrollableDot: ({ data, width, height, paddingTop, paddingRight, scrollableDotHorizontalOffset, scrollableDotFill, scrollableDotStrokeColor, scrollableDotStrokeWidth, scrollableDotRadius, scrollableInfoViewStyle, scrollableInfoTextStyle, scrollableInfoTextDecorator, scrollableInfoSize, scrollableInfoOffset }: AbstractChartConfig & { + onDataPointClick: LineChartProps["onDataPointClick"]; + scrollableDotHorizontalOffset: Animated.Value; + }) => any[]; + renderShadow: ({ width, height, paddingRight, paddingTop, data, useColorFromDataset }: Pick & { + useColorFromDataset: AbstractChartConfig["useShadowColorFromDataset"]; + }) => React.JSX.Element[]; + renderLine: ({ width, height, paddingRight, paddingTop, data, linejoinType }: Pick) => any[]; + getXMaxValues: (data: Dataset[]) => number; + getBezierLinePoints: (dataset: Dataset, { width, height, paddingRight, paddingTop, data }: Pick) => string; + renderBezierLine: ({ data, width, height, paddingRight, paddingTop }: Pick) => React.JSX.Element[]; + renderBezierShadow: ({ width, height, paddingRight, paddingTop, data, useColorFromDataset }: Pick & { + useColorFromDataset: AbstractChartConfig["useShadowColorFromDataset"]; + }) => React.JSX.Element[]; + renderLegend: (width: any, legendOffset: any) => React.JSX.Element[]; + render(): React.JSX.Element; +} +export default LineChart; +//# sourceMappingURL=LineChart.d.ts.map \ No newline at end of file diff --git a/dist/line-chart/LineChart.d.ts.map b/dist/line-chart/LineChart.d.ts.map new file mode 100644 index 00000000..b8ffca0e --- /dev/null +++ b/dist/line-chart/LineChart.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"LineChart.d.ts","sourceRoot":"","sources":["../../src/line-chart/LineChart.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AACzC,OAAO,EACL,QAAQ,EAGR,SAAS,EAET,SAAS,EACV,MAAM,cAAc,CAAC;AAWtB,OAAO,aAAa,EAAE,EACpB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAKpD,MAAM,WAAW,aAAc,SAAQ,SAAS;IAC9C,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,cAAe,SAAQ,kBAAkB;IACxD;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,EAAE,aAAa,CAAC;IACpB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;OAEG;IAEH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;OAEG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;;;;;;OAeG;IACH,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAElC;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC;IACrB;;OAEG;IACH,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,OAAO,CAAC;QACjB,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;QACV,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;KACvC,KAAK,IAAI,CAAC;IACX;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC3B;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACxD;;;OAGG;IACH,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE;QAC1B,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;QACV,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;KACnB,KAAK,KAAK,CAAC,SAAS,CAAC;IACtB;;OAEG;IACH,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;IAC1C;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;IAC1C;;OAEG;IACH,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACxD;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,KAAK,cAAc,GAAG;IACpB,6BAA6B,EAAE,QAAQ,CAAC,KAAK,CAAC;CAC/C,CAAC;AAEF,cAAM,SAAU,SAAQ,aAAa,CAAC,cAAc,EAAE,cAAc,CAAC;IACnE,KAAK,6BAAgC;IAErC,KAAK;;MAEH;IAEF,QAAQ,GAAI,SAAS,OAAO,EAAE,SAAS,MAAM,YAE3C;IAEF,cAAc,GAAI,SAAS,OAAO,YAEhC;IAEF,QAAQ,GAAI,MAAM,OAAO,EAAE,KAAG,MAAM,EAAE,CAKpC;IAEF,eAAe,GAAI,GAAG,GAAG,EAAE,GAAG,MAAM,YAUlC;IAEF,UAAU,GAAI,qEAOX,IAAI,CACL,mBAAmB,EACnB,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,YAAY,CAC5D,GAAG;QACF,gBAAgB,EAAE,cAAc,CAAC,kBAAkB,CAAC,CAAC;KACtD,uBAsEC;IAEF,mBAAmB,GAAI,uSAgBpB,mBAAmB,GAAG;QACvB,gBAAgB,EAAE,cAAc,CAAC,kBAAkB,CAAC,CAAC;QACrD,6BAA6B,EAAE,QAAQ,CAAC,KAAK,CAAC;KAC/C,WA8KC;IAEF,YAAY,GAAI,wEAOb,IAAI,CACL,mBAAmB,EACnB,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,YAAY,CAC5D,GAAG;QACF,mBAAmB,EAAE,mBAAmB,CAAC,2BAA2B,CAAC,CAAC;KACvE,yBA6CC;IAEF,UAAU,GAAI,iEAOX,IAAI,CACL,mBAAmB,EACnB,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,YAAY,GAAG,cAAc,CAC7E,WA4CC;IAEF,aAAa,GAAI,MAAM,OAAO,EAAE,YAI9B;IAEF,mBAAmB,GACjB,SAAS,OAAO,EAChB,mDAMG,IAAI,CACL,mBAAmB,EACnB,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,YAAY,GAAG,MAAM,CAC5D,YAkCD;IAEF,gBAAgB,GAAI,mDAMjB,IAAI,CACL,mBAAmB,EACnB,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,YAAY,CAC5D,yBAsBC;IAEF,kBAAkB,GAAI,wEAOnB,IAAI,CACL,mBAAmB,EACnB,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,YAAY,CAC5D,GAAG;QACF,mBAAmB,EAAE,mBAAmB,CAAC,2BAA2B,CAAC,CAAC;KACvE,yBA0BI;IAEL,YAAY,GAAI,UAAK,EAAE,iBAAY,yBAgBjC;IAEF,MAAM;CA4MP;AAED,eAAe,SAAS,CAAC"} \ No newline at end of file diff --git a/dist/line-chart/LineChart.js b/dist/line-chart/LineChart.js new file mode 100644 index 00000000..54beeff8 --- /dev/null +++ b/dist/line-chart/LineChart.js @@ -0,0 +1,448 @@ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { + if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i); + ar[i] = from[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from)); +}; +import React from "react"; +import { Animated, ScrollView, StyleSheet, TextInput, View } from "react-native"; +import { Circle, G, Path, Polygon, Polyline, Rect, Svg } from "react-native-svg"; +import AbstractChart from "../AbstractChart"; +import { LegendItem } from "./LegendItem"; +var AnimatedCircle = Animated.createAnimatedComponent(Circle); +var LineChart = /** @class */ (function (_super) { + __extends(LineChart, _super); + function LineChart() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.label = React.createRef(); + _this.state = { + scrollableDotHorizontalOffset: new Animated.Value(0) + }; + _this.getColor = function (dataset, opacity) { + return (dataset.color || _this.props.chartConfig.color)(opacity); + }; + _this.getStrokeWidth = function (dataset) { + return dataset.strokeWidth || _this.props.chartConfig.strokeWidth || 3; + }; + _this.getDatas = function (data) { + return data.reduce(function (acc, item) { return (item.data ? __spreadArray(__spreadArray([], acc, true), item.data, true) : acc); }, []); + }; + _this.getPropsForDots = function (x, i) { + var _a = _this.props, getDotProps = _a.getDotProps, chartConfig = _a.chartConfig; + if (typeof getDotProps === "function") { + return getDotProps(x, i); + } + var _b = chartConfig.propsForDots, propsForDots = _b === void 0 ? {} : _b; + return __assign({ r: "4" }, propsForDots); + }; + _this.renderDots = function (_a) { + var data = _a.data, width = _a.width, height = _a.height, paddingTop = _a.paddingTop, paddingRight = _a.paddingRight, onDataPointClick = _a.onDataPointClick; + var output = []; + var datas = _this.getDatas(data); + var baseHeight = _this.calcBaseHeight(datas, height); + var _b = _this.props, getDotColor = _b.getDotColor, _c = _b.hidePointsAtIndex, hidePointsAtIndex = _c === void 0 ? [] : _c, _d = _b.renderDotContent, renderDotContent = _d === void 0 ? function () { + return null; + } : _d; + var xMax = _this.getXMaxValues(data); + data.forEach(function (dataset) { + if (dataset.withDots == false) + return; + dataset.data.forEach(function (x, i) { + if (hidePointsAtIndex.includes(i)) { + return; + } + var cx = paddingRight + (i * (width - paddingRight)) / xMax; + var cy = ((baseHeight - _this.calcHeight(x, datas, height)) / 4) * 3 + + paddingTop; + var onPress = function () { + if (!onDataPointClick || hidePointsAtIndex.includes(i)) { + return; + } + onDataPointClick({ + index: i, + value: x, + dataset: dataset, + x: cx, + y: cy, + getColor: function (opacity) { return _this.getColor(dataset, opacity); } + }); + }; + output.push(, , renderDotContent({ x: cx, y: cy, index: i, indexData: x })); + }); + }); + return output; + }; + _this.renderScrollableDot = function (_a) { + var data = _a.data, width = _a.width, height = _a.height, paddingTop = _a.paddingTop, paddingRight = _a.paddingRight, scrollableDotHorizontalOffset = _a.scrollableDotHorizontalOffset, scrollableDotFill = _a.scrollableDotFill, scrollableDotStrokeColor = _a.scrollableDotStrokeColor, scrollableDotStrokeWidth = _a.scrollableDotStrokeWidth, scrollableDotRadius = _a.scrollableDotRadius, scrollableInfoViewStyle = _a.scrollableInfoViewStyle, scrollableInfoTextStyle = _a.scrollableInfoTextStyle, _b = _a.scrollableInfoTextDecorator, scrollableInfoTextDecorator = _b === void 0 ? function (x) { return "".concat(x); } : _b, scrollableInfoSize = _a.scrollableInfoSize, scrollableInfoOffset = _a.scrollableInfoOffset; + var output = []; + var datas = _this.getDatas(data); + var baseHeight = _this.calcBaseHeight(datas, height); + var vl = []; + var perData = width / data[0].data.length; + for (var index = 0; index < data[0].data.length; index++) { + vl.push(index * perData); + } + var lastIndex; + scrollableDotHorizontalOffset.addListener(function (value) { + var index = value.value / perData; + if (!lastIndex) { + lastIndex = index; + } + var abs = Math.floor(index); + var percent = index - abs; + abs = data[0].data.length - abs - 1; + if (index >= data[0].data.length - 1) { + _this.label.current.setNativeProps({ + text: scrollableInfoTextDecorator(Math.floor(data[0].data[0])) + }); + } + else { + if (index > lastIndex) { + // to right + var base = data[0].data[abs]; + var prev = data[0].data[abs - 1]; + if (prev > base) { + var rest = prev - base; + _this.label.current.setNativeProps({ + text: scrollableInfoTextDecorator(Math.floor(base + percent * rest)) + }); + } + else { + var rest = base - prev; + _this.label.current.setNativeProps({ + text: scrollableInfoTextDecorator(Math.floor(base - percent * rest)) + }); + } + } + else { + // to left + var base = data[0].data[abs - 1]; + var next = data[0].data[abs]; + percent = 1 - percent; + if (next > base) { + var rest = next - base; + _this.label.current.setNativeProps({ + text: scrollableInfoTextDecorator(Math.floor(base + percent * rest)) + }); + } + else { + var rest = base - next; + _this.label.current.setNativeProps({ + text: scrollableInfoTextDecorator(Math.floor(base - percent * rest)) + }); + } + } + } + lastIndex = index; + }); + data.forEach(function (dataset) { + if (dataset.withScrollableDot == false) + return; + var perData = width / dataset.data.length; + var values = []; + var yValues = []; + var xValues = []; + var yValuesLabel = []; + var xValuesLabel = []; + for (var index = 0; index < dataset.data.length; index++) { + values.push(index * perData); + var yval = ((baseHeight - + _this.calcHeight(dataset.data[dataset.data.length - index - 1], datas, height)) / + 4) * + 3 + + paddingTop; + yValues.push(yval); + var xval = paddingRight + + ((dataset.data.length - index - 1) * (width - paddingRight)) / + dataset.data.length; + xValues.push(xval); + yValuesLabel.push(yval - (scrollableInfoSize.height + scrollableInfoOffset)); + xValuesLabel.push(xval - scrollableInfoSize.width / 2); + } + var translateX = scrollableDotHorizontalOffset.interpolate({ + inputRange: values, + outputRange: xValues, + extrapolate: "clamp" + }); + var translateY = scrollableDotHorizontalOffset.interpolate({ + inputRange: values, + outputRange: yValues, + extrapolate: "clamp" + }); + var labelTranslateX = scrollableDotHorizontalOffset.interpolate({ + inputRange: values, + outputRange: xValuesLabel, + extrapolate: "clamp" + }); + var labelTranslateY = scrollableDotHorizontalOffset.interpolate({ + inputRange: values, + outputRange: yValuesLabel, + extrapolate: "clamp" + }); + output.push([ + + + , + + ]); + }); + return output; + }; + _this.renderShadow = function (_a) { + var width = _a.width, height = _a.height, paddingRight = _a.paddingRight, paddingTop = _a.paddingTop, data = _a.data, useColorFromDataset = _a.useColorFromDataset; + if (_this.props.bezier) { + return _this.renderBezierShadow({ + width: width, + height: height, + paddingRight: paddingRight, + paddingTop: paddingTop, + data: data, + useColorFromDataset: useColorFromDataset + }); + } + var datas = _this.getDatas(data); + var baseHeight = _this.calcBaseHeight(datas, height); + return data.map(function (dataset, index) { + return (); + }); + }; + _this.renderLine = function (_a) { + var width = _a.width, height = _a.height, paddingRight = _a.paddingRight, paddingTop = _a.paddingTop, data = _a.data, linejoinType = _a.linejoinType; + if (_this.props.bezier) { + return _this.renderBezierLine({ + data: data, + width: width, + height: height, + paddingRight: paddingRight, + paddingTop: paddingTop + }); + } + var output = []; + var datas = _this.getDatas(data); + var baseHeight = _this.calcBaseHeight(datas, height); + var xMax = _this.getXMaxValues(data); + var lastPoint; + data.forEach(function (dataset, index) { + var points = dataset.data.map(function (d, i) { + if (d === null) + return lastPoint; + var x = (i * (width - paddingRight)) / xMax + paddingRight; + var y = ((baseHeight - _this.calcHeight(d, datas, height)) / 4) * 3 + + paddingTop; + lastPoint = "".concat(x, ",").concat(y); + return "".concat(x, ",").concat(y); + }); + output.push(); + }); + return output; + }; + _this.getXMaxValues = function (data) { + return data.reduce(function (acc, cur) { + return cur.data.length > acc ? cur.data.length : acc; + }, 0); + }; + _this.getBezierLinePoints = function (dataset, _a) { + var width = _a.width, height = _a.height, paddingRight = _a.paddingRight, paddingTop = _a.paddingTop, data = _a.data; + if (dataset.data.length === 0) { + return "M0,0"; + } + var datas = _this.getDatas(data); + var xMax = _this.getXMaxValues(data); + var x = function (i) { + return Math.floor(paddingRight + (i * (width - paddingRight)) / xMax); + }; + var baseHeight = _this.calcBaseHeight(datas, height); + var y = function (i) { + var yHeight = _this.calcHeight(dataset.data[i], datas, height); + return Math.floor(((baseHeight - yHeight) / 4) * 3 + paddingTop); + }; + return ["M".concat(x(0), ",").concat(y(0))] + .concat(dataset.data.slice(0, -1).map(function (_, i) { + var x_mid = (x(i) + x(i + 1)) / 2; + var y_mid = (y(i) + y(i + 1)) / 2; + var cp_x1 = (x_mid + x(i)) / 2; + var cp_x2 = (x_mid + x(i + 1)) / 2; + return ("Q ".concat(cp_x1, ", ").concat(y(i), ", ").concat(x_mid, ", ").concat(y_mid) + + " Q ".concat(cp_x2, ", ").concat(y(i + 1), ", ").concat(x(i + 1), ", ").concat(y(i + 1))); + })) + .join(" "); + }; + _this.renderBezierLine = function (_a) { + var data = _a.data, width = _a.width, height = _a.height, paddingRight = _a.paddingRight, paddingTop = _a.paddingTop; + return data.map(function (dataset, index) { + var result = _this.getBezierLinePoints(dataset, { + width: width, + height: height, + paddingRight: paddingRight, + paddingTop: paddingTop, + data: data + }); + return (); + }); + }; + _this.renderBezierShadow = function (_a) { + var width = _a.width, height = _a.height, paddingRight = _a.paddingRight, paddingTop = _a.paddingTop, data = _a.data, useColorFromDataset = _a.useColorFromDataset; + return data.map(function (dataset, index) { + var xMax = _this.getXMaxValues(data); + var d = _this.getBezierLinePoints(dataset, { + width: width, + height: height, + paddingRight: paddingRight, + paddingTop: paddingTop, + data: data + }) + + " L".concat(paddingRight + + ((width - paddingRight) / xMax) * + (dataset.data.length - 1), ",").concat((height / 4) * 3 + + paddingTop, " L").concat(paddingRight, ",").concat((height / 4) * 3 + paddingTop, " Z"); + return (); + }); + }; + _this.renderLegend = function (width, legendOffset) { + var _a = _this.props.data, legend = _a.legend, datasets = _a.datasets; + var baseLegendItemX = width / (legend.length + 1); + return legend.map(function (legendItem, i) { return ( + + ); }); + }; + return _this; + } + LineChart.prototype.render = function () { + var _a = this.props, width = _a.width, height = _a.height, data = _a.data, _b = _a.withScrollableDot, withScrollableDot = _b === void 0 ? false : _b, _c = _a.withShadow, withShadow = _c === void 0 ? true : _c, _d = _a.withDots, withDots = _d === void 0 ? true : _d, _e = _a.withInnerLines, withInnerLines = _e === void 0 ? true : _e, _f = _a.withOuterLines, withOuterLines = _f === void 0 ? true : _f, _g = _a.withHorizontalLines, withHorizontalLines = _g === void 0 ? true : _g, _h = _a.withVerticalLines, withVerticalLines = _h === void 0 ? true : _h, _j = _a.withHorizontalLabels, withHorizontalLabels = _j === void 0 ? true : _j, _k = _a.withVerticalLabels, withVerticalLabels = _k === void 0 ? true : _k, _l = _a.style, style = _l === void 0 ? {} : _l, decorator = _a.decorator, onDataPointClick = _a.onDataPointClick, _m = _a.verticalLabelRotation, verticalLabelRotation = _m === void 0 ? 0 : _m, _o = _a.horizontalLabelRotation, horizontalLabelRotation = _o === void 0 ? 0 : _o, _p = _a.formatYLabel, formatYLabel = _p === void 0 ? function (yLabel) { return yLabel; } : _p, _q = _a.formatXLabel, formatXLabel = _q === void 0 ? function (xLabel) { return xLabel; } : _q, segments = _a.segments, _r = _a.transparent, transparent = _r === void 0 ? false : _r, chartConfig = _a.chartConfig; + var scrollableDotHorizontalOffset = this.state.scrollableDotHorizontalOffset; + var _s = data.labels, labels = _s === void 0 ? [] : _s; + var _t = style.borderRadius, borderRadius = _t === void 0 ? 0 : _t, _u = style.paddingTop, paddingTop = _u === void 0 ? 16 : _u, _v = style.paddingRight, paddingRight = _v === void 0 ? 64 : _v, _w = style.margin, margin = _w === void 0 ? 0 : _w, _x = style.marginRight, marginRight = _x === void 0 ? 0 : _x, _y = style.paddingBottom, paddingBottom = _y === void 0 ? 0 : _y; + var config = { + width: width, + height: height, + verticalLabelRotation: verticalLabelRotation, + horizontalLabelRotation: horizontalLabelRotation + }; + var datas = this.getDatas(data.datasets); + var count = Math.min.apply(Math, datas) === Math.max.apply(Math, datas) ? 1 : 4; + if (segments) { + count = segments; + } + var legendOffset = this.props.data.legend ? height * 0.15 : 0; + return ( + + + {this.props.data.legend && + this.renderLegend(config.width, legendOffset)} + + {this.renderDefs(__assign(__assign(__assign({}, config), chartConfig), { data: data.datasets }))} + + {withHorizontalLines && + (withInnerLines + ? this.renderHorizontalLines(__assign(__assign({}, config), { count: count, paddingTop: paddingTop, paddingRight: paddingRight })) + : withOuterLines + ? this.renderHorizontalLine(__assign(__assign({}, config), { paddingTop: paddingTop, paddingRight: paddingRight })) + : null)} + + + {withHorizontalLabels && + this.renderHorizontalLabels(__assign(__assign({}, config), { count: count, data: datas, paddingTop: paddingTop, paddingRight: paddingRight, formatYLabel: formatYLabel, decimalPlaces: chartConfig.decimalPlaces }))} + + + {withVerticalLines && + (withInnerLines + ? this.renderVerticalLines(__assign(__assign({}, config), { data: data.datasets[0].data, paddingTop: paddingTop, paddingRight: paddingRight })) + : withOuterLines + ? this.renderVerticalLine(__assign(__assign({}, config), { paddingTop: paddingTop, paddingRight: paddingRight })) + : null)} + + + {withVerticalLabels && + this.renderVerticalLabels(__assign(__assign({}, config), { labels: labels, paddingTop: paddingTop, paddingRight: paddingRight, formatXLabel: formatXLabel }))} + + + {this.renderLine(__assign(__assign(__assign({}, config), chartConfig), { paddingRight: paddingRight, paddingTop: paddingTop, data: data.datasets }))} + + + {withShadow && + this.renderShadow(__assign(__assign({}, config), { data: data.datasets, paddingRight: paddingRight, paddingTop: paddingTop, useColorFromDataset: chartConfig.useShadowColorFromDataset }))} + + + {withDots && + this.renderDots(__assign(__assign({}, config), { data: data.datasets, paddingTop: paddingTop, paddingRight: paddingRight, onDataPointClick: onDataPointClick }))} + + + {withScrollableDot && + this.renderScrollableDot(__assign(__assign(__assign({}, config), chartConfig), { data: data.datasets, paddingTop: paddingTop, paddingRight: paddingRight, onDataPointClick: onDataPointClick, scrollableDotHorizontalOffset: scrollableDotHorizontalOffset }))} + + + {decorator && + decorator(__assign(__assign({}, config), { data: data.datasets, paddingTop: paddingTop, paddingRight: paddingRight }))} + + + + {withScrollableDot && ()} + ); + }; + return LineChart; +}(AbstractChart)); +export default LineChart; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LineChart.js","sourceRoot":"","sources":["../../src/line-chart/LineChart.tsx"],"names":[],"mappings":"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","sourcesContent":["import React, { ReactNode } from \"react\";\nimport {\n  Animated,\n  ScrollView,\n  StyleSheet,\n  TextInput,\n  View,\n  ViewStyle\n} from \"react-native\";\nimport {\n  Circle,\n  G,\n  Path,\n  Polygon,\n  Polyline,\n  Rect,\n  Svg\n} from \"react-native-svg\";\n\nimport AbstractChart, {\n  AbstractChartConfig,\n  AbstractChartProps\n} from \"../AbstractChart\";\nimport { ChartData, Dataset } from \"../HelperTypes\";\nimport { LegendItem } from \"./LegendItem\";\n\nlet AnimatedCircle = Animated.createAnimatedComponent(Circle);\n\nexport interface LineChartData extends ChartData {\n  legend?: string[];\n}\n\nexport interface LineChartProps extends AbstractChartProps {\n  /**\n   * Data for the chart.\n   *\n   * Example from [docs](https://github.com/indiespirit/react-native-chart-kit#line-chart):\n   *\n   * ```javascript\n   * const data = {\n   *   labels: ['January', 'February', 'March', 'April', 'May', 'June'],\n   *   datasets: [{\n   *     data: [ 20, 45, 28, 80, 99, 43 ],\n   *     color: (opacity = 1) => `rgba(134, 65, 244, ${opacity})`, // optional\n   *     strokeWidth: 2 // optional\n   *   }],\n   *   legend: [\"Rainy Days\", \"Sunny Days\", \"Snowy Days\"] // optional\n   * }\n   * ```\n   */\n  data: LineChartData;\n  /**\n   * Width of the chart, use 'Dimensions' library to get the width of your screen for responsive.\n   */\n  width: number;\n  /**\n   * Height of the chart.\n   */\n  height: number;\n  /**\n   * Show dots on the line - default: True.\n   */\n  withDots?: boolean;\n  /**\n   * Show shadow for line - default: True.\n   */\n  withShadow?: boolean;\n  /**\n   * Show inner dashed lines - default: True.\n   */\n\n  withScrollableDot?: boolean;\n  withInnerLines?: boolean;\n  /**\n   * Show outer dashed lines - default: True.\n   */\n  withOuterLines?: boolean;\n  /**\n   * Show vertical lines - default: True.\n   */\n  withVerticalLines?: boolean;\n  /**\n   * Show horizontal lines - default: True.\n   */\n  withHorizontalLines?: boolean;\n  /**\n   * Show vertical labels - default: True.\n   */\n  withVerticalLabels?: boolean;\n  /**\n   * Show horizontal labels - default: True.\n   */\n  withHorizontalLabels?: boolean;\n  /**\n   * Render charts from 0 not from the minimum value. - default: False.\n   */\n  fromZero?: boolean;\n  /**\n   * Prepend text to horizontal labels -- default: ''.\n   */\n  yAxisLabel?: string;\n  /**\n   * Append text to horizontal labels -- default: ''.\n   */\n  yAxisSuffix?: string;\n  /**\n   * Prepend text to vertical labels -- default: ''.\n   */\n  xAxisLabel?: string;\n  /**\n   * Configuration object for the chart, see example:\n   *\n   * ```javascript\n   * const chartConfig = {\n   *   backgroundGradientFrom: \"#1E2923\",\n   *   backgroundGradientFromOpacity: 0,\n   *   backgroundGradientTo: \"#08130D\",\n   *   backgroundGradientToOpacity: 0.5,\n   *   color: (opacity = 1) => `rgba(26, 255, 146, ${opacity})`,\n   *   labelColor: (opacity = 1) => `rgba(26, 255, 146, ${opacity})`,\n   *   strokeWidth: 2, // optional, default 3\n   *   barPercentage: 0.5\n   * };\n   * ```\n   */\n  chartConfig?: AbstractChartConfig;\n\n  /**\n   * Divide axis quantity by the input number -- default: 1.\n   */\n  yAxisInterval?: number;\n\n  /**\n   * Defines if chart is transparent\n   */\n  transparent?: boolean;\n  /**\n   * This function takes a [whole bunch](https://github.com/indiespirit/react-native-chart-kit/blob/master/src/line-chart.js#L266)\n   * of stuff and can render extra elements,\n   * such as data point info or additional markup.\n   */\n  decorator?: Function;\n  /**\n   * Callback that is called when a data point is clicked.\n   */\n  onDataPointClick?: (data: {\n    index: number;\n    value: number;\n    dataset: Dataset;\n    x: number;\n    y: number;\n    getColor: (opacity: number) => string;\n  }) => void;\n  /**\n   * Style of the container view of the chart.\n   */\n  style?: Partial<ViewStyle>;\n  /**\n   * Add this prop to make the line chart smooth and curvy.\n   *\n   * [Example](https://github.com/indiespirit/react-native-chart-kit#bezier-line-chart)\n   */\n  bezier?: boolean;\n  /**\n   * Defines the dot color function that is used to calculate colors of dots in a line chart.\n   * Takes `(dataPoint, dataPointIndex)` as arguments.\n   */\n  getDotColor?: (dataPoint: any, index: number) => string;\n  /**\n   * Renders additional content for dots in a line chart.\n   * Takes `({x, y, index})` as arguments.\n   */\n  renderDotContent?: (params: {\n    x: number;\n    y: number;\n    index: number;\n    indexData: number;\n  }) => React.ReactNode;\n  /**\n   * Rotation angle of the horizontal labels - default 0 (degrees).\n   */\n  horizontalLabelRotation?: number;\n  /**\n   * Rotation angle of the vertical labels - default 0 (degrees).\n   */\n  verticalLabelRotation?: number;\n  /**\n   * Offset for Y axis labels.\n   */\n  yLabelsOffset?: number;\n  /**\n   * Offset for X axis labels.\n   */\n  xLabelsOffset?: number;\n  /**\n   * Array of indices of the data points you don't want to display.\n   */\n  hidePointsAtIndex?: number[];\n  /**\n   * This function change the format of the display value of the Y label.\n   * Takes the y value as argument and should return the desirable string.\n   */\n  formatYLabel?: (yValue: string) => string;\n  /**\n   * This function change the format of the display value of the X label.\n   * Takes the X value as argument and should return the desirable string.\n   */\n  formatXLabel?: (xValue: string) => string;\n  /**\n   * Provide props for a data point dot.\n   */\n  getDotProps?: (dataPoint: any, index: number) => object;\n  /**\n   * The number of horizontal lines\n   */\n  segments?: number;\n}\n\ntype LineChartState = {\n  scrollableDotHorizontalOffset: Animated.Value;\n};\n\nclass LineChart extends AbstractChart<LineChartProps, LineChartState> {\n  label = React.createRef<TextInput>();\n\n  state = {\n    scrollableDotHorizontalOffset: new Animated.Value(0)\n  };\n\n  getColor = (dataset: Dataset, opacity: number) => {\n    return (dataset.color || this.props.chartConfig.color)(opacity);\n  };\n\n  getStrokeWidth = (dataset: Dataset) => {\n    return dataset.strokeWidth || this.props.chartConfig.strokeWidth || 3;\n  };\n\n  getDatas = (data: Dataset[]): number[] => {\n    return data.reduce(\n      (acc, item) => (item.data ? [...acc, ...item.data] : acc),\n      []\n    );\n  };\n\n  getPropsForDots = (x: any, i: number) => {\n    const { getDotProps, chartConfig } = this.props;\n\n    if (typeof getDotProps === \"function\") {\n      return getDotProps(x, i);\n    }\n\n    const { propsForDots = {} } = chartConfig;\n\n    return { r: \"4\", ...propsForDots };\n  };\n\n  renderDots = ({\n    data,\n    width,\n    height,\n    paddingTop,\n    paddingRight,\n    onDataPointClick\n  }: Pick<\n    AbstractChartConfig,\n    \"data\" | \"width\" | \"height\" | \"paddingRight\" | \"paddingTop\"\n  > & {\n    onDataPointClick: LineChartProps[\"onDataPointClick\"];\n  }) => {\n    const output: ReactNode[] = [];\n    const datas = this.getDatas(data);\n    const baseHeight = this.calcBaseHeight(datas, height);\n\n    const {\n      getDotColor,\n      hidePointsAtIndex = [],\n      renderDotContent = () => {\n        return null;\n      }\n    } = this.props;\n    const xMax = this.getXMaxValues(data);\n    data.forEach(dataset => {\n      if (dataset.withDots == false) return;\n\n      dataset.data.forEach((x, i) => {\n        if (hidePointsAtIndex.includes(i)) {\n          return;\n        }\n\n        const cx = paddingRight + (i * (width - paddingRight)) / xMax;\n\n        const cy =\n          ((baseHeight - this.calcHeight(x, datas, height)) / 4) * 3 +\n          paddingTop;\n\n        const onPress = () => {\n          if (!onDataPointClick || hidePointsAtIndex.includes(i)) {\n            return;\n          }\n\n          onDataPointClick({\n            index: i,\n            value: x,\n            dataset,\n            x: cx,\n            y: cy,\n            getColor: opacity => this.getColor(dataset, opacity)\n          });\n        };\n\n        output.push(\n          <Circle\n            key={Math.random()}\n            cx={cx}\n            cy={cy}\n            fill={\n              typeof getDotColor === \"function\"\n                ? getDotColor(x, i)\n                : this.getColor(dataset, 0.9)\n            }\n            onPress={onPress}\n            {...this.getPropsForDots(x, i)}\n          />,\n          <Circle\n            key={Math.random()}\n            cx={cx}\n            cy={cy}\n            r=\"14\"\n            fill=\"#fff\"\n            fillOpacity={0}\n            onPress={onPress}\n          />,\n          renderDotContent({ x: cx, y: cy, index: i, indexData: x })\n        );\n      });\n    });\n\n    return output;\n  };\n\n  renderScrollableDot = ({\n    data,\n    width,\n    height,\n    paddingTop,\n    paddingRight,\n    scrollableDotHorizontalOffset,\n    scrollableDotFill,\n    scrollableDotStrokeColor,\n    scrollableDotStrokeWidth,\n    scrollableDotRadius,\n    scrollableInfoViewStyle,\n    scrollableInfoTextStyle,\n    scrollableInfoTextDecorator = x => `${x}`,\n    scrollableInfoSize,\n    scrollableInfoOffset\n  }: AbstractChartConfig & {\n    onDataPointClick: LineChartProps[\"onDataPointClick\"];\n    scrollableDotHorizontalOffset: Animated.Value;\n  }) => {\n    const output = [];\n    const datas = this.getDatas(data);\n    const baseHeight = this.calcBaseHeight(datas, height);\n\n    let vl: number[] = [];\n\n    const perData = width / data[0].data.length;\n    for (let index = 0; index < data[0].data.length; index++) {\n      vl.push(index * perData);\n    }\n    let lastIndex: number;\n\n    scrollableDotHorizontalOffset.addListener(value => {\n      const index = value.value / perData;\n      if (!lastIndex) {\n        lastIndex = index;\n      }\n\n      let abs = Math.floor(index);\n      let percent = index - abs;\n      abs = data[0].data.length - abs - 1;\n\n      if (index >= data[0].data.length - 1) {\n        this.label.current.setNativeProps({\n          text: scrollableInfoTextDecorator(Math.floor(data[0].data[0]))\n        });\n      } else {\n        if (index > lastIndex) {\n          // to right\n\n          const base = data[0].data[abs];\n          const prev = data[0].data[abs - 1];\n          if (prev > base) {\n            let rest = prev - base;\n            this.label.current.setNativeProps({\n              text: scrollableInfoTextDecorator(\n                Math.floor(base + percent * rest)\n              )\n            });\n          } else {\n            let rest = base - prev;\n            this.label.current.setNativeProps({\n              text: scrollableInfoTextDecorator(\n                Math.floor(base - percent * rest)\n              )\n            });\n          }\n        } else {\n          // to left\n\n          const base = data[0].data[abs - 1];\n          const next = data[0].data[abs];\n          percent = 1 - percent;\n          if (next > base) {\n            let rest = next - base;\n            this.label.current.setNativeProps({\n              text: scrollableInfoTextDecorator(\n                Math.floor(base + percent * rest)\n              )\n            });\n          } else {\n            let rest = base - next;\n            this.label.current.setNativeProps({\n              text: scrollableInfoTextDecorator(\n                Math.floor(base - percent * rest)\n              )\n            });\n          }\n        }\n      }\n      lastIndex = index;\n    });\n\n    data.forEach(dataset => {\n      if (dataset.withScrollableDot == false) return;\n\n      const perData = width / dataset.data.length;\n      let values = [];\n      let yValues = [];\n      let xValues = [];\n\n      let yValuesLabel = [];\n      let xValuesLabel = [];\n\n      for (let index = 0; index < dataset.data.length; index++) {\n        values.push(index * perData);\n        const yval =\n          ((baseHeight -\n            this.calcHeight(\n              dataset.data[dataset.data.length - index - 1],\n              datas,\n              height\n            )) /\n            4) *\n            3 +\n          paddingTop;\n        yValues.push(yval);\n        const xval =\n          paddingRight +\n          ((dataset.data.length - index - 1) * (width - paddingRight)) /\n            dataset.data.length;\n        xValues.push(xval);\n\n        yValuesLabel.push(\n          yval - (scrollableInfoSize.height + scrollableInfoOffset)\n        );\n        xValuesLabel.push(xval - scrollableInfoSize.width / 2);\n      }\n\n      const translateX = scrollableDotHorizontalOffset.interpolate({\n        inputRange: values,\n        outputRange: xValues,\n        extrapolate: \"clamp\"\n      });\n\n      const translateY = scrollableDotHorizontalOffset.interpolate({\n        inputRange: values,\n        outputRange: yValues,\n        extrapolate: \"clamp\"\n      });\n\n      const labelTranslateX = scrollableDotHorizontalOffset.interpolate({\n        inputRange: values,\n        outputRange: xValuesLabel,\n        extrapolate: \"clamp\"\n      });\n\n      const labelTranslateY = scrollableDotHorizontalOffset.interpolate({\n        inputRange: values,\n        outputRange: yValuesLabel,\n        extrapolate: \"clamp\"\n      });\n\n      output.push([\n        <Animated.View\n          key={Math.random()}\n          style={[\n            scrollableInfoViewStyle,\n            {\n              transform: [\n                { translateX: labelTranslateX },\n                { translateY: labelTranslateY }\n              ],\n              width: scrollableInfoSize.width,\n              height: scrollableInfoSize.height\n            }\n          ]}\n        >\n          <TextInput\n            onLayout={() => {\n              this.label.current.setNativeProps({\n                text: scrollableInfoTextDecorator(\n                  Math.floor(data[0].data[data[0].data.length - 1])\n                )\n              });\n            }}\n            style={scrollableInfoTextStyle}\n            ref={this.label}\n          />\n        </Animated.View>,\n        <AnimatedCircle\n          key={Math.random()}\n          cx={translateX}\n          cy={translateY}\n          r={scrollableDotRadius}\n          stroke={scrollableDotStrokeColor}\n          strokeWidth={scrollableDotStrokeWidth}\n          fill={scrollableDotFill}\n        />\n      ]);\n    });\n\n    return output;\n  };\n\n  renderShadow = ({\n    width,\n    height,\n    paddingRight,\n    paddingTop,\n    data,\n    useColorFromDataset\n  }: Pick<\n    AbstractChartConfig,\n    \"data\" | \"width\" | \"height\" | \"paddingRight\" | \"paddingTop\"\n  > & {\n    useColorFromDataset: AbstractChartConfig[\"useShadowColorFromDataset\"];\n  }) => {\n    if (this.props.bezier) {\n      return this.renderBezierShadow({\n        width,\n        height,\n        paddingRight,\n        paddingTop,\n        data,\n        useColorFromDataset\n      });\n    }\n\n    const datas = this.getDatas(data);\n    const baseHeight = this.calcBaseHeight(datas, height);\n\n    return data.map((dataset, index) => {\n      return (\n        <Polygon\n          key={index}\n          points={\n            dataset.data\n              .map((d, i) => {\n                const x =\n                  paddingRight +\n                  (i * (width - paddingRight)) / dataset.data.length;\n\n                const y =\n                  ((baseHeight - this.calcHeight(d, datas, height)) / 4) * 3 +\n                  paddingTop;\n\n                return `${x},${y}`;\n              })\n              .join(\" \") +\n            ` ${paddingRight +\n              ((width - paddingRight) / dataset.data.length) *\n                (dataset.data.length - 1)},${(height / 4) * 3 +\n              paddingTop} ${paddingRight},${(height / 4) * 3 + paddingTop}`\n          }\n          fill={`url(#fillShadowGradientFrom${\n            useColorFromDataset ? `_${index}` : \"\"\n          })`}\n          strokeWidth={0}\n        />\n      );\n    });\n  };\n\n  renderLine = ({\n    width,\n    height,\n    paddingRight,\n    paddingTop,\n    data,\n    linejoinType\n  }: Pick<\n    AbstractChartConfig,\n    \"data\" | \"width\" | \"height\" | \"paddingRight\" | \"paddingTop\" | \"linejoinType\"\n  >) => {\n    if (this.props.bezier) {\n      return this.renderBezierLine({\n        data,\n        width,\n        height,\n        paddingRight,\n        paddingTop\n      });\n    }\n\n    const output = [];\n    const datas = this.getDatas(data);\n    const baseHeight = this.calcBaseHeight(datas, height);\n    const xMax = this.getXMaxValues(data);\n\n    let lastPoint: string;\n\n    data.forEach((dataset, index) => {\n      const points = dataset.data.map((d, i) => {\n        if (d === null) return lastPoint;\n        const x = (i * (width - paddingRight)) / xMax + paddingRight;\n        const y =\n          ((baseHeight - this.calcHeight(d, datas, height)) / 4) * 3 +\n          paddingTop;\n        lastPoint = `${x},${y}`;\n        return `${x},${y}`;\n      });\n\n      output.push(\n        <Polyline\n          key={index}\n          strokeLinejoin={linejoinType}\n          points={points.join(\" \")}\n          fill=\"none\"\n          stroke={this.getColor(dataset, 0.2)}\n          strokeWidth={this.getStrokeWidth(dataset)}\n          strokeDasharray={dataset.strokeDashArray}\n          strokeDashoffset={dataset.strokeDashOffset}\n        />\n      );\n    });\n\n    return output;\n  };\n\n  getXMaxValues = (data: Dataset[]) => {\n    return data.reduce((acc, cur) => {\n      return cur.data.length > acc ? cur.data.length : acc;\n    }, 0);\n  };\n\n  getBezierLinePoints = (\n    dataset: Dataset,\n    {\n      width,\n      height,\n      paddingRight,\n      paddingTop,\n      data\n    }: Pick<\n      AbstractChartConfig,\n      \"width\" | \"height\" | \"paddingRight\" | \"paddingTop\" | \"data\"\n    >\n  ) => {\n    if (dataset.data.length === 0) {\n      return \"M0,0\";\n    }\n\n    const datas = this.getDatas(data);\n    const xMax = this.getXMaxValues(data);\n\n    const x = (i: number) =>\n      Math.floor(paddingRight + (i * (width - paddingRight)) / xMax);\n\n    const baseHeight = this.calcBaseHeight(datas, height);\n\n    const y = (i: number) => {\n      const yHeight = this.calcHeight(dataset.data[i], datas, height);\n\n      return Math.floor(((baseHeight - yHeight) / 4) * 3 + paddingTop);\n    };\n\n    return [`M${x(0)},${y(0)}`]\n      .concat(\n        dataset.data.slice(0, -1).map((_, i) => {\n          const x_mid = (x(i) + x(i + 1)) / 2;\n          const y_mid = (y(i) + y(i + 1)) / 2;\n          const cp_x1 = (x_mid + x(i)) / 2;\n          const cp_x2 = (x_mid + x(i + 1)) / 2;\n          return (\n            `Q ${cp_x1}, ${y(i)}, ${x_mid}, ${y_mid}` +\n            ` Q ${cp_x2}, ${y(i + 1)}, ${x(i + 1)}, ${y(i + 1)}`\n          );\n        })\n      )\n      .join(\" \");\n  };\n\n  renderBezierLine = ({\n    data,\n    width,\n    height,\n    paddingRight,\n    paddingTop\n  }: Pick<\n    AbstractChartConfig,\n    \"data\" | \"width\" | \"height\" | \"paddingRight\" | \"paddingTop\"\n  >) => {\n    return data.map((dataset, index) => {\n      const result = this.getBezierLinePoints(dataset, {\n        width,\n        height,\n        paddingRight,\n        paddingTop,\n        data\n      });\n\n      return (\n        <Path\n          key={index}\n          d={result}\n          fill=\"none\"\n          stroke={this.getColor(dataset, 0.2)}\n          strokeWidth={this.getStrokeWidth(dataset)}\n          strokeDasharray={dataset.strokeDashArray}\n          strokeDashoffset={dataset.strokeDashOffset}\n        />\n      );\n    });\n  };\n\n  renderBezierShadow = ({\n    width,\n    height,\n    paddingRight,\n    paddingTop,\n    data,\n    useColorFromDataset\n  }: Pick<\n    AbstractChartConfig,\n    \"data\" | \"width\" | \"height\" | \"paddingRight\" | \"paddingTop\"\n  > & {\n    useColorFromDataset: AbstractChartConfig[\"useShadowColorFromDataset\"];\n  }) =>\n    data.map((dataset, index) => {\n      const xMax = this.getXMaxValues(data);\n      const d =\n        this.getBezierLinePoints(dataset, {\n          width,\n          height,\n          paddingRight,\n          paddingTop,\n          data\n        }) +\n        ` L${paddingRight +\n          ((width - paddingRight) / xMax) *\n            (dataset.data.length - 1)},${(height / 4) * 3 +\n          paddingTop} L${paddingRight},${(height / 4) * 3 + paddingTop} Z`;\n\n      return (\n        <Path\n          key={index}\n          d={d}\n          fill={`url(#fillShadowGradientFrom${\n            useColorFromDataset ? `_${index}` : \"\"\n          })`}\n          strokeWidth={0}\n        />\n      );\n    });\n\n  renderLegend = (width, legendOffset) => {\n    const { legend, datasets } = this.props.data;\n    const baseLegendItemX = width / (legend.length + 1);\n\n    return legend.map((legendItem, i) => (\n      <G key={Math.random()}>\n        <LegendItem\n          index={i}\n          iconColor={this.getColor(datasets[i], 0.9)}\n          baseLegendItemX={baseLegendItemX}\n          legendText={legendItem}\n          labelProps={{ ...this.getPropsForLabels() }}\n          legendOffset={legendOffset}\n        />\n      </G>\n    ));\n  };\n\n  render() {\n    const {\n      width,\n      height,\n      data,\n      withScrollableDot = false,\n      withShadow = true,\n      withDots = true,\n      withInnerLines = true,\n      withOuterLines = true,\n      withHorizontalLines = true,\n      withVerticalLines = true,\n      withHorizontalLabels = true,\n      withVerticalLabels = true,\n      style = {},\n      decorator,\n      onDataPointClick,\n      verticalLabelRotation = 0,\n      horizontalLabelRotation = 0,\n      formatYLabel = yLabel => yLabel,\n      formatXLabel = xLabel => xLabel,\n      segments,\n      transparent = false,\n      chartConfig\n    } = this.props;\n\n    const { scrollableDotHorizontalOffset } = this.state;\n    const { labels = [] } = data;\n    const {\n      borderRadius = 0,\n      paddingTop = 16,\n      paddingRight = 64,\n      margin = 0,\n      marginRight = 0,\n      paddingBottom = 0\n    } = style;\n\n    const config = {\n      width,\n      height,\n      verticalLabelRotation,\n      horizontalLabelRotation\n    };\n\n    const datas = this.getDatas(data.datasets);\n\n    let count = Math.min(...datas) === Math.max(...datas) ? 1 : 4;\n    if (segments) {\n      count = segments;\n    }\n\n    const legendOffset = this.props.data.legend ? height * 0.15 : 0;\n\n    return (\n      <View style={style}>\n        <Svg\n          height={height + (paddingBottom as number) + legendOffset}\n          width={width - (margin as number) * 2 - (marginRight as number)}\n        >\n          <Rect\n            width=\"100%\"\n            height={height + legendOffset}\n            rx={Number(borderRadius)}\n            ry={Number(borderRadius)}\n            fill=\"url(#backgroundGradient)\"\n            fillOpacity={transparent ? 0 : 1}\n          />\n          {this.props.data.legend &&\n            this.renderLegend(config.width, legendOffset)}\n          <G x=\"0\" y={legendOffset}>\n            {this.renderDefs({\n              ...config,\n              ...chartConfig,\n              data: data.datasets\n            })}\n            <G>\n              {withHorizontalLines &&\n                (withInnerLines\n                  ? this.renderHorizontalLines({\n                      ...config,\n                      count: count,\n                      paddingTop,\n                      paddingRight\n                    })\n                  : withOuterLines\n                  ? this.renderHorizontalLine({\n                      ...config,\n                      paddingTop,\n                      paddingRight\n                    })\n                  : null)}\n            </G>\n            <G>\n              {withHorizontalLabels &&\n                this.renderHorizontalLabels({\n                  ...config,\n                  count: count,\n                  data: datas,\n                  paddingTop: paddingTop as number,\n                  paddingRight: paddingRight as number,\n                  formatYLabel,\n                  decimalPlaces: chartConfig.decimalPlaces\n                })}\n            </G>\n            <G>\n              {withVerticalLines &&\n                (withInnerLines\n                  ? this.renderVerticalLines({\n                      ...config,\n                      data: data.datasets[0].data,\n                      paddingTop: paddingTop as number,\n                      paddingRight: paddingRight as number\n                    })\n                  : withOuterLines\n                  ? this.renderVerticalLine({\n                      ...config,\n                      paddingTop: paddingTop as number,\n                      paddingRight: paddingRight as number\n                    })\n                  : null)}\n            </G>\n            <G>\n              {withVerticalLabels &&\n                this.renderVerticalLabels({\n                  ...config,\n                  labels,\n                  paddingTop: paddingTop as number,\n                  paddingRight: paddingRight as number,\n                  formatXLabel\n                })}\n            </G>\n            <G>\n              {this.renderLine({\n                ...config,\n                ...chartConfig,\n                paddingRight: paddingRight as number,\n                paddingTop: paddingTop as number,\n                data: data.datasets\n              })}\n            </G>\n            <G>\n              {withShadow &&\n                this.renderShadow({\n                  ...config,\n                  data: data.datasets,\n                  paddingRight: paddingRight as number,\n                  paddingTop: paddingTop as number,\n                  useColorFromDataset: chartConfig.useShadowColorFromDataset\n                })}\n            </G>\n            <G>\n              {withDots &&\n                this.renderDots({\n                  ...config,\n                  data: data.datasets,\n                  paddingTop: paddingTop as number,\n                  paddingRight: paddingRight as number,\n                  onDataPointClick\n                })}\n            </G>\n            <G>\n              {withScrollableDot &&\n                this.renderScrollableDot({\n                  ...config,\n                  ...chartConfig,\n                  data: data.datasets,\n                  paddingTop: paddingTop as number,\n                  paddingRight: paddingRight as number,\n                  onDataPointClick,\n                  scrollableDotHorizontalOffset\n                })}\n            </G>\n            <G>\n              {decorator &&\n                decorator({\n                  ...config,\n                  data: data.datasets,\n                  paddingTop,\n                  paddingRight\n                })}\n            </G>\n          </G>\n        </Svg>\n        {withScrollableDot && (\n          <ScrollView\n            style={StyleSheet.absoluteFill}\n            contentContainerStyle={{ width: width * 2 }}\n            showsHorizontalScrollIndicator={false}\n            scrollEventThrottle={16}\n            onScroll={Animated.event([\n              {\n                nativeEvent: {\n                  contentOffset: { x: scrollableDotHorizontalOffset }\n                }\n              }\n            ], { useNativeDriver: false }\n            )}\n            horizontal\n            bounces={false}\n          />\n        )}\n      </View>\n    );\n  }\n}\n\nexport default LineChart;\n"]} \ No newline at end of file diff --git a/dist/line-chart/index.d.ts b/dist/line-chart/index.d.ts new file mode 100644 index 00000000..48a943e3 --- /dev/null +++ b/dist/line-chart/index.d.ts @@ -0,0 +1,3 @@ +import LineChart from "./LineChart"; +export default LineChart; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/dist/line-chart/index.d.ts.map b/dist/line-chart/index.d.ts.map new file mode 100644 index 00000000..24694d0b --- /dev/null +++ b/dist/line-chart/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/line-chart/index.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,aAAa,CAAC;AAEpC,eAAe,SAAS,CAAC"} \ No newline at end of file diff --git a/dist/line-chart/index.js b/dist/line-chart/index.js new file mode 100644 index 00000000..eb05d08f --- /dev/null +++ b/dist/line-chart/index.js @@ -0,0 +1,3 @@ +import LineChart from "./LineChart"; +export default LineChart; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbGluZS1jaGFydC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLFNBQVMsTUFBTSxhQUFhLENBQUM7QUFFcEMsZUFBZSxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgTGluZUNoYXJ0IGZyb20gXCIuL0xpbmVDaGFydFwiO1xuXG5leHBvcnQgZGVmYXVsdCBMaW5lQ2hhcnQ7XG4iXX0= \ No newline at end of file diff --git a/package.json b/package.json index 611973d1..4167fa2d 100644 --- a/package.json +++ b/package.json @@ -1,31 +1,30 @@ { - "name": "react-native-chart-kit", + "name": "@adalo/react-native-chart-kit", "version": "6.11.0", "devDependencies": { - "@types/react": "^16.9.38", - "@types/react-native": "^0.62.13", - "babel-eslint": "10.x", - "babel-plugin-module-resolver": "^3.1.1", + "@types/react-native": "0.72", + "babel-eslint": "^10.1.0", + "babel-plugin-module-resolver": "^5.0.0", "babel-polyfill": "^6.26.0", - "eslint": "6.x", - "eslint-config-react-app": "^5.0.2", - "eslint-plugin-flowtype": "^4.3.0", - "eslint-plugin-import": "2.x", - "eslint-plugin-jsx-a11y": "6.x", - "eslint-plugin-react": "7.x", - "eslint-plugin-react-hooks": "1.x", - "expo": "^37.0.0", - "husky": "^3.0.7", - "jest-expo": "^37.0.0", - "prettier": "^1.18.2", - "pretty-quick": "^1.11.1", - "react": "16.9.0", - "react-native": "https://github.com/expo/react-native/archive/sdk-37.0.1.tar.gz", - "react-native-flash-message": "^0.1.10", + "eslint": "^8.56.0", + "eslint-config-react-app": "^7.0.1", + "eslint-plugin-flowtype": "^8.0.3", + "eslint-plugin-import": "^2.29.1", + "eslint-plugin-jsx-a11y": "^6.8.0", + "eslint-plugin-react": "^7.33.2", + "eslint-plugin-react-hooks": "^4.6.0", + "expo": "^50.0.0", + "husky": "^8.0.3", + "jest-expo": "^50.0.0", + "prettier": "^3.2.5", + "pretty-quick": "^4.0.0", + "react": "18.2.0", + "react-native": "https://github.com/expo/react-native/archive/sdk-49.0.0.tar.gz", + "react-native-flash-message": "^0.4.0", "react-native-scrollable-tab-view": "^1.0.0", - "react-native-svg": "11.0.1", - "react-test-renderer": "16.7.0", - "typescript": "^3.9.5" + "react-native-svg": "^15.11.2", + "react-test-renderer": "18.2.0", + "typescript": "^5.8.3" }, "_main": "./node_modules/expo/AppEntry.js", "main": "./dist/index.js", @@ -41,18 +40,19 @@ "test": "jest", "build": "tsc", "dev": "tsc --watch", - "prepublish": "yarn build" + "prepublish": "yarn build", + "prepare": "yarn build" }, "jest": { "preset": "jest-expo" }, "peerDependencies": { - "react": "> 16.7.0", - "react-native": ">= 0.50.0", - "react-native-svg": "> 6.4.1" + "react": ">= 18.2.0", + "react-native": ">= 0.77.2", + "react-native-svg": ">= 15.11.2" }, "dependencies": { - "lodash": "^4.17.13", + "lodash": "^4.17.21", "paths-js": "^0.4.10", "point-in-polygon": "^1.0.1" }, @@ -62,9 +62,12 @@ } }, "license": "MIT", - "homepage": "https://github.com/indiespirit/react-native-chart-kit", + "homepage": "https://github.com/AdaloHQ/react-native-chart-kit", "repository": { "type": "git", - "url": "https://github.com/indiespirit/react-native-chart-kit" + "url": "https://github.com/AdaloHQ/react-native-chart-kit" + }, + "resolutions": { + "@types/react": "^18.2.0" } -} \ No newline at end of file +} diff --git a/src/AbstractChart.tsx b/src/AbstractChart.tsx index 612ffdfb..4f7b124f 100644 --- a/src/AbstractChart.tsx +++ b/src/AbstractChart.tsx @@ -31,6 +31,7 @@ export interface AbstractChartConfig extends ChartConfig { verticalLabelRotation?: number; formatXLabel?: (xLabel: string) => string; verticalLabelsHeightPercentage?: number; + formatTopBarValue?: (topBarValue: number) => string | number; } export type AbstractChartState = {}; @@ -42,7 +43,9 @@ class AbstractChart< IState extends AbstractChartState > extends Component { calcScaler = (data: number[]) => { - if (this.props.fromZero) { + if (this.props.fromZero && this.props.fromNumber) { + return Math.max(...data, this.props.fromNumber) - Math.min(...data, 0) || 1; + } else if (this.props.fromZero) { return Math.max(...data, 0) - Math.min(...data, 0) || 1; } else if (this.props.fromNumber) { return ( @@ -378,6 +381,12 @@ class AbstractChart< | "backgroundGradientToOpacity" | "fillShadowGradient" | "fillShadowGradientOpacity" + | "fillShadowGradientFrom" + | "fillShadowGradientFromOpacity" + | "fillShadowGradientFromOffset" + | "fillShadowGradientTo" + | "fillShadowGradientToOpacity" + | "fillShadowGradientToOffset" >, | "width" | "height" @@ -389,6 +398,12 @@ class AbstractChart< | "backgroundGradientToOpacity" | "fillShadowGradient" | "fillShadowGradientOpacity" + | "fillShadowGradientFrom" + | "fillShadowGradientFromOpacity" + | "fillShadowGradientFromOffset" + | "fillShadowGradientTo" + | "fillShadowGradientToOpacity" + | "fillShadowGradientToOffset" > ) => { const { @@ -417,6 +432,40 @@ class AbstractChart< ? config.fillShadowGradientOpacity : 0.1; + const fillShadowGradientFrom = config.hasOwnProperty( + "fillShadowGradientFrom" + ) + ? config.fillShadowGradientFrom + : fillShadowGradient; + + const fillShadowGradientFromOpacity = config.hasOwnProperty( + "fillShadowGradientFromOpacity" + ) + ? config.fillShadowGradientFromOpacity + : fillShadowGradientOpacity; + + const fillShadowGradientFromOffset = config.hasOwnProperty( + "fillShadowGradientFromOffset" + ) + ? config.fillShadowGradientFromOffset + : 0; + + const fillShadowGradientTo = config.hasOwnProperty("fillShadowGradientTo") + ? config.fillShadowGradientTo + : this.props.chartConfig.color(1.0); + + const fillShadowGradientToOpacity = config.hasOwnProperty( + "fillShadowGradientToOpacity" + ) + ? config.fillShadowGradientToOpacity + : 0.1; + + const fillShadowGradientToOffset = config.hasOwnProperty( + "fillShadowGradientToOffset" + ) + ? config.fillShadowGradientToOffset + : 1; + return ( ( )) ) : ( + - )} diff --git a/src/BarChart.tsx b/src/BarChart.tsx index 4f2508fd..ec2d9e2a 100644 --- a/src/BarChart.tsx +++ b/src/BarChart.tsx @@ -46,6 +46,7 @@ export interface BarChartProps extends AbstractChartProps { showValuesOnTopOfBars?: boolean; withCustomBarColorFromData?: boolean; flatColor?: boolean; + } type BarChartState = {}; @@ -94,7 +95,7 @@ class BarChart extends AbstractChart { fill={ withCustomBarColorFromData ? `url(#customColor_0_${i})` - : "url(#fillShadowGradient)" + : "url(#fillShadowGradientFrom)" } /> ); @@ -183,6 +184,14 @@ class BarChart extends AbstractChart { }) => { const baseHeight = this.calcBaseHeight(data, height); + const renderLabel = (value: number) => { + if(this.props.chartConfig.formatTopBarValue) { + return this.props.chartConfig.formatTopBarValue(value) + } + else { + return value + } + } return data.map((x, i) => { const barHeight = this.calcHeight(x, data, height); const barWidth = 32 * this.getBarPercentage(); @@ -193,13 +202,14 @@ class BarChart extends AbstractChart { paddingRight + (i * (width - paddingRight)) / data.length + barWidth / 1 + } y={((baseHeight - barHeight) / 4) * 3 + paddingTop - 1} fill={this.props.chartConfig.color(0.6)} fontSize="12" textAnchor="middle" > - {data[i]} + {renderLabel(data[i])} ); }); @@ -261,8 +271,8 @@ class BarChart extends AbstractChart { diff --git a/src/HelperTypes.ts b/src/HelperTypes.ts index 6bec6e4d..0d5dde32 100644 --- a/src/HelperTypes.ts +++ b/src/HelperTypes.ts @@ -54,8 +54,35 @@ export interface ChartConfig { * Defines the second color opacity in the linear gradient of a chart's background */ backgroundGradientToOpacity?: number; + /** + * Defines the previous options to maintain backwards compatibility + */ fillShadowGradient?: string; fillShadowGradientOpacity?: number; + /** + * Defines the first color in the linear gradient of the area under data + */ + fillShadowGradientFrom?: string; + /** + * Defines the first color opacity in the linear gradient of the area under data + */ + fillShadowGradientFromOpacity?: number; + /** + * Defines the first color offset in the linear gradient of the area under data + */ + fillShadowGradientFromOffset?: number; + /** + * Defines the second color in the linear gradient of the area under data + */ + fillShadowGradientTo?: string; + /** + * Defines the second color opacity in the linear gradient of the area under data + */ + fillShadowGradientToOpacity?: number; + /** + * Defines the second color offset in the linear gradient of the area under data + */ + fillShadowGradientToOffset?: number; /** * Defines the option to use color from dataset to each chart data */ diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 3e498ddc..02601c27 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -1,9 +1,11 @@ +import { isObject } from "lodash"; import Pie from "paths-js/pie"; -import React from "react"; -import { View, ViewStyle } from "react-native"; +import React, { Fragment } from "react"; +import { View, ViewStyle, Text as NativeText } from "react-native"; import { G, Path, Rect, Svg, Text } from "react-native-svg"; import AbstractChart, { AbstractChartProps } from "./AbstractChart"; +import { hslToRgba } from "./Utils"; export interface PieChartProps extends AbstractChartProps { data: Array; @@ -17,11 +19,89 @@ export interface PieChartProps extends AbstractChartProps { hasLegend?: boolean; style?: Partial; avoidFalseZero?: boolean; + chartWidthPercentage: number; + showLabelPrefix: boolean; + editor: boolean; } -type PieChartState = {}; +type PieChartState = { + data: Array; + calculating: Array; +}; + +const compareDataArrays = (a, b) => { + //TODO: remove values field from a and b + //TODO: get the sum of values to make sure percentages stay the same + let sumA = a.reduce((accumulator, item) => { + return accumulator + item.value; + }, 0); + + let sumB = b.reduce((accumulator, item) => { + return accumulator + item.value; + }, 0); + + return ( + sumA === sumB && + a.length === b.length && + a.every((value, index) => { + const aCopy = { + ...value, + values: null + }; + const bCopy = { + ...b[index], + values: null + }; + return JSON.stringify(aCopy) === JSON.stringify(bCopy); + }) + ); +}; class PieChart extends AbstractChart { + componentDidUpdate(prevProps) { + if ( + this.props.width !== prevProps.width || + this.props.height !== prevProps.height || + this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || + !compareDataArrays(this.props.data, prevProps.data) + ) { + let calculating = []; + for (let i = 0; i < this.props.data.length; i++) { + calculating[i] = { label: this.props.data[i], calculating: true }; + } + if ( + this.state.calculating.filter(i => i.calculating === true).length === + 0 && + this.props.width === prevProps.width && + compareDataArrays(this.props.data, prevProps.data) + ) { + this.setState({ + calculating, + ...this.props, + ...this.state + }); + } else { + this.setState({ + calculating, + ...this.props + }); + } + } + } + + constructor(props) { + super(props); + let calculating = []; + for (let i = 0; i < this.props.data.length; i++) { + calculating[i] = { label: this.props.data[i], calculating: true }; + } + this.state = { + calculating, + ...props, + labelData: this.props.data + }; + } + render() { const { style = {}, @@ -31,36 +111,175 @@ class PieChart extends AbstractChart { avoidFalseZero = false } = this.props; + const calculations = this.state.calculating.map((item, index) => { + let { + name, + legendFontFamily, + legendFontSize, + legendFontWeight, + value + } = item.label; + if (item.calculating && this.props.hasLegend) { + if (this.props.absolute === false) { + value = "55%"; + } + if (this.props.showLabelPrefix === false) { + value = ""; + } + if (!isObject(value)) { + return ( + + {`${value} ${name}`} + + ); + } else { + return ( + + + {//@ts-ignore + `${value.whole}% ${name}`} + + + ); + } + } + }); + const { borderRadius = 0 } = style; - const chart = Pie({ + let chartWidthPercentage = this.props.chartWidthPercentage * 0.01; + + let radius: number; + + if ( + this.props.height / 2.5 < + (this.props.width * chartWidthPercentage) / 2 + ) { + radius = this.props.height / 2.5; + chartWidthPercentage = 2 * (radius / this.props.width); + } else { + radius = this.props.width * (chartWidthPercentage / 2); + } + + if (chartWidthPercentage === 1) { + chartWidthPercentage = 0.5; + } + + let chart = Pie({ center: this.props.center || [0, 0], r: 0, - R: this.props.height / 2.5, - data: this.props.data, + R: radius, + data: this.state.data, accessor: x => { return x[this.props.accessor]; } }); - const total = this.props.data.reduce((sum, item) => { - return sum + item[this.props.accessor]; + const total = this.state.data.reduce((sum, item) => { + if (isObject(item[this.props.accessor])) { + return sum + item[this.props.accessor].whole; + } else { + return sum + item[this.props.accessor]; + } }, 0); - const slices = chart.curves.map((c, i) => { + let uppedIndices = []; + + if (!absolute) { + const divisor = total / 100.0; + let wholeTotal = 0; + chart.curves.forEach((c, i) => { + if (!isObject(c.item.values)) { + const percentage = c.item[this.props.accessor] / divisor; + const pieces = percentage.toString().split("."); + let whole = parseInt(pieces[0]); + let decimal = parseFloat("." + pieces[1]); + if (isNaN(decimal)) { + decimal = 0; + } + wholeTotal += whole; + //had to create a new object here to use for percentages, chart wouldn't render when assigning the object to c.item[this.props.accessor] + c.item.values = { + index: i, + whole, + decimal + }; + } else { + wholeTotal += c.item.values.whole; + } + }); + + const hamiltonDiff = 100 - wholeTotal; + const sortedCurves = [...chart.curves].sort((a, b) => + a.item.values.decimal < b.item.values.decimal ? 1 : -1 + ); + for (let i = 0; i < hamiltonDiff; i++) { + let uppedVal = sortedCurves[i].item.values.whole; + sortedCurves.some(item => { + if (item.item.values.whole === uppedVal) { + uppedIndices.push(item.item.values.index); + chart.curves[item.item.values.index].item.values.whole += 1; + return true; + } + }); + } + } + + let chartCurvesSorted = [...chart.curves].filter( + item => item.item.otherSlice !== true + ); + let otherSlice = [...chart.curves].find( + item => item.item.otherSlice === true + ); + + if (!absolute) { + chartCurvesSorted = chartCurvesSorted.sort((a, b) => + a.item.values.whole < b.item.values.whole ? 1 : -1 + ); + } + + if (otherSlice) { + chartCurvesSorted.push(otherSlice); + } + + const slices = chartCurvesSorted.map((c, i) => { let value: string; if (absolute) { - value = c.item[this.props.accessor]; + if (this.props.showLabelPrefix) { + value = c.item[this.props.accessor]; + } else { + value = ""; + } } else { + //calculate percentage using Hamilton's method if (total === 0) { value = 0 + "%"; } else { - const percentage = Math.round( - (100 / total) * c.item[this.props.accessor] - ); - value = Math.round((100 / total) * c.item[this.props.accessor]) + "%"; - if (avoidFalseZero && percentage === 0) { + const item = c.item.values; + let percentage = item.whole; + + if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) { value = "<1%"; } else { value = percentage + "%"; @@ -68,35 +287,60 @@ class PieChart extends AbstractChart { } } + let textColor = this.state.calculating[i] + ? c.item.legendFontColor + : "transparent"; + + if (typeof c?.item?.color === "string" && c.item.color.includes('hsl')) { + c.item.color = hslToRgba(c.item.color) + } + return ( - + {hasLegend ? ( ) : null} {hasLegend ? ( {`${value} ${c.item.name}`} @@ -114,7 +358,11 @@ class PieChart extends AbstractChart { ...style }} > - + {this.renderDefs({ width: this.props.height, @@ -125,20 +373,22 @@ class PieChart extends AbstractChart { {slices} + {calculations} ); } diff --git a/src/ProgressChart.tsx b/src/ProgressChart.tsx index a4e8be57..0a399cbb 100644 --- a/src/ProgressChart.tsx +++ b/src/ProgressChart.tsx @@ -171,8 +171,8 @@ class ProgressChart extends AbstractChart< diff --git a/src/Utils.ts b/src/Utils.ts index 00816a48..fbe209b7 100644 --- a/src/Utils.ts +++ b/src/Utils.ts @@ -7,3 +7,35 @@ export function mapValue( ) { return ((x - in_min) * (out_max - out_min)) / (in_max - in_min) + out_min; } + + +export function hslToRgba(hslString: string): string { + const matches = hslString.match(/hsla?\((\d+\.?\d*),\s*(\d+\.?\d*)%,\s*(\d+\.?\d*)%(?:,\s*([\d.]+)\s*)?\)/i); + + if (!matches) { + return '#000000'; + } + + const h = parseFloat(matches[1]); + const s = parseFloat(matches[2]) / 100; + const l = parseFloat(matches[3]) / 100; + const a = matches[4] ? parseFloat(matches[4]) : 1; + + const c = (1 - Math.abs(2 * l - 1)) * s; + const x = c * (1 - Math.abs(((h / 60) % 2) - 1)); + const m = l - c / 2; + + let r, g, b; + if (h < 60) [r, g, b] = [c, x, 0]; + else if (h < 120) [r, g, b] = [x, c, 0]; + else if (h < 180) [r, g, b] = [0, c, x]; + else if (h < 240) [r, g, b] = [0, x, c]; + else if (h < 300) [r, g, b] = [x, 0, c]; + else [r, g, b] = [c, 0, x]; + + r = Math.round((r + m) * 255); + g = Math.round((g + m) * 255); + b = Math.round((b + m) * 255); + + return `rgba(${r}, ${g}, ${b}, ${a})`; +} diff --git a/src/contribution-graph/ContributionGraph.tsx b/src/contribution-graph/ContributionGraph.tsx index 0a6033fc..430cdecc 100644 --- a/src/contribution-graph/ContributionGraph.tsx +++ b/src/contribution-graph/ContributionGraph.tsx @@ -166,8 +166,8 @@ class ContributionGraph extends AbstractChart< if (count) { const opacity = mapValue( count, - this.state.minValue, - this.state.maxValue, + this.state.maxValue === this.state.minValue ? 0: this.state.minValue, + isNaN(this.state.maxValue) ? 1 : this.state.maxValue, 0.15 + 0.05, // + 0.05 to make smaller values a bit more visible 1 ); @@ -385,8 +385,8 @@ class ContributionGraph extends AbstractChart< {this.renderMonthLabels()} diff --git a/src/contribution-graph/index.tsx b/src/contribution-graph/index.tsx index afa9d027..ead682de 100644 --- a/src/contribution-graph/index.tsx +++ b/src/contribution-graph/index.tsx @@ -19,7 +19,7 @@ export interface ContributionGraphProps extends AbstractChartProps { showOutOfRangeDays?: boolean; accessor?: string; getMonthLabel?: (monthIndex: number) => string; - onDayPress?: ({ count: number, date: Date }) => void; + onDayPress?: (data: { count: number; date: Date }) => void; classForValue?: (value: string) => string; style?: Partial; titleForValue?: (value: ContributionChartValue) => string; diff --git a/src/line-chart/LegendItem.tsx b/src/line-chart/LegendItem.tsx index c80777ff..7d9c0171 100644 --- a/src/line-chart/LegendItem.tsx +++ b/src/line-chart/LegendItem.tsx @@ -1,5 +1,6 @@ import React from "react"; -import { Color, Rect, Text, TextProps } from "react-native-svg"; +import { Rect, Text, TextProps } from "react-native-svg"; +type Color = string; const CIRCLE_WIDTH = 16; const PADDING_LEFT = 4; diff --git a/src/line-chart/LineChart.tsx b/src/line-chart/LineChart.tsx index 3b7a5a90..5de2c988 100644 --- a/src/line-chart/LineChart.tsx +++ b/src/line-chart/LineChart.tsx @@ -278,7 +278,7 @@ class LineChart extends AbstractChart { return null; } } = this.props; - + const xMax = this.getXMaxValues(data); data.forEach(dataset => { if (dataset.withDots == false) return; @@ -287,8 +287,7 @@ class LineChart extends AbstractChart { return; } - const cx = - paddingRight + (i * (width - paddingRight)) / dataset.data.length; + const cx = paddingRight + (i * (width - paddingRight)) / xMax; const cy = ((baseHeight - this.calcHeight(x, datas, height)) / 4) * 3 + @@ -584,7 +583,7 @@ class LineChart extends AbstractChart { (dataset.data.length - 1)},${(height / 4) * 3 + paddingTop} ${paddingRight},${(height / 4) * 3 + paddingTop}` } - fill={`url(#fillShadowGradient${ + fill={`url(#fillShadowGradientFrom${ useColorFromDataset ? `_${index}` : "" })`} strokeWidth={0} @@ -617,14 +616,14 @@ class LineChart extends AbstractChart { const output = []; const datas = this.getDatas(data); const baseHeight = this.calcBaseHeight(datas, height); + const xMax = this.getXMaxValues(data); let lastPoint: string; data.forEach((dataset, index) => { const points = dataset.data.map((d, i) => { if (d === null) return lastPoint; - const x = - (i * (width - paddingRight)) / dataset.data.length + paddingRight; + const x = (i * (width - paddingRight)) / xMax + paddingRight; const y = ((baseHeight - this.calcHeight(d, datas, height)) / 4) * 3 + paddingTop; @@ -649,6 +648,12 @@ class LineChart extends AbstractChart { return output; }; + getXMaxValues = (data: Dataset[]) => { + return data.reduce((acc, cur) => { + return cur.data.length > acc ? cur.data.length : acc; + }, 0); + }; + getBezierLinePoints = ( dataset: Dataset, { @@ -667,11 +672,10 @@ class LineChart extends AbstractChart { } const datas = this.getDatas(data); + const xMax = this.getXMaxValues(data); const x = (i: number) => - Math.floor( - paddingRight + (i * (width - paddingRight)) / dataset.data.length - ); + Math.floor(paddingRight + (i * (width - paddingRight)) / xMax); const baseHeight = this.calcBaseHeight(datas, height); @@ -744,6 +748,7 @@ class LineChart extends AbstractChart { useColorFromDataset: AbstractChartConfig["useShadowColorFromDataset"]; }) => data.map((dataset, index) => { + const xMax = this.getXMaxValues(data); const d = this.getBezierLinePoints(dataset, { width, @@ -753,7 +758,7 @@ class LineChart extends AbstractChart { data }) + ` L${paddingRight + - ((width - paddingRight) / dataset.data.length) * + ((width - paddingRight) / xMax) * (dataset.data.length - 1)},${(height / 4) * 3 + paddingTop} L${paddingRight},${(height / 4) * 3 + paddingTop} Z`; @@ -761,7 +766,7 @@ class LineChart extends AbstractChart { { @@ -982,7 +987,8 @@ class LineChart extends AbstractChart { contentOffset: { x: scrollableDotHorizontalOffset } } } - ])} + ], { useNativeDriver: false } + )} horizontal bounces={false} /> diff --git a/tsconfig.json b/tsconfig.json index 07904ad0..14775826 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -21,6 +21,7 @@ "inlineSources": true, "esModuleInterop": true, "noErrorTruncation": true, - "jsx": "react-native" + "jsx": "react-native", + "skipLibCheck": true } }