From 900bc3731cfa95624326b94ac6f1526740193bda Mon Sep 17 00:00:00 2001 From: PixoDev <42890253+PixoDev@users.noreply.github.com> Date: Tue, 8 Feb 2022 04:54:08 +0100 Subject: [PATCH 01/86] Add formatting function for BarChart top bar value (#518) Co-authored-by: Robert --- src/AbstractChart.tsx | 1 + src/BarChart.tsx | 12 +++++++++++- 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/src/AbstractChart.tsx b/src/AbstractChart.tsx index 612ffdfb..4a3255ca 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 = {}; diff --git a/src/BarChart.tsx b/src/BarChart.tsx index 4f2508fd..f7e8671a 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 = {}; @@ -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])} ); }); From 5ec0b089848ae69f9476314dc21dbd683668afb9 Mon Sep 17 00:00:00 2001 From: Jason Pan Date: Tue, 8 Feb 2022 14:55:39 +1100 Subject: [PATCH 02/86] Fix AbstractChart calculating incorrect range when both fromZero and fromNumber are set (#575) --- src/AbstractChart.tsx | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/AbstractChart.tsx b/src/AbstractChart.tsx index 4a3255ca..0d7ffb53 100644 --- a/src/AbstractChart.tsx +++ b/src/AbstractChart.tsx @@ -43,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 ( From e979a59fc42ca6efefee6027f1212f477e087c68 Mon Sep 17 00:00:00 2001 From: Andrew Chen Wang <60190294+Andrew-Chen-Wang@users.noreply.github.com> Date: Mon, 7 Feb 2022 22:59:50 -0500 Subject: [PATCH 03/86] Add defaults for ContributionGraph (Fixes #425) (#543) --- src/contribution-graph/ContributionGraph.tsx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/contribution-graph/ContributionGraph.tsx b/src/contribution-graph/ContributionGraph.tsx index 0a6033fc..62f7d742 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 ); From 58c08a4554b1ccbb8695601ef74868ef07ada572 Mon Sep 17 00:00:00 2001 From: Yen Sheng <16015050+tention@users.noreply.github.com> Date: Tue, 8 Feb 2022 12:00:44 +0800 Subject: [PATCH 04/86] =?UTF-8?q?To=20fix=20React=20Native=20Error:=20?= =?UTF-8?q?=E2=80=9CAnimated.event=20now=20requires=20a=20second=20argumen?= =?UTF-8?q?t=20for=20options=E2=80=9D=20(#523)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit To fix React Native Error: “Animated.event now requires a second argument for options” --- src/line-chart/LineChart.tsx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/line-chart/LineChart.tsx b/src/line-chart/LineChart.tsx index 3b7a5a90..16cc27ec 100644 --- a/src/line-chart/LineChart.tsx +++ b/src/line-chart/LineChart.tsx @@ -982,7 +982,8 @@ class LineChart extends AbstractChart { contentOffset: { x: scrollableDotHorizontalOffset } } } - ])} + ], { useNativeDriver: false } + )} horizontal bounces={false} /> From a37be65fc0d7ac5015b413fa284d5bf5f0c61077 Mon Sep 17 00:00:00 2001 From: Colton McCormack Date: Mon, 7 Feb 2022 22:02:05 -0600 Subject: [PATCH 05/86] LineChart: Rework X axis labeling to allow dissimilar dataset lengths (#515) * Rework X axis labeling to allow dissimilar dataset lengths * Add prepare script for GitHub sourced library usage (builds on install) --- package.json | 4 ++-- src/line-chart/LineChart.tsx | 23 ++++++++++++++--------- 2 files changed, 16 insertions(+), 11 deletions(-) diff --git a/package.json b/package.json index 611973d1..1929b920 100644 --- a/package.json +++ b/package.json @@ -2,7 +2,6 @@ "name": "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", @@ -41,7 +40,8 @@ "test": "jest", "build": "tsc", "dev": "tsc --watch", - "prepublish": "yarn build" + "prepublish": "yarn build", + "prepare": "yarn build" }, "jest": { "preset": "jest-expo" diff --git a/src/line-chart/LineChart.tsx b/src/line-chart/LineChart.tsx index 16cc27ec..a487631a 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 + @@ -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`; From f30a37d73cd02807c2f19cd8094f1cacb9f6ba3b Mon Sep 17 00:00:00 2001 From: Ezra Free Date: Mon, 7 Feb 2022 21:03:57 -0700 Subject: [PATCH 06/86] Add fillShadowGradientTo option (#513) * feat(line-chart): add fillShadowGradient To and From * feat(line-chart): set fillShadowGradientToOpacity * feat(line-chart): maintain backwards compatibility * feat(readme): update chart style object docs * feat(abstract): update option comments * feat(abstract): add offset options * feat(readme): update documentation * feat(readme): update documentation * feat(package): specify dependency resolutions * feat(abstract-chart): fix backwards compatibility Co-authored-by: Ezra Burga --- README.md | 38 ++++++++++-------- package.json | 5 ++- src/AbstractChart.tsx | 76 ++++++++++++++++++++++++++++++------ src/BarChart.tsx | 2 +- src/HelperTypes.ts | 27 +++++++++++++ src/line-chart/LineChart.tsx | 4 +- 6 files changed, 118 insertions(+), 34 deletions(-) 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/package.json b/package.json index 1929b920..9501f9f1 100644 --- a/package.json +++ b/package.json @@ -66,5 +66,8 @@ "repository": { "type": "git", "url": "https://github.com/indiespirit/react-native-chart-kit" + }, + "resolutions": { + "@types/react": "16.14.8" } -} \ No newline at end of file +} diff --git a/src/AbstractChart.tsx b/src/AbstractChart.tsx index 0d7ffb53..4f7b124f 100644 --- a/src/AbstractChart.tsx +++ b/src/AbstractChart.tsx @@ -381,6 +381,12 @@ class AbstractChart< | "backgroundGradientToOpacity" | "fillShadowGradient" | "fillShadowGradientOpacity" + | "fillShadowGradientFrom" + | "fillShadowGradientFromOpacity" + | "fillShadowGradientFromOffset" + | "fillShadowGradientTo" + | "fillShadowGradientToOpacity" + | "fillShadowGradientToOffset" >, | "width" | "height" @@ -392,6 +398,12 @@ class AbstractChart< | "backgroundGradientToOpacity" | "fillShadowGradient" | "fillShadowGradientOpacity" + | "fillShadowGradientFrom" + | "fillShadowGradientFromOpacity" + | "fillShadowGradientFromOffset" + | "fillShadowGradientTo" + | "fillShadowGradientToOpacity" + | "fillShadowGradientToOffset" > ) => { const { @@ -420,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 f7e8671a..9af3a8b7 100644 --- a/src/BarChart.tsx +++ b/src/BarChart.tsx @@ -95,7 +95,7 @@ class BarChart extends AbstractChart { fill={ withCustomBarColorFromData ? `url(#customColor_0_${i})` - : "url(#fillShadowGradient)" + : "url(#fillShadowGradientFrom)" } /> ); 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/line-chart/LineChart.tsx b/src/line-chart/LineChart.tsx index a487631a..895e911a 100644 --- a/src/line-chart/LineChart.tsx +++ b/src/line-chart/LineChart.tsx @@ -583,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} @@ -766,7 +766,7 @@ class LineChart extends AbstractChart { Date: Mon, 14 Jun 2021 12:55:16 -0500 Subject: [PATCH 07/86] add actions and formatting to pie chart --- package.json | 2 +- src/PieChart.tsx | 9 ++++++++- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/package.json b/package.json index 9501f9f1..064a6813 100644 --- a/package.json +++ b/package.json @@ -1,5 +1,5 @@ { - "name": "react-native-chart-kit", + "name": "@adalo/react-native-chart-kit", "version": "6.11.0", "devDependencies": { "@types/react-native": "^0.62.13", diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 3e498ddc..26f77a9c 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -70,7 +70,11 @@ class PieChart extends AbstractChart { return ( - + {hasLegend ? ( { fill={c.item.legendFontColor} fontSize={c.item.legendFontSize} fontFamily={c.item.legendFontFamily} + fontWeight={c.item.legendFontWeight} x={this.props.width / 2.5} y={ -(this.props.height / 2.5) + ((this.props.height * 0.8) / this.props.data.length) * i + 12 * 2 } + // @ts-expect-error + width={this.props.width / 2.5} > {`${value} ${c.item.name}`} From ab7dd12cea51c93b47d34f4778b6315712844355 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 13:02:33 -0500 Subject: [PATCH 08/86] edited package.json --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 064a6813..9501f9f1 100644 --- a/package.json +++ b/package.json @@ -1,5 +1,5 @@ { - "name": "@adalo/react-native-chart-kit", + "name": "react-native-chart-kit", "version": "6.11.0", "devDependencies": { "@types/react-native": "^0.62.13", From a28230969efe5fc4308df219db355040293f3b42 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 13:11:37 -0500 Subject: [PATCH 09/86] added console.logs --- src/PieChart.tsx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 26f77a9c..f93f7590 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -67,7 +67,7 @@ class PieChart extends AbstractChart { } } } - + console.log(c.item); return ( Date: Mon, 14 Jun 2021 13:22:49 -0500 Subject: [PATCH 10/86] removed console.log --- src/PieChart.tsx | 1 - 1 file changed, 1 deletion(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index f93f7590..8db13538 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -67,7 +67,6 @@ class PieChart extends AbstractChart { } } } - console.log(c.item); return ( Date: Mon, 14 Jun 2021 13:50:24 -0500 Subject: [PATCH 11/86] added view wrapper around text --- src/PieChart.tsx | 31 ++++++++++++++++++------------- 1 file changed, 18 insertions(+), 13 deletions(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 8db13538..c855a53a 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -90,22 +90,27 @@ class PieChart extends AbstractChart { /> ) : null} {hasLegend ? ( - - {`${value} ${c.item.name}`} - + + {`${value} ${c.item.name}`} + + ) : null} ); From 681b51c7dc847a3fc88a9cc30f80386d89c6e698 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 13:53:29 -0500 Subject: [PATCH 12/86] add flex and flex wrap properties to text --- src/PieChart.tsx | 33 +++++++++++++++------------------ 1 file changed, 15 insertions(+), 18 deletions(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index c855a53a..391cba33 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -90,27 +90,24 @@ class PieChart extends AbstractChart { /> ) : null} {hasLegend ? ( - - - {`${value} ${c.item.name}`} - - + {`${value} ${c.item.name}`} + ) : null} ); From fd84c862bf07029e27f9e15d986d25beff238cc3 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 13:57:19 -0500 Subject: [PATCH 13/86] added style to text --- src/PieChart.tsx | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 391cba33..f6ef93ca 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -103,8 +103,7 @@ class PieChart extends AbstractChart { } // @ts-expect-error width={this.props.width / 2.5} - flex={1} - flexWrap={"wrap"} + style={{ width: this.props.width / 2.5 }} > {`${value} ${c.item.name}`} From 84a57ee38f14f0c3ef1fb1c08f72c40a889ca313 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 13:59:35 -0500 Subject: [PATCH 14/86] added numberOfLines prop --- src/PieChart.tsx | 1 + 1 file changed, 1 insertion(+) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index f6ef93ca..ef925aec 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -102,6 +102,7 @@ class PieChart extends AbstractChart { 12 * 2 } // @ts-expect-error + numberOfLines={3} width={this.props.width / 2.5} style={{ width: this.props.width / 2.5 }} > From 3a0afd96e5f8d07866985de26f2c3c3d3c1cc913 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 14:35:13 -0500 Subject: [PATCH 15/86] added width to G --- src/PieChart.tsx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index ef925aec..4e4b6461 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -102,7 +102,6 @@ class PieChart extends AbstractChart { 12 * 2 } // @ts-expect-error - numberOfLines={3} width={this.props.width / 2.5} style={{ width: this.props.width / 2.5 }} > @@ -143,6 +142,8 @@ class PieChart extends AbstractChart { Number(this.props.paddingLeft ? this.props.paddingLeft : 0) } y={this.props.height / 2} + // @ts-expect-error + width={this.props.width} > {slices} From 15cf1ce8b946e85c5652147ac659c2e746fe7b9b Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 14:42:48 -0500 Subject: [PATCH 16/86] moved width declaration --- src/PieChart.tsx | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 4e4b6461..faada987 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -68,7 +68,11 @@ class PieChart extends AbstractChart { } } return ( - + { Number(this.props.paddingLeft ? this.props.paddingLeft : 0) } y={this.props.height / 2} - // @ts-expect-error - width={this.props.width} > {slices} From 4682b9e7cfb5c9d5026f0e678c1a8b8c18cf2ad9 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 14:58:44 -0500 Subject: [PATCH 17/86] more width --- src/PieChart.tsx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index faada987..1c057152 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -107,7 +107,6 @@ class PieChart extends AbstractChart { } // @ts-expect-error width={this.props.width / 2.5} - style={{ width: this.props.width / 2.5 }} > {`${value} ${c.item.name}`} @@ -146,6 +145,8 @@ class PieChart extends AbstractChart { Number(this.props.paddingLeft ? this.props.paddingLeft : 0) } y={this.props.height / 2} + // @ts-expect-error + width={this.props.width} > {slices} From 0a709c2abae9a9aed563fc86ec96f4ee225afb3e Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 15:20:51 -0500 Subject: [PATCH 18/86] added useTextWidth --- package.json | 1 + src/PieChart.tsx | 17 ++++++++++++++++- 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/package.json b/package.json index 9501f9f1..adcb6944 100644 --- a/package.json +++ b/package.json @@ -52,6 +52,7 @@ "react-native-svg": "> 6.4.1" }, "dependencies": { + "@imagemarker/use-text-width": "^0.4.4", "lodash": "^4.17.13", "paths-js": "^0.4.10", "point-in-polygon": "^1.0.1" diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 1c057152..a37860bd 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -1,7 +1,8 @@ import Pie from "paths-js/pie"; import React from "react"; import { View, ViewStyle } from "react-native"; -import { G, Path, Rect, Svg, Text } from "react-native-svg"; +import { G, Path, Rect, Svg, Text, TSpan } from "react-native-svg"; +import { useTextWidth } from "@imagemarker/use-text-width"; import AbstractChart, { AbstractChartProps } from "./AbstractChart"; @@ -156,4 +157,18 @@ class PieChart extends AbstractChart { } } +const labelText = ( + value: String, + name: String, + fontName: String, + fontSize: String +) => { + let fullText = value + " " + name; + let font = fontSize + " " + fontName; + const fullTextWidth = useTextWidth({ text: fullText, font: font }); + console.log(fullTextWidth); + + return {fullTextWidth}; +}; + export default PieChart; From 7ed5ca4d9cdecc3fc347c45708523f470beaae92 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 15:25:23 -0500 Subject: [PATCH 19/86] used label text function --- src/PieChart.tsx | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index a37860bd..eb9ea41c 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -110,6 +110,12 @@ class PieChart extends AbstractChart { width={this.props.width / 2.5} > {`${value} ${c.item.name}`} + {labelText( + value, + c.item.name, + c.item.legendFontFamily, + c.item.legendFontFamily + "px" + )} ) : null} From a190eeaf9cd19fcc05036843d11162d3e4ae6603 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 15:37:19 -0500 Subject: [PATCH 20/86] trying inlineSize --- package.json | 1 - src/PieChart.tsx | 25 +++---------------------- 2 files changed, 3 insertions(+), 23 deletions(-) diff --git a/package.json b/package.json index adcb6944..9501f9f1 100644 --- a/package.json +++ b/package.json @@ -52,7 +52,6 @@ "react-native-svg": "> 6.4.1" }, "dependencies": { - "@imagemarker/use-text-width": "^0.4.4", "lodash": "^4.17.13", "paths-js": "^0.4.10", "point-in-polygon": "^1.0.1" diff --git a/src/PieChart.tsx b/src/PieChart.tsx index eb9ea41c..1de9af83 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -2,7 +2,6 @@ import Pie from "paths-js/pie"; import React from "react"; import { View, ViewStyle } from "react-native"; import { G, Path, Rect, Svg, Text, TSpan } from "react-native-svg"; -import { useTextWidth } from "@imagemarker/use-text-width"; import AbstractChart, { AbstractChartProps } from "./AbstractChart"; @@ -109,13 +108,9 @@ class PieChart extends AbstractChart { // @ts-expect-error width={this.props.width / 2.5} > - {`${value} ${c.item.name}`} - {labelText( - value, - c.item.name, - c.item.legendFontFamily, - c.item.legendFontFamily + "px" - )} + + {`${value} ${c.item.name}`} + ) : null} @@ -163,18 +158,4 @@ class PieChart extends AbstractChart { } } -const labelText = ( - value: String, - name: String, - fontName: String, - fontSize: String -) => { - let fullText = value + " " + name; - let font = fontSize + " " + fontName; - const fullTextWidth = useTextWidth({ text: fullText, font: font }); - console.log(fullTextWidth); - - return {fullTextWidth}; -}; - export default PieChart; From 19ae97f30b8b4fd9bd06ac3d4c06f09e9d4f1c1e Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 15:42:51 -0500 Subject: [PATCH 21/86] added inlinesize to text --- src/PieChart.tsx | 1 + 1 file changed, 1 insertion(+) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 1de9af83..d3d3829b 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -107,6 +107,7 @@ class PieChart extends AbstractChart { } // @ts-expect-error width={this.props.width / 2.5} + inlineSize={this.props.width / 2.5} > {`${value} ${c.item.name}`} From c401d14f0b1e732feec63c6a93212cac2370bfae Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 15:47:16 -0500 Subject: [PATCH 22/86] added bounding rect --- src/PieChart.tsx | 34 ++++++++++++++++++++++------------ 1 file changed, 22 insertions(+), 12 deletions(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index d3d3829b..1df616fb 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -94,25 +94,35 @@ class PieChart extends AbstractChart { /> ) : null} {hasLegend ? ( - - - {`${value} ${c.item.name}`} - - + + + {`${value} ${c.item.name}`} + + + ) : null} ); From 80acf33ec13e93575dc5e0dadd737d0dc7b8586a Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 15:49:19 -0500 Subject: [PATCH 23/86] rect height --- src/PieChart.tsx | 1 + 1 file changed, 1 insertion(+) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 1df616fb..76e508ca 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -96,6 +96,7 @@ class PieChart extends AbstractChart { {hasLegend ? ( Date: Mon, 14 Jun 2021 15:53:49 -0500 Subject: [PATCH 24/86] back to inline size --- src/PieChart.tsx | 35 +++++++++++------------------------ 1 file changed, 11 insertions(+), 24 deletions(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 76e508ca..0ca61591 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -1,7 +1,7 @@ import Pie from "paths-js/pie"; import React from "react"; import { View, ViewStyle } from "react-native"; -import { G, Path, Rect, Svg, Text, TSpan } from "react-native-svg"; +import { G, Path, Rect, Svg, Text } from "react-native-svg"; import AbstractChart, { AbstractChartProps } from "./AbstractChart"; @@ -94,36 +94,23 @@ class PieChart extends AbstractChart { /> ) : null} {hasLegend ? ( - - - - {`${value} ${c.item.name}`} - - - + {`${value} ${c.item.name}`} + ) : null} ); From 0cecf53dcb2db0cd50d70391ae5b8180c5401d94 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 15:59:34 -0500 Subject: [PATCH 25/86] added text anchor --- src/PieChart.tsx | 1 + 1 file changed, 1 insertion(+) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 0ca61591..6b56e7c0 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -106,6 +106,7 @@ class PieChart extends AbstractChart { 12 * 2 } inlineSize={100} + textAnchor={"start"} // @ts-expect-error width={this.props.width / 2.5} > From 0d6783b7e03aa56a47bc43a3aeb33092f85d44fe Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 16:03:40 -0500 Subject: [PATCH 26/86] added tspan --- src/PieChart.tsx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 6b56e7c0..34bb45b4 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -1,7 +1,7 @@ import Pie from "paths-js/pie"; import React from "react"; import { View, ViewStyle } from "react-native"; -import { G, Path, Rect, Svg, Text } from "react-native-svg"; +import { G, Path, Rect, Svg, Text, TSpan } from "react-native-svg"; import AbstractChart, { AbstractChartProps } from "./AbstractChart"; @@ -110,7 +110,7 @@ class PieChart extends AbstractChart { // @ts-expect-error width={this.props.width / 2.5} > - {`${value} ${c.item.name}`} + {`${value} ${c.item.name}`} ) : null} From 52f7950f42fd21a24111cabe45b49a0e5716e62b Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 16:05:51 -0500 Subject: [PATCH 27/86] removed x prop onspan --- src/PieChart.tsx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 34bb45b4..4dfea5a7 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -110,7 +110,7 @@ class PieChart extends AbstractChart { // @ts-expect-error width={this.props.width / 2.5} > - {`${value} ${c.item.name}`} + {`${value} ${c.item.name}`} ) : null} From 1259d01d4a410f90b85f74452587575605d74082 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 16:15:43 -0500 Subject: [PATCH 28/86] remove position --- src/PieChart.tsx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 4dfea5a7..eeab4bd4 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -99,12 +99,12 @@ class PieChart extends AbstractChart { fontSize={c.item.legendFontSize} fontFamily={c.item.legendFontFamily} fontWeight={c.item.legendFontWeight} - x={this.props.width / 2.5} - y={ - -(this.props.height / 2.5) + - ((this.props.height * 0.8) / this.props.data.length) * i + - 12 * 2 - } + // x={this.props.width / 2.5} + // y={ + // -(this.props.height / 2.5) + + // ((this.props.height * 0.8) / this.props.data.length) * i + + // 12 * 2 + // } inlineSize={100} textAnchor={"start"} // @ts-expect-error From 356c04df52752e71e6823c3bcc94061a6d9f2948 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 16:19:45 -0500 Subject: [PATCH 29/86] returned positioning --- src/PieChart.tsx | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index eeab4bd4..31cf72de 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -68,11 +68,7 @@ class PieChart extends AbstractChart { } } return ( - + { fontSize={c.item.legendFontSize} fontFamily={c.item.legendFontFamily} fontWeight={c.item.legendFontWeight} - // x={this.props.width / 2.5} - // y={ - // -(this.props.height / 2.5) + - // ((this.props.height * 0.8) / this.props.data.length) * i + - // 12 * 2 - // } + x={this.props.width / 2.5} + y={ + -(this.props.height / 2.5) + + ((this.props.height * 0.8) / this.props.data.length) * i + + 12 * 2 + } inlineSize={100} textAnchor={"start"} // @ts-expect-error From 33ecc145a806782a703468124a17d60bc6d59046 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 16:27:49 -0500 Subject: [PATCH 30/86] new text library --- package.json | 1 + src/PieChart.tsx | 7 +++---- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/package.json b/package.json index 9501f9f1..6e19e2bf 100644 --- a/package.json +++ b/package.json @@ -52,6 +52,7 @@ "react-native-svg": "> 6.4.1" }, "dependencies": { + "@visx/text": "^1.10.0", "lodash": "^4.17.13", "paths-js": "^0.4.10", "point-in-polygon": "^1.0.1" diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 31cf72de..f9f6c39d 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -1,7 +1,8 @@ import Pie from "paths-js/pie"; import React from "react"; import { View, ViewStyle } from "react-native"; -import { G, Path, Rect, Svg, Text, TSpan } from "react-native-svg"; +import { G, Path, Rect, Svg } from "react-native-svg"; +import { Text } from "@visx/text"; import AbstractChart, { AbstractChartProps } from "./AbstractChart"; @@ -101,12 +102,10 @@ class PieChart extends AbstractChart { ((this.props.height * 0.8) / this.props.data.length) * i + 12 * 2 } - inlineSize={100} textAnchor={"start"} - // @ts-expect-error width={this.props.width / 2.5} > - {`${value} ${c.item.name}`} + {`${value} ${c.item.name}`} ) : null} From 8ec2c4e14ff3dd2e2071d2dd3c263c27c7459aee Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 16:32:44 -0500 Subject: [PATCH 31/86] scale to fit prop --- src/PieChart.tsx | 1 + 1 file changed, 1 insertion(+) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index f9f6c39d..457c4724 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -104,6 +104,7 @@ class PieChart extends AbstractChart { } textAnchor={"start"} width={this.props.width / 2.5} + scaleToFit > {`${value} ${c.item.name}`} From 9b4949203093e920f036429e823c27314fc901ad Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 16:34:30 -0500 Subject: [PATCH 32/86] removed scale to fit --- src/PieChart.tsx | 1 - 1 file changed, 1 deletion(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 457c4724..f9f6c39d 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -104,7 +104,6 @@ class PieChart extends AbstractChart { } textAnchor={"start"} width={this.props.width / 2.5} - scaleToFit > {`${value} ${c.item.name}`} From aafcae8d11f52d9565edbf8558dc2f4673d96f20 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 16:39:14 -0500 Subject: [PATCH 33/86] check with fixed width --- src/PieChart.tsx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index f9f6c39d..bf63b4f1 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -102,8 +102,8 @@ class PieChart extends AbstractChart { ((this.props.height * 0.8) / this.props.data.length) * i + 12 * 2 } - textAnchor={"start"} - width={this.props.width / 2.5} + // textAnchor={"start"} + width={100} > {`${value} ${c.item.name}`} From 17ab0164716678a4f816d6f82f67840d3b5058df Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 16:44:08 -0500 Subject: [PATCH 34/86] remove position with new library --- src/PieChart.tsx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index bf63b4f1..7848af4f 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -96,12 +96,12 @@ class PieChart extends AbstractChart { fontSize={c.item.legendFontSize} fontFamily={c.item.legendFontFamily} fontWeight={c.item.legendFontWeight} - x={this.props.width / 2.5} - y={ - -(this.props.height / 2.5) + - ((this.props.height * 0.8) / this.props.data.length) * i + - 12 * 2 - } + // x={this.props.width / 2.5} + // y={ + // -(this.props.height / 2.5) + + // ((this.props.height * 0.8) / this.props.data.length) * i + + // 12 * 2 + // } // textAnchor={"start"} width={100} > From 0c2561498153e766276b841a092fa81c918f60a0 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 16:46:35 -0500 Subject: [PATCH 35/86] readded positioning --- src/PieChart.tsx | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 7848af4f..ca270720 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -96,14 +96,14 @@ class PieChart extends AbstractChart { fontSize={c.item.legendFontSize} fontFamily={c.item.legendFontFamily} fontWeight={c.item.legendFontWeight} - // x={this.props.width / 2.5} - // y={ - // -(this.props.height / 2.5) + - // ((this.props.height * 0.8) / this.props.data.length) * i + - // 12 * 2 - // } + x={this.props.width / 2.5} + y={ + -(this.props.height / 2.5) + + ((this.props.height * 0.8) / this.props.data.length) * i + + 12 * 2 + } // textAnchor={"start"} - width={100} + width={this.props.width - this.props.width / 2.5} > {`${value} ${c.item.name}`} From a41d51446aab3d29362b5b62dffad429843cd5b3 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 16:49:31 -0500 Subject: [PATCH 36/86] original calculation --- src/PieChart.tsx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index ca270720..71bf43fe 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -103,7 +103,7 @@ class PieChart extends AbstractChart { 12 * 2 } // textAnchor={"start"} - width={this.props.width - this.props.width / 2.5} + width={this.props.width / 2.5} > {`${value} ${c.item.name}`} From 9b96c82d80246db4d68f499c6743646805375a6d Mon Sep 17 00:00:00 2001 From: TDH55 Date: Mon, 14 Jun 2021 16:51:26 -0500 Subject: [PATCH 37/86] account for bullet point --- src/PieChart.tsx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 71bf43fe..8f36ca6a 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -103,7 +103,7 @@ class PieChart extends AbstractChart { 12 * 2 } // textAnchor={"start"} - width={this.props.width / 2.5} + width={this.props.width / 2.5 - 16} > {`${value} ${c.item.name}`} From 4d9f4f02a834dcd7b4f949f90f5d906a39379c0a Mon Sep 17 00:00:00 2001 From: TDH55 Date: Tue, 15 Jun 2021 15:54:37 -0500 Subject: [PATCH 38/86] ran build command --- .gitignore | 1 - dist/AbstractChart.d.ts | 538 +++++++++++ dist/AbstractChart.d.ts.map | 1 + dist/AbstractChart.js | 468 ++++++++++ dist/BarChart.d.ts | 223 +++++ dist/BarChart.d.ts.map | 1 + dist/BarChart.js | 350 ++++++++ dist/HelperTypes.d.ts | 135 +++ dist/HelperTypes.d.ts.map | 1 + dist/HelperTypes.js | 1 + dist/PieChart.d.ts | 22 + dist/PieChart.d.ts.map | 1 + dist/PieChart.js | 183 ++++ dist/ProgressChart.d.ts | 41 + dist/ProgressChart.d.ts.map | 1 + dist/ProgressChart.js | 228 +++++ dist/StackedBarChart.d.ts | 140 +++ dist/StackedBarChart.d.ts.map | 1 + dist/StackedBarChart.js | 288 ++++++ dist/Utils.d.ts | 8 + dist/Utils.d.ts.map | 1 + dist/Utils.js | 4 + .../contribution-graph/ContributionGraph.d.ts | 71 ++ .../ContributionGraph.d.ts.map | 1 + dist/contribution-graph/ContributionGraph.js | 400 +++++++++ dist/contribution-graph/DateHelpers.d.ts | 4 + dist/contribution-graph/DateHelpers.d.ts.map | 1 + dist/contribution-graph/DateHelpers.js | 14 + dist/contribution-graph/constants.d.ts | 17 + dist/contribution-graph/constants.d.ts.map | 1 + dist/contribution-graph/constants.js | 17 + dist/contribution-graph/index.d.ts | 38 + dist/contribution-graph/index.d.ts.map | 1 + dist/contribution-graph/index.js | 3 + dist/index.d.ts | 17 + dist/index.d.ts.map | 1 + dist/index.js | 17 + dist/line-chart/LegendItem.d.ts | 12 + dist/line-chart/LegendItem.d.ts.map | 1 + dist/line-chart/LegendItem.js | 42 + dist/line-chart/LineChart.d.ts | 302 +++++++ dist/line-chart/LineChart.d.ts.map | 1 + dist/line-chart/LineChart.js | 837 ++++++++++++++++++ dist/line-chart/index.d.ts | 3 + dist/line-chart/index.d.ts.map | 1 + dist/line-chart/index.js | 3 + 46 files changed, 4441 insertions(+), 1 deletion(-) create mode 100644 dist/AbstractChart.d.ts create mode 100644 dist/AbstractChart.d.ts.map create mode 100644 dist/AbstractChart.js create mode 100644 dist/BarChart.d.ts create mode 100644 dist/BarChart.d.ts.map create mode 100644 dist/BarChart.js create mode 100644 dist/HelperTypes.d.ts create mode 100644 dist/HelperTypes.d.ts.map create mode 100644 dist/HelperTypes.js create mode 100644 dist/PieChart.d.ts create mode 100644 dist/PieChart.d.ts.map create mode 100644 dist/PieChart.js create mode 100644 dist/ProgressChart.d.ts create mode 100644 dist/ProgressChart.d.ts.map create mode 100644 dist/ProgressChart.js create mode 100644 dist/StackedBarChart.d.ts create mode 100644 dist/StackedBarChart.d.ts.map create mode 100644 dist/StackedBarChart.js create mode 100644 dist/Utils.d.ts create mode 100644 dist/Utils.d.ts.map create mode 100644 dist/Utils.js create mode 100644 dist/contribution-graph/ContributionGraph.d.ts create mode 100644 dist/contribution-graph/ContributionGraph.d.ts.map create mode 100644 dist/contribution-graph/ContributionGraph.js create mode 100644 dist/contribution-graph/DateHelpers.d.ts create mode 100644 dist/contribution-graph/DateHelpers.d.ts.map create mode 100644 dist/contribution-graph/DateHelpers.js create mode 100644 dist/contribution-graph/constants.d.ts create mode 100644 dist/contribution-graph/constants.d.ts.map create mode 100644 dist/contribution-graph/constants.js create mode 100644 dist/contribution-graph/index.d.ts create mode 100644 dist/contribution-graph/index.d.ts.map create mode 100644 dist/contribution-graph/index.js create mode 100644 dist/index.d.ts create mode 100644 dist/index.d.ts.map create mode 100644 dist/index.js create mode 100644 dist/line-chart/LegendItem.d.ts create mode 100644 dist/line-chart/LegendItem.d.ts.map create mode 100644 dist/line-chart/LegendItem.js create mode 100644 dist/line-chart/LineChart.d.ts create mode 100644 dist/line-chart/LineChart.d.ts.map create mode 100644 dist/line-chart/LineChart.js create mode 100644 dist/line-chart/index.d.ts create mode 100644 dist/line-chart/index.d.ts.map create mode 100644 dist/line-chart/index.js diff --git a/.gitignore b/.gitignore index eb549748..5e88d0dd 100644 --- a/.gitignore +++ b/.gitignore @@ -6,4 +6,3 @@ package-lock.json .idea .vscode yarn.lock -dist \ No newline at end of file diff --git a/dist/AbstractChart.d.ts b/dist/AbstractChart.d.ts new file mode 100644 index 00000000..c613e316 --- /dev/null +++ b/dist/AbstractChart.d.ts @@ -0,0 +1,538 @@ +import { 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; +} +export declare type AbstractChartState = {}; +export declare const DEFAULT_X_LABELS_HEIGHT_PERCENTAGE = 0.75; +declare class AbstractChart< + IProps extends AbstractChartProps, + IState extends AbstractChartState +> 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(): { + 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?: string | number; + inlineSize?: string | number; + alignmentBaseline?: import("react-native-svg").AlignmentBaseline; + baselineShift?: import("react-native-svg").BaselineShift; + verticalAlign?: string | number; + lengthAdjust?: import("react-native-svg").LengthAdjust; + textLength?: string | number; + fontData?: { + [name: string]: unknown; + }; + fontFeatureSettings?: string; + fill: import("react-native-svg").Color; + fillOpacity?: string | number; + fillRule?: import("react-native-svg").FillRule; + stroke?: import("react-native-svg").Color; + strokeWidth?: string | number; + strokeOpacity?: string | number; + strokeDasharray?: string | number | readonly (string | number)[]; + strokeDashoffset?: string | number; + strokeLinecap?: "round" | "butt" | "square"; + strokeLinejoin?: "round" | "bevel" | "miter"; + strokeMiterlimit?: string | number; + clipRule?: import("react-native-svg").FillRule; + clipPath?: string; + transform?: + | string + | import("react-native-svg").TransformObject + | import("react-native-svg").ColumnMajorTransformMatrix; + translate?: import("react-native-svg").NumberArray; + translateX?: string | number; + translateY?: string | number; + origin?: import("react-native-svg").NumberArray; + originX?: string | number; + originY?: string | number; + scale?: import("react-native-svg").NumberArray; + scaleX?: string | number; + scaleY?: string | number; + skew?: import("react-native-svg").NumberArray; + skewX?: string | number; + skewY?: string | number; + rotation?: string | number; + vectorEffect?: + | "default" + | "inherit" + | "none" + | "non-scaling-stroke" + | "nonScalingStroke" + | "uri"; + pointerEvents?: "auto" | "none" | "box-none" | "box-only"; + onStartShouldSetResponder?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + onMoveShouldSetResponder?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + onResponderEnd?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderGrant?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderReject?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderMove?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderRelease?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderStart?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderTerminationRequest?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + onResponderTerminate?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onStartShouldSetResponderCapture?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + onMoveShouldSetResponderCapture?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + 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; + font?: import("react-native-svg").FontObject; + fontStyle?: import("react-native-svg").FontStyle; + fontVariant?: import("react-native-svg").FontVariant; + fontWeight?: string | number; + fontStretch?: import("react-native-svg").FontStretch; + fontSize: string | number; + fontFamily?: string; + textAnchor?: import("react-native-svg").TextAnchor; + textDecoration?: import("react-native-svg").TextDecoration; + letterSpacing?: string | number; + wordSpacing?: string | number; + kerning?: string | number; + fontVariantLigatures?: import("react-native-svg").FontVariantLigatures; + fontVariationSettings?: string; + }; + getPropsForVerticalLabels(): { + 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?: string | number; + inlineSize?: string | number; + alignmentBaseline?: import("react-native-svg").AlignmentBaseline; + baselineShift?: import("react-native-svg").BaselineShift; + verticalAlign?: string | number; + lengthAdjust?: import("react-native-svg").LengthAdjust; + textLength?: string | number; + fontData?: { + [name: string]: unknown; + }; + fontFeatureSettings?: string; + fill: import("react-native-svg").Color; + fillOpacity?: string | number; + fillRule?: import("react-native-svg").FillRule; + stroke?: import("react-native-svg").Color; + strokeWidth?: string | number; + strokeOpacity?: string | number; + strokeDasharray?: string | number | readonly (string | number)[]; + strokeDashoffset?: string | number; + strokeLinecap?: "round" | "butt" | "square"; + strokeLinejoin?: "round" | "bevel" | "miter"; + strokeMiterlimit?: string | number; + clipRule?: import("react-native-svg").FillRule; + clipPath?: string; + transform?: + | string + | import("react-native-svg").TransformObject + | import("react-native-svg").ColumnMajorTransformMatrix; + translate?: import("react-native-svg").NumberArray; + translateX?: string | number; + translateY?: string | number; + origin?: import("react-native-svg").NumberArray; + originX?: string | number; + originY?: string | number; + scale?: import("react-native-svg").NumberArray; + scaleX?: string | number; + scaleY?: string | number; + skew?: import("react-native-svg").NumberArray; + skewX?: string | number; + skewY?: string | number; + rotation?: string | number; + vectorEffect?: + | "default" + | "inherit" + | "none" + | "non-scaling-stroke" + | "nonScalingStroke" + | "uri"; + pointerEvents?: "auto" | "none" | "box-none" | "box-only"; + onStartShouldSetResponder?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + onMoveShouldSetResponder?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + onResponderEnd?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderGrant?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderReject?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderMove?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderRelease?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderStart?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderTerminationRequest?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + onResponderTerminate?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onStartShouldSetResponderCapture?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + onMoveShouldSetResponderCapture?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + 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; + font?: import("react-native-svg").FontObject; + fontStyle?: import("react-native-svg").FontStyle; + fontVariant?: import("react-native-svg").FontVariant; + fontWeight?: string | number; + fontStretch?: import("react-native-svg").FontStretch; + fontSize?: string | number; + fontFamily?: string; + textAnchor?: import("react-native-svg").TextAnchor; + textDecoration?: import("react-native-svg").TextDecoration; + letterSpacing?: string | number; + wordSpacing?: string | number; + kerning?: string | number; + fontVariantLigatures?: import("react-native-svg").FontVariantLigatures; + fontVariationSettings?: string; + }; + getPropsForHorizontalLabels(): { + 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?: string | number; + inlineSize?: string | number; + alignmentBaseline?: import("react-native-svg").AlignmentBaseline; + baselineShift?: import("react-native-svg").BaselineShift; + verticalAlign?: string | number; + lengthAdjust?: import("react-native-svg").LengthAdjust; + textLength?: string | number; + fontData?: { + [name: string]: unknown; + }; + fontFeatureSettings?: string; + fill: import("react-native-svg").Color; + fillOpacity?: string | number; + fillRule?: import("react-native-svg").FillRule; + stroke?: import("react-native-svg").Color; + strokeWidth?: string | number; + strokeOpacity?: string | number; + strokeDasharray?: string | number | readonly (string | number)[]; + strokeDashoffset?: string | number; + strokeLinecap?: "round" | "butt" | "square"; + strokeLinejoin?: "round" | "bevel" | "miter"; + strokeMiterlimit?: string | number; + clipRule?: import("react-native-svg").FillRule; + clipPath?: string; + transform?: + | string + | import("react-native-svg").TransformObject + | import("react-native-svg").ColumnMajorTransformMatrix; + translate?: import("react-native-svg").NumberArray; + translateX?: string | number; + translateY?: string | number; + origin?: import("react-native-svg").NumberArray; + originX?: string | number; + originY?: string | number; + scale?: import("react-native-svg").NumberArray; + scaleX?: string | number; + scaleY?: string | number; + skew?: import("react-native-svg").NumberArray; + skewX?: string | number; + skewY?: string | number; + rotation?: string | number; + vectorEffect?: + | "default" + | "inherit" + | "none" + | "non-scaling-stroke" + | "nonScalingStroke" + | "uri"; + pointerEvents?: "auto" | "none" | "box-none" | "box-only"; + onStartShouldSetResponder?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + onMoveShouldSetResponder?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + onResponderEnd?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderGrant?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderReject?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderMove?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderRelease?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderStart?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onResponderTerminationRequest?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + onResponderTerminate?: ( + event: import("react-native").GestureResponderEvent + ) => void; + onStartShouldSetResponderCapture?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + onMoveShouldSetResponderCapture?: ( + event: import("react-native").GestureResponderEvent + ) => boolean; + 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; + font?: import("react-native-svg").FontObject; + fontStyle?: import("react-native-svg").FontStyle; + fontVariant?: import("react-native-svg").FontVariant; + fontWeight?: string | number; + fontStretch?: import("react-native-svg").FontStretch; + fontSize?: string | number; + fontFamily?: string; + textAnchor?: import("react-native-svg").TextAnchor; + textDecoration?: import("react-native-svg").TextDecoration; + letterSpacing?: string | number; + wordSpacing?: string | number; + kerning?: string | number; + fontVariantLigatures?: import("react-native-svg").FontVariantLigatures; + fontVariationSettings?: string; + }; + renderHorizontalLines: (config: any) => JSX.Element[]; + renderHorizontalLine: (config: any) => JSX.Element; + renderHorizontalLabels: ( + config: Pick< + AbstractChartConfig, + | "color" + | "style" + | "backgroundColor" + | "height" + | "paddingRight" + | "paddingTop" + | "width" + | "strokeWidth" + | "propsForBackgroundLines" + | "propsForLabels" + | "labelColor" + | "propsForVerticalLabels" + | "propsForHorizontalLabels" + | "count" + | "horizontalLabelRotation" + | "formatYLabel" + | "labels" + | "horizontalOffset" + | "stackedBar" + | "verticalLabelRotation" + | "formatXLabel" + | "verticalLabelsHeightPercentage" + | "backgroundGradientFrom" + | "backgroundGradientFromOpacity" + | "backgroundGradientTo" + | "backgroundGradientToOpacity" + | "fillShadowGradient" + | "fillShadowGradientOpacity" + | "useShadowColorFromDataset" + | "barPercentage" + | "barRadius" + | "propsForDots" + | "decimalPlaces" + | "linejoinType" + | "scrollableDotFill" + | "scrollableDotStrokeColor" + | "scrollableDotStrokeWidth" + | "scrollableDotRadius" + | "scrollableInfoViewStyle" + | "scrollableInfoTextStyle" + | "scrollableInfoTextDecorator" + | "scrollableInfoOffset" + | "scrollableInfoSize" + > & { + data: number[]; + } + ) => JSX.Element[]; + renderVerticalLabels: ({ + labels, + width, + height, + paddingRight, + paddingTop, + horizontalOffset, + stackedBar, + verticalLabelRotation, + formatXLabel, + verticalLabelsHeightPercentage + }: Pick< + AbstractChartConfig, + | "labels" + | "width" + | "height" + | "paddingRight" + | "paddingTop" + | "horizontalOffset" + | "stackedBar" + | "verticalLabelRotation" + | "formatXLabel" + | "verticalLabelsHeightPercentage" + >) => JSX.Element[]; + renderVerticalLines: ({ + data, + width, + height, + paddingTop, + paddingRight, + verticalLabelsHeightPercentage + }: Pick< + Pick< + AbstractChartConfig, + | "height" + | "paddingRight" + | "paddingTop" + | "width" + | "data" + | "verticalLabelsHeightPercentage" + >, + | "height" + | "paddingRight" + | "paddingTop" + | "width" + | "verticalLabelsHeightPercentage" + > & { + data: number[]; + }) => JSX.Element[]; + renderVerticalLine: ({ + height, + paddingTop, + paddingRight, + verticalLabelsHeightPercentage + }: Pick< + AbstractChartConfig, + "height" | "paddingRight" | "paddingTop" | "verticalLabelsHeightPercentage" + >) => JSX.Element; + renderDefs: ( + config: Pick< + PartialBy< + AbstractChartConfig, + | "backgroundGradientFromOpacity" + | "backgroundGradientToOpacity" + | "fillShadowGradient" + | "fillShadowGradientOpacity" + >, + | "width" + | "height" + | "backgroundGradientFrom" + | "backgroundGradientTo" + | "useShadowColorFromDataset" + | "data" + | "backgroundGradientFromOpacity" + | "backgroundGradientToOpacity" + | "fillShadowGradient" + | "fillShadowGradientOpacity" + > + ) => JSX.Element; +} +export default AbstractChart; +//# sourceMappingURL=AbstractChart.d.ts.map diff --git a/dist/AbstractChart.d.ts.map b/dist/AbstractChart.d.ts.map new file mode 100644 index 00000000..187f8941 --- /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..65200aab --- /dev/null +++ b/dist/AbstractChart.js @@ -0,0 +1,468 @@ +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 (b.hasOwnProperty(p)) d[p] = b[p]; + }; + return extendStatics(d, b); + }; + return function(d, b) { + 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 __spreadArrays = + (this && this.__spreadArrays) || + function() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) + s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; + }; +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) { + return ( + Math.max.apply(Math, __spreadArrays(data, [0])) - + Math.min.apply(Math, __spreadArrays(data, [0])) || 1 + ); + } else if (_this.props.fromNumber) { + return ( + Math.max.apply(Math, __spreadArrays(data, [_this.props.fromNumber])) - + Math.min.apply( + Math, + __spreadArrays(data, [_this.props.fromNumber]) + ) || 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 __spreadArrays(new Array(count + 1)).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 = + "" + + yAxisLabel + + formatYLabel(data[0].toFixed(decimalPlaces)) + + yAxisSuffix; + } else { + var label = _this.props.fromZero + ? (_this.calcScaler(data) / count) * i + + Math.min.apply(Math, __spreadArrays(data, [0])) + : (_this.calcScaler(data) / count) * i + Math.min.apply(Math, data); + yLabel = + "" + + yAxisLabel + + formatYLabel(label.toFixed(decimalPlaces)) + + 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 ( + + {"" + formatXLabel(label) + 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 __spreadArrays( + new Array(Math.ceil(data.length / yAxisInterval)) + ).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; + 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}\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) {\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      >,\n      | \"width\"\n      | \"height\"\n      | \"backgroundGradientFrom\"\n      | \"backgroundGradientTo\"\n      | \"useShadowColorFromDataset\"\n      | \"data\"\n      | \"backgroundGradientFromOpacity\"\n      | \"backgroundGradientToOpacity\"\n      | \"fillShadowGradient\"\n      | \"fillShadowGradientOpacity\"\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    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={`fillShadowGradient_${index}`}\n              key={`${index}`}\n              x1={0}\n              y1={0}\n              x2={0}\n              y2={height}\n              gradientUnits=\"userSpaceOnUse\"\n            >\n              <Stop\n                offset=\"0\"\n                stopColor={\n                  dataset.color ? dataset.color(1.0) : fillShadowGradient\n                }\n                stopOpacity={fillShadowGradientOpacity}\n              />\n              <Stop\n                offset=\"1\"\n                stopColor={\n                  dataset.color\n                    ? dataset.color(fillShadowGradientOpacity)\n                    : fillShadowGradient\n                }\n                stopOpacity=\"0\"\n              />\n            </LinearGradient>\n          ))\n        ) : (\n          <LinearGradient\n            id=\"fillShadowGradient\"\n            x1={0}\n            y1={0}\n            x2={0}\n            y2={height}\n            gradientUnits=\"userSpaceOnUse\"\n          >\n            <Stop\n              offset=\"0\"\n              stopColor={fillShadowGradient}\n              stopOpacity={fillShadowGradientOpacity}\n            />\n            <Stop offset=\"1\" stopColor={fillShadowGradient} stopOpacity=\"0\" />\n          </LinearGradient>\n        )}\n      </Defs>\n    );\n  };\n}\n\nexport default AbstractChart;\n"]} diff --git a/dist/BarChart.d.ts b/dist/BarChart.d.ts new file mode 100644 index 00000000..76e2ed02 --- /dev/null +++ b/dist/BarChart.d.ts @@ -0,0 +1,223 @@ +/// +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; +} +declare type BarChartState = {}; +declare class BarChart extends AbstractChart { + getBarPercentage: () => number; + renderBars: ({ + data, + width, + height, + paddingTop, + paddingRight, + barRadius, + withCustomBarColorFromData + }: Pick< + Pick< + AbstractChartConfig, + | "color" + | "style" + | "backgroundColor" + | "height" + | "paddingRight" + | "paddingTop" + | "width" + | "strokeWidth" + | "propsForBackgroundLines" + | "propsForLabels" + | "labelColor" + | "propsForVerticalLabels" + | "propsForHorizontalLabels" + | "count" + | "horizontalLabelRotation" + | "formatYLabel" + | "labels" + | "horizontalOffset" + | "stackedBar" + | "verticalLabelRotation" + | "formatXLabel" + | "verticalLabelsHeightPercentage" + | "backgroundGradientFrom" + | "backgroundGradientFromOpacity" + | "backgroundGradientTo" + | "backgroundGradientToOpacity" + | "fillShadowGradient" + | "fillShadowGradientOpacity" + | "useShadowColorFromDataset" + | "barPercentage" + | "barRadius" + | "propsForDots" + | "decimalPlaces" + | "linejoinType" + | "scrollableDotFill" + | "scrollableDotStrokeColor" + | "scrollableDotStrokeWidth" + | "scrollableDotRadius" + | "scrollableInfoViewStyle" + | "scrollableInfoTextStyle" + | "scrollableInfoTextDecorator" + | "scrollableInfoOffset" + | "scrollableInfoSize" + >, + "height" | "paddingRight" | "paddingTop" | "width" | "barRadius" + > & { + data: number[]; + withCustomBarColorFromData: boolean; + }) => JSX.Element[]; + renderBarTops: ({ + data, + width, + height, + paddingTop, + paddingRight + }: Pick< + Pick< + AbstractChartConfig, + | "color" + | "style" + | "backgroundColor" + | "height" + | "paddingRight" + | "paddingTop" + | "width" + | "strokeWidth" + | "propsForBackgroundLines" + | "propsForLabels" + | "labelColor" + | "propsForVerticalLabels" + | "propsForHorizontalLabels" + | "count" + | "horizontalLabelRotation" + | "formatYLabel" + | "labels" + | "horizontalOffset" + | "stackedBar" + | "verticalLabelRotation" + | "formatXLabel" + | "verticalLabelsHeightPercentage" + | "backgroundGradientFrom" + | "backgroundGradientFromOpacity" + | "backgroundGradientTo" + | "backgroundGradientToOpacity" + | "fillShadowGradient" + | "fillShadowGradientOpacity" + | "useShadowColorFromDataset" + | "barPercentage" + | "barRadius" + | "propsForDots" + | "decimalPlaces" + | "linejoinType" + | "scrollableDotFill" + | "scrollableDotStrokeColor" + | "scrollableDotStrokeWidth" + | "scrollableDotRadius" + | "scrollableInfoViewStyle" + | "scrollableInfoTextStyle" + | "scrollableInfoTextDecorator" + | "scrollableInfoOffset" + | "scrollableInfoSize" + >, + "height" | "paddingRight" | "paddingTop" | "width" + > & { + data: number[]; + }) => JSX.Element[]; + renderColors: ({ + data, + flatColor + }: Pick & { + flatColor: boolean; + }) => JSX.Element[]; + renderValuesOnTopOfBars: ({ + data, + width, + height, + paddingTop, + paddingRight + }: Pick< + Pick< + AbstractChartConfig, + | "color" + | "style" + | "backgroundColor" + | "height" + | "paddingRight" + | "paddingTop" + | "width" + | "strokeWidth" + | "propsForBackgroundLines" + | "propsForLabels" + | "labelColor" + | "propsForVerticalLabels" + | "propsForHorizontalLabels" + | "count" + | "horizontalLabelRotation" + | "formatYLabel" + | "labels" + | "horizontalOffset" + | "stackedBar" + | "verticalLabelRotation" + | "formatXLabel" + | "verticalLabelsHeightPercentage" + | "backgroundGradientFrom" + | "backgroundGradientFromOpacity" + | "backgroundGradientTo" + | "backgroundGradientToOpacity" + | "fillShadowGradient" + | "fillShadowGradientOpacity" + | "useShadowColorFromDataset" + | "barPercentage" + | "barRadius" + | "propsForDots" + | "decimalPlaces" + | "linejoinType" + | "scrollableDotFill" + | "scrollableDotStrokeColor" + | "scrollableDotStrokeWidth" + | "scrollableDotRadius" + | "scrollableInfoViewStyle" + | "scrollableInfoTextStyle" + | "scrollableInfoTextDecorator" + | "scrollableInfoOffset" + | "scrollableInfoSize" + >, + "height" | "paddingRight" | "paddingTop" | "width" + > & { + data: number[]; + }) => JSX.Element[]; + render(): JSX.Element; +} +export default BarChart; +//# sourceMappingURL=BarChart.d.ts.map diff --git a/dist/BarChart.d.ts.map b/dist/BarChart.d.ts.map new file mode 100644 index 00000000..2ec1865a --- /dev/null +++ b/dist/BarChart.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"BarChart.d.ts","sourceRoot":"","sources":["../src/BarChart.tsx"],"names":[],"mappings":";AACA,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;CACrB;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,gBAAgB,eAGd;IAEF,UAAU;cAYF,MAAM,EAAE;oCACc,OAAO;wBA8BnC;IAEF,aAAa;cAUL,MAAM,EAAE;wBAsBd;IAEF,YAAY;mBAIC,OAAO;wBA4BlB;IAEF,uBAAuB;cAUf,MAAM,EAAE;wBAwBd;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..df102c87 --- /dev/null +++ b/dist/BarChart.js @@ -0,0 +1,350 @@ +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 (b.hasOwnProperty(p)) d[p] = b[p]; + }; + return extendStatics(d, b); + }; + return function(d, b) { + 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_" + i + ")" + : "url(#fillShadowGradient)" + } + /> + ); + }); + }; + _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); + return data.map(function(x, i) { + var barHeight = _this.calcHeight(x, data, height); + var barWidth = 32 * _this.getBarPercentage(); + return ( + + {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":"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","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\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(#fillShadowGradient)\"\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    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          y={((baseHeight - barHeight) / 4) * 3 + paddingTop - 1}\n          fill={this.props.chartConfig.color(0.6)}\n          fontSize=\"12\"\n          textAnchor=\"middle\"\n        >\n          {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={borderRadius}\n            ry={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"]} diff --git a/dist/HelperTypes.d.ts b/dist/HelperTypes.d.ts new file mode 100644 index 00000000..2da7b806 --- /dev/null +++ b/dist/HelperTypes.d.ts @@ -0,0 +1,135 @@ +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; + fillShadowGradient?: string; + fillShadowGradientOpacity?: 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 declare type PartialBy = Omit & + Partial>; +//# sourceMappingURL=HelperTypes.d.ts.map diff --git a/dist/HelperTypes.d.ts.map b/dist/HelperTypes.d.ts.map new file mode 100644 index 00000000..939631c5 --- /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..e7d2597d --- /dev/null +++ b/dist/HelperTypes.js @@ -0,0 +1 @@ +//# sourceMappingURL=data:application/json;base64,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 diff --git a/dist/PieChart.d.ts b/dist/PieChart.d.ts new file mode 100644 index 00000000..68a5a27c --- /dev/null +++ b/dist/PieChart.d.ts @@ -0,0 +1,22 @@ +/// +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; +} +declare type PieChartState = {}; +declare class PieChart extends AbstractChart { + render(): JSX.Element; +} +export default PieChart; +//# sourceMappingURL=PieChart.d.ts.map diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map new file mode 100644 index 00000000..c825500c --- /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,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC1B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAgIP;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..a405e407 --- /dev/null +++ b/dist/PieChart.js @@ -0,0 +1,183 @@ +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 (b.hasOwnProperty(p)) d[p] = b[p]; + }; + return extendStatics(d, b); + }; + return function(d, b) { + 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 } from "react-native-svg"; +import { Text } from "@visx/text"; +import AbstractChart from "./AbstractChart"; +var PieChart = /** @class */ (function(_super) { + __extends(PieChart, _super); + function PieChart() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + 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 _f = style.borderRadius, + borderRadius = _f === void 0 ? 0 : _f; + var chart = Pie({ + center: this.props.center || [0, 0], + r: 0, + R: this.props.height / 2.5, + data: this.props.data, + accessor: function(x) { + return x[_this.props.accessor]; + } + }); + var total = this.props.data.reduce(function(sum, item) { + return sum + item[_this.props.accessor]; + }, 0); + var slices = chart.curves.map(function(c, i) { + var value; + if (absolute) { + value = c.item[_this.props.accessor]; + } else { + if (total === 0) { + value = 0 + "%"; + } else { + var percentage = Math.round( + (100 / total) * c.item[_this.props.accessor] + ); + value = + Math.round((100 / total) * c.item[_this.props.accessor]) + "%"; + if (avoidFalseZero && percentage === 0) { + value = "<1%"; + } else { + value = percentage + "%"; + } + } + } + return ( + + + {hasLegend ? ( + + ) : null} + {hasLegend ? ( + + {value + " " + c.item.name} + + ) : null} + + ); + }); + return ( + + + + {this.renderDefs( + __assign( + { width: this.props.height, height: this.props.height }, + this.props.chartConfig + ) + )} + + + + {slices} + + + + ); + }; + 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 Pie from \"paths-js/pie\";\nimport React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport { G, Path, Rect, Svg } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\n\n    const { borderRadius = 0 } = style;\n\n    const chart = Pie({\n      center: this.props.center || [0, 0],\n      r: 0,\n      R: this.props.height / 2.5,\n      data: this.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\n    }, 0);\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const percentage = Math.round(\n            (100 / total) * c.item[this.props.accessor]\n          );\n          value = Math.round((100 / total) * c.item[this.props.accessor]) + \"%\";\n          if (avoidFalseZero && percentage === 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width=\"16px\"\n              height=\"16px\"\n              fill={c.item.color}\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) / this.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\n              fontSize={c.item.legendFontSize}\n              fontFamily={c.item.legendFontFamily}\n              fontWeight={c.item.legendFontWeight}\n              x={this.props.width / 2.5}\n              y={\n                -(this.props.height / 2.5) +\n                ((this.props.height * 0.8) / this.props.data.length) * i +\n                12 * 2\n              }\n              // textAnchor={\"start\"}\n              width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={borderRadius}\n            fill={backgroundColor}\n          />\n          <G\n            x={\n              this.props.width / 2 / 2 +\n              Number(this.props.paddingLeft ? this.props.paddingLeft : 0)\n            }\n            y={this.props.height / 2}\n            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/dist/ProgressChart.d.ts b/dist/ProgressChart.d.ts new file mode 100644 index 00000000..19987f3d --- /dev/null +++ b/dist/ProgressChart.d.ts @@ -0,0 +1,41 @@ +/// +import { ViewStyle } from "react-native"; +import AbstractChart, { + AbstractChartConfig, + AbstractChartProps +} from "./AbstractChart"; +export declare 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; +} +declare type ProgressChartState = {}; +declare class ProgressChart extends AbstractChart< + ProgressChartProps, + ProgressChartState +> { + static defaultProps: { + style: {}; + strokeWidth: number; + radius: number; + }; + render(): JSX.Element; +} +export default ProgressChart; +//# sourceMappingURL=ProgressChart.d.ts.map diff --git a/dist/ProgressChart.d.ts.map b/dist/ProgressChart.d.ts.map new file mode 100644 index 00000000..1c2867ac --- /dev/null +++ b/dist/ProgressChart.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"ProgressChart.d.ts","sourceRoot":"","sources":["../src/ProgressChart.tsx"],"names":[],"mappings":";AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,aAAa,EAAE,EACpB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AAEzB,oBAAY,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,aAAK,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..fc85228d --- /dev/null +++ b/dist/ProgressChart.js @@ -0,0 +1,228 @@ +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 (b.hasOwnProperty(p)) d[p] = b[p]; + }; + return extendStatics(d, b); + }; + return function(d, b) { + 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) + ? data.labels[i] + " " + Math.round(100 * data.data[i]) + "%" + : 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={borderRadius}\n            ry={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"]} diff --git a/dist/StackedBarChart.d.ts b/dist/StackedBarChart.d.ts new file mode 100644 index 00000000..51632dda --- /dev/null +++ b/dist/StackedBarChart.d.ts @@ -0,0 +1,140 @@ +/// +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; +} +declare type StackedBarChartState = {}; +declare class StackedBarChart extends AbstractChart< + StackedBarChartProps, + StackedBarChartState +> { + getBarPercentage: () => number; + getBarRadius: (ret: string | any[], x: string | any[]) => number; + renderBars: ({ + data, + width, + height, + paddingTop, + paddingRight, + border, + colors, + stackedBar, + verticalLabelsHeightPercentage + }: Pick< + Pick< + AbstractChartConfig, + | "color" + | "style" + | "backgroundColor" + | "height" + | "paddingRight" + | "paddingTop" + | "width" + | "strokeWidth" + | "propsForBackgroundLines" + | "propsForLabels" + | "labelColor" + | "propsForVerticalLabels" + | "propsForHorizontalLabels" + | "count" + | "horizontalLabelRotation" + | "formatYLabel" + | "labels" + | "horizontalOffset" + | "stackedBar" + | "verticalLabelRotation" + | "formatXLabel" + | "verticalLabelsHeightPercentage" + | "backgroundGradientFrom" + | "backgroundGradientFromOpacity" + | "backgroundGradientTo" + | "backgroundGradientToOpacity" + | "fillShadowGradient" + | "fillShadowGradientOpacity" + | "useShadowColorFromDataset" + | "barPercentage" + | "barRadius" + | "propsForDots" + | "decimalPlaces" + | "linejoinType" + | "scrollableDotFill" + | "scrollableDotStrokeColor" + | "scrollableDotStrokeWidth" + | "scrollableDotRadius" + | "scrollableInfoViewStyle" + | "scrollableInfoTextStyle" + | "scrollableInfoTextDecorator" + | "scrollableInfoOffset" + | "scrollableInfoSize" + >, + | "height" + | "paddingRight" + | "paddingTop" + | "width" + | "stackedBar" + | "verticalLabelsHeightPercentage" + > & { + border: number; + colors: string[]; + data: number[][]; + }) => any[][]; + renderLegend: ({ + legend, + colors, + width, + height + }: Pick & { + legend: string[]; + colors: string[]; + }) => JSX.Element[]; + render(): JSX.Element; +} +export default StackedBarChart; +//# sourceMappingURL=StackedBarChart.d.ts.map diff --git a/dist/StackedBarChart.d.ts.map b/dist/StackedBarChart.d.ts.map new file mode 100644 index 00000000..9efc9841 --- /dev/null +++ b/dist/StackedBarChart.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"StackedBarChart.d.ts","sourceRoot":"","sources":["../src/StackedBarChart.tsx"],"names":[],"mappings":";AACA,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,aAAK,oBAAoB,GAAG,EAAE,CAAC;AAE/B,cAAM,eAAgB,SAAQ,aAAa,CACzC,oBAAoB,EACpB,oBAAoB,CACrB;IACC,gBAAgB,eAGd;IAEF,YAAY,QAAS,MAAM,GAAG,GAAG,EAAE,KAAK,MAAM,GAAG,GAAG,EAAE,YAIpD;IAEF,UAAU;gBAmBA,MAAM;gBACN,MAAM,EAAE;cACV,MAAM,EAAE,EAAE;kBAsDb;IAEL,YAAY;gBAMF,MAAM,EAAE;gBACR,MAAM,EAAE;wBAuBb;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..69f162fc --- /dev/null +++ b/dist/StackedBarChart.js @@ -0,0 +1,288 @@ +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 (b.hasOwnProperty(p)) d[p] = b[p]; + }; + return extendStatics(d, b); + }; + return function(d, b) { + 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={borderRadius}\n            ry={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"]} diff --git a/dist/Utils.d.ts b/dist/Utils.d.ts new file mode 100644 index 00000000..2ade2726 --- /dev/null +++ b/dist/Utils.d.ts @@ -0,0 +1,8 @@ +export declare function mapValue( + x: number, + in_min: number, + in_max: number, + out_min: number, + out_max: number +): number; +//# sourceMappingURL=Utils.d.ts.map diff --git a/dist/Utils.d.ts.map b/dist/Utils.d.ts.map new file mode 100644 index 00000000..f546db9f --- /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"} \ No newline at end of file diff --git a/dist/Utils.js b/dist/Utils.js new file mode 100644 index 00000000..580bd212 --- /dev/null +++ b/dist/Utils.js @@ -0,0 +1,4 @@ +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; +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvVXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxVQUFVLFFBQVEsQ0FDdEIsQ0FBUyxFQUNULE1BQWMsRUFDZCxNQUFjLEVBQ2QsT0FBZSxFQUNmLE9BQWU7SUFFZixPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDLENBQUMsR0FBRyxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUMsR0FBRyxPQUFPLENBQUM7QUFDNUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBtYXBWYWx1ZShcbiAgeDogbnVtYmVyLFxuICBpbl9taW46IG51bWJlcixcbiAgaW5fbWF4OiBudW1iZXIsXG4gIG91dF9taW46IG51bWJlcixcbiAgb3V0X21heDogbnVtYmVyXG4pIHtcbiAgcmV0dXJuICgoeCAtIGluX21pbikgKiAob3V0X21heCAtIG91dF9taW4pKSAvIChpbl9tYXggLSBpbl9taW4pICsgb3V0X21pbjtcbn1cbiJdfQ== diff --git a/dist/contribution-graph/ContributionGraph.d.ts b/dist/contribution-graph/ContributionGraph.d.ts new file mode 100644 index 00000000..9861654c --- /dev/null +++ b/dist/contribution-graph/ContributionGraph.d.ts @@ -0,0 +1,71 @@ +/// +import { RectProps } from "react-native-svg"; +import AbstractChart from "../AbstractChart"; +import { ContributionGraphProps, ContributionGraphState } from "."; +export declare type ContributionChartValue = { + value: number; + title: string; + tooltipDataAttrs: TooltipDataAttrs; + date: Date; +}; +export declare type TooltipDataAttrs = ( + value: ContributionChartValue +) => Partial | Partial; +declare class ContributionGraph extends AbstractChart< + ContributionGraphProps, + ContributionGraphState +> { + 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): JSX.Element; + handleDayPress(index: number): void; + renderWeek(weekIndex: number): JSX.Element; + renderAllWeeks(): JSX.Element[]; + renderMonthLabels(): JSX.Element[]; + 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(): JSX.Element; +} +export default ContributionGraph; +//# sourceMappingURL=ContributionGraph.d.ts.map diff --git a/dist/contribution-graph/ContributionGraph.d.ts.map b/dist/contribution-graph/ContributionGraph.d.ts.map new file mode 100644 index 00000000..b022bddc --- /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":";AAGA,OAAO,EAAW,SAAS,EAAa,MAAM,kBAAkB,CAAC;AAEjE,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAY7C,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,GAAG,CAAC;AAMnE,oBAAY,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,oBAAY,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..9f12635d --- /dev/null +++ b/dist/contribution-graph/ContributionGraph.js @@ -0,0 +1,400 @@ +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 (b.hasOwnProperty(p)) d[p] = b[p]; + }; + return extendStatics(d, b); + }; + return function(d, b) { + 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.minValue, + 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 this.getWeekWidth() + MONTH_LABEL_GUTTER_SIZE + ", 0"; + }; + ContributionGraph.prototype.getTransformForAllWeeks = function() { + if (this.props.horizontal) { + return "0, " + (this.getMonthLabelSize() - 100); + } + return null; + }; + ContributionGraph.prototype.getViewBox = function() { + if (this.props.horizontal) { + return this.getWidth() + " " + this.getHeight(); + } + return this.getHeight() + " " + 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.minValue,\n            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={borderRadius}\n            ry={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"]} diff --git a/dist/contribution-graph/DateHelpers.d.ts b/dist/contribution-graph/DateHelpers.d.ts new file mode 100644 index 00000000..3e55a4fe --- /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 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..bad97a3d --- /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== diff --git a/dist/contribution-graph/constants.d.ts b/dist/contribution-graph/constants.d.ts new file mode 100644 index 00000000..2f86932f --- /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 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..38a2e98f --- /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 diff --git a/dist/contribution-graph/index.d.ts b/dist/contribution-graph/index.d.ts new file mode 100644 index 00000000..a9f8650b --- /dev/null +++ b/dist/contribution-graph/index.d.ts @@ -0,0 +1,38 @@ +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?: ({ + count: number, + date: Date + }: { + count: any; + date: any; + }) => void; + classForValue?: (value: string) => string; + style?: Partial; + titleForValue?: (value: ContributionChartValue) => string; + tooltipDataAttrs: TooltipDataAttrs; +} +export declare type ContributionGraphState = { + maxValue: number; + minValue: number; + valueCache: object; +}; +export default ContributionGraph; +//# sourceMappingURL=index.d.ts.map diff --git a/dist/contribution-graph/index.d.ts.map b/dist/contribution-graph/index.d.ts.map new file mode 100644 index 00000000..94b6293d --- /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,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE;;;KAAA,KAAK,IAAI,CAAC;IACrD,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,oBAAY,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..4a3c3002 --- /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+IHN0cmluZztcbiAgb25EYXlQcmVzcz86ICh7IGNvdW50OiBudW1iZXIsIGRhdGU6IERhdGUgfSkgPT4gdm9pZDtcbiAgY2xhc3NGb3JWYWx1ZT86ICh2YWx1ZTogc3RyaW5nKSA9PiBzdHJpbmc7XG4gIHN0eWxlPzogUGFydGlhbDxWaWV3U3R5bGU+O1xuICB0aXRsZUZvclZhbHVlPzogKHZhbHVlOiBDb250cmlidXRpb25DaGFydFZhbHVlKSA9PiBzdHJpbmc7XG4gIHRvb2x0aXBEYXRhQXR0cnM6IFRvb2x0aXBEYXRhQXR0cnM7XG59XG5cbmV4cG9ydCB0eXBlIENvbnRyaWJ1dGlvbkdyYXBoU3RhdGUgPSB7XG4gIG1heFZhbHVlOiBudW1iZXI7XG4gIG1pblZhbHVlOiBudW1iZXI7XG4gIHZhbHVlQ2FjaGU6IG9iamVjdDtcbn07XG5cbmV4cG9ydCBkZWZhdWx0IENvbnRyaWJ1dGlvbkdyYXBoO1xuIl19 diff --git a/dist/index.d.ts b/dist/index.d.ts new file mode 100644 index 00000000..7581680e --- /dev/null +++ b/dist/index.d.ts @@ -0,0 +1,17 @@ +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 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..ff143602 --- /dev/null +++ b/dist/index.js @@ -0,0 +1,17 @@ +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= diff --git a/dist/line-chart/LegendItem.d.ts b/dist/line-chart/LegendItem.d.ts new file mode 100644 index 00000000..7e41e428 --- /dev/null +++ b/dist/line-chart/LegendItem.d.ts @@ -0,0 +1,12 @@ +/// +import { Color, TextProps } from "react-native-svg"; +export declare type LegendItemProps = { + baseLegendItemX: number; + index: number; + legendOffset: number; + legendText: string; + iconColor: Color; + labelProps: TextProps; +}; +export declare const LegendItem: (props: LegendItemProps) => JSX.Element; +//# sourceMappingURL=LegendItem.d.ts.map diff --git a/dist/line-chart/LegendItem.d.ts.map b/dist/line-chart/LegendItem.d.ts.map new file mode 100644 index 00000000..174bfda3 --- /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":";AACA,OAAO,EAAE,KAAK,EAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAMhE,oBAAY,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,UAAW,eAAe,gBAmChD,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..7a01cb37 --- /dev/null +++ b/dist/line-chart/LegendItem.js @@ -0,0 +1,42 @@ +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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 diff --git a/dist/line-chart/LineChart.d.ts b/dist/line-chart/LineChart.d.ts new file mode 100644 index 00000000..419d325e --- /dev/null +++ b/dist/line-chart/LineChart.d.ts @@ -0,0 +1,302 @@ +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; +} +declare 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< + AbstractChartConfig, + "height" | "paddingRight" | "paddingTop" | "width" | "data" + > & { + 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< + AbstractChartConfig, + "height" | "paddingRight" | "paddingTop" | "width" | "data" + > & { + useColorFromDataset: AbstractChartConfig["useShadowColorFromDataset"]; + }) => JSX.Element[]; + renderLine: ({ + width, + height, + paddingRight, + paddingTop, + data, + linejoinType + }: Pick< + AbstractChartConfig, + "data" | "width" | "height" | "paddingRight" | "paddingTop" | "linejoinType" + >) => any[]; + getBezierLinePoints: ( + dataset: Dataset, + { + width, + height, + paddingRight, + paddingTop, + data + }: Pick< + AbstractChartConfig, + "width" | "height" | "paddingRight" | "paddingTop" | "data" + > + ) => string; + renderBezierLine: ({ + data, + width, + height, + paddingRight, + paddingTop + }: Pick< + AbstractChartConfig, + "data" | "width" | "height" | "paddingRight" | "paddingTop" + >) => JSX.Element[]; + renderBezierShadow: ({ + width, + height, + paddingRight, + paddingTop, + data, + useColorFromDataset + }: Pick< + AbstractChartConfig, + "height" | "paddingRight" | "paddingTop" | "width" | "data" + > & { + useColorFromDataset: AbstractChartConfig["useShadowColorFromDataset"]; + }) => JSX.Element[]; + renderLegend: (width: any, legendOffset: any) => JSX.Element[]; + render(): JSX.Element; +} +export default LineChart; +//# sourceMappingURL=LineChart.d.ts.map diff --git a/dist/line-chart/LineChart.d.ts.map b/dist/line-chart/LineChart.d.ts.map new file mode 100644 index 00000000..19cc1b5a --- /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":"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"} \ 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..c37bd76c --- /dev/null +++ b/dist/line-chart/LineChart.js @@ -0,0 +1,837 @@ +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 (b.hasOwnProperty(p)) d[p] = b[p]; + }; + return extendStatics(d, b); + }; + return function(d, b) { + 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 __spreadArrays = + (this && this.__spreadArrays) || + function() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) + s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; + }; +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 ? __spreadArrays(acc, item.data) : 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; + 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)) / dataset.data.length; + 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 "" + 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 lastPoint; + data.forEach(function(dataset, index) { + var points = dataset.data.map(function(d, i) { + if (d === null) return lastPoint; + var x = + (i * (width - paddingRight)) / dataset.data.length + paddingRight; + var y = + ((baseHeight - _this.calcHeight(d, datas, height)) / 4) * 3 + + paddingTop; + lastPoint = x + "," + y; + return x + "," + y; + }); + output.push( + + ); + }); + return output; + }; + _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 x = function(i) { + return Math.floor( + paddingRight + (i * (width - paddingRight)) / dataset.data.length + ); + }; + 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" + x(0) + "," + 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 " + + cp_x1 + + ", " + + y(i) + + ", " + + x_mid + + ", " + + y_mid + + (" Q " + + cp_x2 + + ", " + + y(i + 1) + + ", " + + x(i + 1) + + ", " + + 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 d = + _this.getBezierLinePoints(dataset, { + width: width, + height: height, + paddingRight: paddingRight, + paddingTop: paddingTop, + data: data + }) + + (" L" + + (paddingRight + + ((width - paddingRight) / dataset.data.length) * + (dataset.data.length - 1)) + + "," + + ((height / 4) * 3 + paddingTop) + + " L" + + paddingRight + + "," + + ((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\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 =\n          paddingRight + (i * (width - paddingRight)) / dataset.data.length;\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(#fillShadowGradient${\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\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 =\n          (i * (width - paddingRight)) / dataset.data.length + 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  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\n    const x = (i: number) =>\n      Math.floor(\n        paddingRight + (i * (width - paddingRight)) / dataset.data.length\n      );\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 d =\n        this.getBezierLinePoints(dataset, {\n          width,\n          height,\n          paddingRight,\n          paddingTop,\n          data\n        }) +\n        ` L${paddingRight +\n          ((width - paddingRight) / dataset.data.length) *\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(#fillShadowGradient${\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={borderRadius}\n            ry={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            ])}\n            horizontal\n            bounces={false}\n          />\n        )}\n      </View>\n    );\n  }\n}\n\nexport default LineChart;\n"]} diff --git a/dist/line-chart/index.d.ts b/dist/line-chart/index.d.ts new file mode 100644 index 00000000..749e0edf --- /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 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..0509935a --- /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= From 0136aae4a36493200f1300b0e11ea4b6017c96fd Mon Sep 17 00:00:00 2001 From: TDH55 Date: Wed, 16 Jun 2021 11:27:32 -0500 Subject: [PATCH 39/86] added hamiltons method to percent calculation --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 50 ++++++++++++++++++++++++++++++++++++------ src/PieChart.tsx | 40 ++++++++++++++++++++++++++++----- 3 files changed, 78 insertions(+), 14 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index c825500c..9db04d58 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":";AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC1B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAgIP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":";AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC1B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CA4JP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index a405e407..cecabbc8 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -39,6 +39,16 @@ var __assign = }; return __assign.apply(this, arguments); }; +var __spreadArrays = + (this && this.__spreadArrays) || + function() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) + s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; + }; import Pie from "paths-js/pie"; import React from "react"; import { View } from "react-native"; @@ -76,20 +86,46 @@ var PieChart = /** @class */ (function(_super) { var total = this.props.data.reduce(function(sum, item) { return sum + item[_this.props.accessor]; }, 0); + var divisor = total / 100.0; + var wholeTotal = 0; + chart.curves.forEach(function(c, i) { + var percentage = c.item[_this.props.accessor] / divisor; + var pieces = percentage.toString().split("."); + var whole = parseInt(pieces[0]); + var decimal = parseFloat("." + pieces[1]); + wholeTotal += whole; + c.item[_this.props.accessor] = { + index: i, + whole: whole, + decimal: decimal + }; + }); + var hamiltonDiff = 100 - wholeTotal; + var sortedCurves = __spreadArrays(chart.curves).sort(function(a, b) { + return a.item[_this.props.accessor].decimal < + b.item[_this.props.accessor].decimal + ? 1 + : -1; + }); + var uppedIndices = []; + for (var i = 0; i < hamiltonDiff; i++) { + uppedIndices.push(sortedCurves[i].item[this.props.accessor].index); + } var slices = chart.curves.map(function(c, i) { var value; if (absolute) { value = c.item[_this.props.accessor]; } else { + //TODO: calculate percentage using Hamilton's method if (total === 0) { value = 0 + "%"; } else { - var percentage = Math.round( - (100 / total) * c.item[_this.props.accessor] - ); - value = - Math.round((100 / total) * c.item[_this.props.accessor]) + "%"; - if (avoidFalseZero && percentage === 0) { + var item = c.item[_this.props.accessor]; + var percentage = item.whole; + if (uppedIndices.includes(item.index)) { + percentage += 1; + } + if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) { value = "<1%"; } else { value = percentage + "%"; @@ -180,4 +216,4 @@ var PieChart = /** @class */ (function(_super) { 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 Pie from \"paths-js/pie\";\nimport React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport { G, Path, Rect, Svg } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\n\n    const { borderRadius = 0 } = style;\n\n    const chart = Pie({\n      center: this.props.center || [0, 0],\n      r: 0,\n      R: this.props.height / 2.5,\n      data: this.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\n    }, 0);\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const percentage = Math.round(\n            (100 / total) * c.item[this.props.accessor]\n          );\n          value = Math.round((100 / total) * c.item[this.props.accessor]) + \"%\";\n          if (avoidFalseZero && percentage === 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width=\"16px\"\n              height=\"16px\"\n              fill={c.item.color}\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) / this.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\n              fontSize={c.item.legendFontSize}\n              fontFamily={c.item.legendFontFamily}\n              fontWeight={c.item.legendFontWeight}\n              x={this.props.width / 2.5}\n              y={\n                -(this.props.height / 2.5) +\n                ((this.props.height * 0.8) / this.props.data.length) * i +\n                12 * 2\n              }\n              // textAnchor={\"start\"}\n              width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={borderRadius}\n            fill={backgroundColor}\n          />\n          <G\n            x={\n              this.props.width / 2 / 2 +\n              Number(this.props.paddingLeft ? this.props.paddingLeft : 0)\n            }\n            y={this.props.height / 2}\n            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PieChart.js","sourceRoot":"","sources":["../src/PieChart.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 } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\n\n    const { borderRadius = 0 } = style;\n\n    let chart = Pie({\n      center: this.props.center || [0, 0],\n      r: 0,\n      R: this.props.height / 2.5,\n      data: this.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\n    }, 0);\n\n    const divisor = total / 100.0;\n    let wholeTotal = 0;\n    chart.curves.forEach((c, i) => {\n      const percentage = c.item[this.props.accessor] / divisor;\n      const pieces = percentage.toString().split(\".\");\n      const whole = parseInt(pieces[0]);\n      const decimal = parseFloat(\".\" + pieces[1]);\n      wholeTotal += whole;\n      c.item[this.props.accessor] = {\n        index: i,\n        whole,\n        decimal\n      };\n    });\n\n    const hamiltonDiff = 100 - wholeTotal;\n    const sortedCurves = [...chart.curves].sort((a, b) =>\n      a.item[this.props.accessor].decimal < b.item[this.props.accessor].decimal\n        ? 1\n        : -1\n    );\n    let uppedIndices = [];\n    for (let i = 0; i < hamiltonDiff; i++) {\n      uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //TODO: calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width=\"16px\"\n              height=\"16px\"\n              fill={c.item.color}\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) / this.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\n              fontSize={c.item.legendFontSize}\n              fontFamily={c.item.legendFontFamily}\n              fontWeight={c.item.legendFontWeight}\n              x={this.props.width / 2.5}\n              y={\n                -(this.props.height / 2.5) +\n                ((this.props.height * 0.8) / this.props.data.length) * i +\n                12 * 2\n              }\n              // textAnchor={\"start\"}\n              width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={borderRadius}\n            fill={backgroundColor}\n          />\n          <G\n            x={\n              this.props.width / 2 / 2 +\n              Number(this.props.paddingLeft ? this.props.paddingLeft : 0)\n            }\n            y={this.props.height / 2}\n            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 8f36ca6a..dcc63da4 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -34,7 +34,7 @@ class PieChart extends AbstractChart { const { borderRadius = 0 } = style; - const chart = Pie({ + let chart = Pie({ center: this.props.center || [0, 0], r: 0, R: this.props.height / 2.5, @@ -48,20 +48,48 @@ class PieChart extends AbstractChart { return sum + item[this.props.accessor]; }, 0); + const divisor = total / 100.0; + let wholeTotal = 0; + chart.curves.forEach((c, i) => { + const percentage = c.item[this.props.accessor] / divisor; + const pieces = percentage.toString().split("."); + const whole = parseInt(pieces[0]); + const decimal = parseFloat("." + pieces[1]); + wholeTotal += whole; + c.item[this.props.accessor] = { + index: i, + whole, + decimal + }; + }); + + const hamiltonDiff = 100 - wholeTotal; + const sortedCurves = [...chart.curves].sort((a, b) => + a.item[this.props.accessor].decimal < b.item[this.props.accessor].decimal + ? 1 + : -1 + ); + let uppedIndices = []; + for (let i = 0; i < hamiltonDiff; i++) { + uppedIndices.push(sortedCurves[i].item[this.props.accessor].index); + } + const slices = chart.curves.map((c, i) => { let value: string; if (absolute) { value = c.item[this.props.accessor]; } else { + //TODO: 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[this.props.accessor]; + let percentage = item.whole; + if (uppedIndices.includes(item.index)) { + percentage += 1; + } + if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) { value = "<1%"; } else { value = percentage + "%"; From b00b730b3f88b7c002ffc1467658477a829c6244 Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Thu, 24 Jun 2021 13:58:51 -0500 Subject: [PATCH 40/86] fixed percentage calculations --- dist/AbstractChart.d.ts | 56 +++++++++---------- dist/BarChart.d.ts | 55 +++++++++--------- dist/BarChart.d.ts.map | 2 +- dist/PieChart.d.ts | 1 - dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 50 +++++++++-------- dist/ProgressChart.d.ts | 1 - dist/ProgressChart.d.ts.map | 2 +- dist/StackedBarChart.d.ts | 23 ++++---- dist/StackedBarChart.d.ts.map | 2 +- .../contribution-graph/ContributionGraph.d.ts | 1 - .../ContributionGraph.d.ts.map | 2 +- dist/line-chart/LegendItem.d.ts | 1 - dist/line-chart/LegendItem.d.ts.map | 2 +- dist/line-chart/LineChart.d.ts | 6 +- src/PieChart.tsx | 50 +++++++++-------- tsconfig.json | 3 +- 17 files changed, 130 insertions(+), 129 deletions(-) diff --git a/dist/AbstractChart.d.ts b/dist/AbstractChart.d.ts index c613e316..3a5efa0e 100644 --- a/dist/AbstractChart.d.ts +++ b/dist/AbstractChart.d.ts @@ -67,8 +67,8 @@ declare class AbstractChart< strokeOpacity?: string | number; strokeDasharray?: string | number | readonly (string | number)[]; strokeDashoffset?: string | number; - strokeLinecap?: "round" | "butt" | "square"; - strokeLinejoin?: "round" | "bevel" | "miter"; + strokeLinecap?: import("react-native-svg").Linecap; + strokeLinejoin?: "miter" | "bevel" | "round"; strokeMiterlimit?: string | number; clipRule?: import("react-native-svg").FillRule; clipPath?: string; @@ -90,13 +90,13 @@ declare class AbstractChart< skewY?: string | number; rotation?: string | number; vectorEffect?: - | "default" - | "inherit" | "none" | "non-scaling-stroke" | "nonScalingStroke" + | "default" + | "inherit" | "uri"; - pointerEvents?: "auto" | "none" | "box-none" | "box-only"; + pointerEvents?: "none" | "box-none" | "box-only" | "auto"; onStartShouldSetResponder?: ( event: import("react-native").GestureResponderEvent ) => boolean; @@ -187,8 +187,8 @@ declare class AbstractChart< strokeOpacity?: string | number; strokeDasharray?: string | number | readonly (string | number)[]; strokeDashoffset?: string | number; - strokeLinecap?: "round" | "butt" | "square"; - strokeLinejoin?: "round" | "bevel" | "miter"; + strokeLinecap?: import("react-native-svg").Linecap; + strokeLinejoin?: "miter" | "bevel" | "round"; strokeMiterlimit?: string | number; clipRule?: import("react-native-svg").FillRule; clipPath?: string; @@ -210,13 +210,13 @@ declare class AbstractChart< skewY?: string | number; rotation?: string | number; vectorEffect?: - | "default" - | "inherit" | "none" | "non-scaling-stroke" | "nonScalingStroke" + | "default" + | "inherit" | "uri"; - pointerEvents?: "auto" | "none" | "box-none" | "box-only"; + pointerEvents?: "none" | "box-none" | "box-only" | "auto"; onStartShouldSetResponder?: ( event: import("react-native").GestureResponderEvent ) => boolean; @@ -307,8 +307,8 @@ declare class AbstractChart< strokeOpacity?: string | number; strokeDasharray?: string | number | readonly (string | number)[]; strokeDashoffset?: string | number; - strokeLinecap?: "round" | "butt" | "square"; - strokeLinejoin?: "round" | "bevel" | "miter"; + strokeLinecap?: import("react-native-svg").Linecap; + strokeLinejoin?: "miter" | "bevel" | "round"; strokeMiterlimit?: string | number; clipRule?: import("react-native-svg").FillRule; clipPath?: string; @@ -330,13 +330,13 @@ declare class AbstractChart< skewY?: string | number; rotation?: string | number; vectorEffect?: - | "default" - | "inherit" | "none" | "non-scaling-stroke" | "nonScalingStroke" + | "default" + | "inherit" | "uri"; - pointerEvents?: "auto" | "none" | "box-none" | "box-only"; + pointerEvents?: "none" | "box-none" | "box-only" | "auto"; onStartShouldSetResponder?: ( event: import("react-native").GestureResponderEvent ) => boolean; @@ -407,20 +407,17 @@ declare class AbstractChart< renderHorizontalLabels: ( config: Pick< AbstractChartConfig, - | "color" - | "style" - | "backgroundColor" - | "height" - | "paddingRight" - | "paddingTop" - | "width" - | "strokeWidth" | "propsForBackgroundLines" | "propsForLabels" + | "color" | "labelColor" | "propsForVerticalLabels" | "propsForHorizontalLabels" | "count" + | "width" + | "height" + | "paddingTop" + | "paddingRight" | "horizontalLabelRotation" | "formatYLabel" | "labels" @@ -429,6 +426,7 @@ declare class AbstractChart< | "verticalLabelRotation" | "formatXLabel" | "verticalLabelsHeightPercentage" + | "backgroundColor" | "backgroundGradientFrom" | "backgroundGradientFromOpacity" | "backgroundGradientTo" @@ -436,10 +434,12 @@ declare class AbstractChart< | "fillShadowGradient" | "fillShadowGradientOpacity" | "useShadowColorFromDataset" + | "strokeWidth" | "barPercentage" | "barRadius" | "propsForDots" | "decimalPlaces" + | "style" | "linejoinType" | "scrollableDotFill" | "scrollableDotStrokeColor" @@ -488,17 +488,17 @@ declare class AbstractChart< }: Pick< Pick< AbstractChartConfig, + | "data" + | "width" | "height" - | "paddingRight" | "paddingTop" - | "width" - | "data" + | "paddingRight" | "verticalLabelsHeightPercentage" >, + | "width" | "height" - | "paddingRight" | "paddingTop" - | "width" + | "paddingRight" | "verticalLabelsHeightPercentage" > & { data: number[]; diff --git a/dist/BarChart.d.ts b/dist/BarChart.d.ts index 76e2ed02..e85b5a3a 100644 --- a/dist/BarChart.d.ts +++ b/dist/BarChart.d.ts @@ -1,4 +1,3 @@ -/// import { ViewStyle } from "react-native"; import AbstractChart, { AbstractChartConfig, @@ -48,20 +47,17 @@ declare class BarChart extends AbstractChart { }: Pick< Pick< AbstractChartConfig, - | "color" - | "style" - | "backgroundColor" - | "height" - | "paddingRight" - | "paddingTop" - | "width" - | "strokeWidth" | "propsForBackgroundLines" | "propsForLabels" + | "color" | "labelColor" | "propsForVerticalLabels" | "propsForHorizontalLabels" | "count" + | "width" + | "height" + | "paddingTop" + | "paddingRight" | "horizontalLabelRotation" | "formatYLabel" | "labels" @@ -70,6 +66,7 @@ declare class BarChart extends AbstractChart { | "verticalLabelRotation" | "formatXLabel" | "verticalLabelsHeightPercentage" + | "backgroundColor" | "backgroundGradientFrom" | "backgroundGradientFromOpacity" | "backgroundGradientTo" @@ -77,10 +74,12 @@ declare class BarChart extends AbstractChart { | "fillShadowGradient" | "fillShadowGradientOpacity" | "useShadowColorFromDataset" + | "strokeWidth" | "barPercentage" | "barRadius" | "propsForDots" | "decimalPlaces" + | "style" | "linejoinType" | "scrollableDotFill" | "scrollableDotStrokeColor" @@ -92,7 +91,7 @@ declare class BarChart extends AbstractChart { | "scrollableInfoOffset" | "scrollableInfoSize" >, - "height" | "paddingRight" | "paddingTop" | "width" | "barRadius" + "width" | "height" | "paddingTop" | "paddingRight" | "barRadius" > & { data: number[]; withCustomBarColorFromData: boolean; @@ -106,20 +105,17 @@ declare class BarChart extends AbstractChart { }: Pick< Pick< AbstractChartConfig, - | "color" - | "style" - | "backgroundColor" - | "height" - | "paddingRight" - | "paddingTop" - | "width" - | "strokeWidth" | "propsForBackgroundLines" | "propsForLabels" + | "color" | "labelColor" | "propsForVerticalLabels" | "propsForHorizontalLabels" | "count" + | "width" + | "height" + | "paddingTop" + | "paddingRight" | "horizontalLabelRotation" | "formatYLabel" | "labels" @@ -128,6 +124,7 @@ declare class BarChart extends AbstractChart { | "verticalLabelRotation" | "formatXLabel" | "verticalLabelsHeightPercentage" + | "backgroundColor" | "backgroundGradientFrom" | "backgroundGradientFromOpacity" | "backgroundGradientTo" @@ -135,10 +132,12 @@ declare class BarChart extends AbstractChart { | "fillShadowGradient" | "fillShadowGradientOpacity" | "useShadowColorFromDataset" + | "strokeWidth" | "barPercentage" | "barRadius" | "propsForDots" | "decimalPlaces" + | "style" | "linejoinType" | "scrollableDotFill" | "scrollableDotStrokeColor" @@ -150,7 +149,7 @@ declare class BarChart extends AbstractChart { | "scrollableInfoOffset" | "scrollableInfoSize" >, - "height" | "paddingRight" | "paddingTop" | "width" + "width" | "height" | "paddingTop" | "paddingRight" > & { data: number[]; }) => JSX.Element[]; @@ -169,20 +168,17 @@ declare class BarChart extends AbstractChart { }: Pick< Pick< AbstractChartConfig, - | "color" - | "style" - | "backgroundColor" - | "height" - | "paddingRight" - | "paddingTop" - | "width" - | "strokeWidth" | "propsForBackgroundLines" | "propsForLabels" + | "color" | "labelColor" | "propsForVerticalLabels" | "propsForHorizontalLabels" | "count" + | "width" + | "height" + | "paddingTop" + | "paddingRight" | "horizontalLabelRotation" | "formatYLabel" | "labels" @@ -191,6 +187,7 @@ declare class BarChart extends AbstractChart { | "verticalLabelRotation" | "formatXLabel" | "verticalLabelsHeightPercentage" + | "backgroundColor" | "backgroundGradientFrom" | "backgroundGradientFromOpacity" | "backgroundGradientTo" @@ -198,10 +195,12 @@ declare class BarChart extends AbstractChart { | "fillShadowGradient" | "fillShadowGradientOpacity" | "useShadowColorFromDataset" + | "strokeWidth" | "barPercentage" | "barRadius" | "propsForDots" | "decimalPlaces" + | "style" | "linejoinType" | "scrollableDotFill" | "scrollableDotStrokeColor" @@ -213,7 +212,7 @@ declare class BarChart extends AbstractChart { | "scrollableInfoOffset" | "scrollableInfoSize" >, - "height" | "paddingRight" | "paddingTop" | "width" + "width" | "height" | "paddingTop" | "paddingRight" > & { data: number[]; }) => JSX.Element[]; diff --git a/dist/BarChart.d.ts.map b/dist/BarChart.d.ts.map index 2ec1865a..ca956276 100644 --- a/dist/BarChart.d.ts.map +++ b/dist/BarChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"BarChart.d.ts","sourceRoot":"","sources":["../src/BarChart.tsx"],"names":[],"mappings":";AACA,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;CACrB;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,gBAAgB,eAGd;IAEF,UAAU;cAYF,MAAM,EAAE;oCACc,OAAO;wBA8BnC;IAEF,aAAa;cAUL,MAAM,EAAE;wBAsBd;IAEF,YAAY;mBAIC,OAAO;wBA4BlB;IAEF,uBAAuB;cAUf,MAAM,EAAE;wBAwBd;IAEF,MAAM;CA0HP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"BarChart.d.ts","sourceRoot":"","sources":["../src/BarChart.tsx"],"names":[],"mappings":"AACA,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;CACrB;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,gBAAgB,eAGd;IAEF,UAAU;cAYF,MAAM,EAAE;oCACc,OAAO;wBA8BnC;IAEF,aAAa;cAUL,MAAM,EAAE;wBAsBd;IAEF,YAAY;mBAIC,OAAO;wBA4BlB;IAEF,uBAAuB;cAUf,MAAM,EAAE;wBAwBd;IAEF,MAAM;CA0HP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.d.ts b/dist/PieChart.d.ts index 68a5a27c..a0116758 100644 --- a/dist/PieChart.d.ts +++ b/dist/PieChart.d.ts @@ -1,4 +1,3 @@ -/// import { ViewStyle } from "react-native"; import AbstractChart, { AbstractChartProps } from "./AbstractChart"; export interface PieChartProps extends AbstractChartProps { diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 9db04d58..875d29da 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":";AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC1B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CA4JP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC1B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CA+JP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index cecabbc8..d9de690f 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -86,30 +86,32 @@ var PieChart = /** @class */ (function(_super) { var total = this.props.data.reduce(function(sum, item) { return sum + item[_this.props.accessor]; }, 0); - var divisor = total / 100.0; - var wholeTotal = 0; - chart.curves.forEach(function(c, i) { - var percentage = c.item[_this.props.accessor] / divisor; - var pieces = percentage.toString().split("."); - var whole = parseInt(pieces[0]); - var decimal = parseFloat("." + pieces[1]); - wholeTotal += whole; - c.item[_this.props.accessor] = { - index: i, - whole: whole, - decimal: decimal - }; - }); - var hamiltonDiff = 100 - wholeTotal; - var sortedCurves = __spreadArrays(chart.curves).sort(function(a, b) { - return a.item[_this.props.accessor].decimal < - b.item[_this.props.accessor].decimal - ? 1 - : -1; - }); var uppedIndices = []; - for (var i = 0; i < hamiltonDiff; i++) { - uppedIndices.push(sortedCurves[i].item[this.props.accessor].index); + if (!absolute) { + var divisor_1 = total / 100.0; + var wholeTotal_1 = 0; + chart.curves.forEach(function(c, i) { + var percentage = c.item[_this.props.accessor] / divisor_1; + var pieces = percentage.toString().split("."); + var whole = parseInt(pieces[0]); + var decimal = parseFloat("." + pieces[1]); + wholeTotal_1 += whole; + c.item[_this.props.accessor] = { + index: i, + whole: whole, + decimal: decimal + }; + }); + var hamiltonDiff = 100 - wholeTotal_1; + var sortedCurves = __spreadArrays(chart.curves).sort(function(a, b) { + return a.item[_this.props.accessor].decimal < + b.item[_this.props.accessor].decimal + ? 1 + : -1; + }); + for (var i = 0; i < hamiltonDiff; i++) { + uppedIndices.push(sortedCurves[i].item[this.props.accessor].index); + } } var slices = chart.curves.map(function(c, i) { var value; @@ -216,4 +218,4 @@ var PieChart = /** @class */ (function(_super) { 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 Pie from \"paths-js/pie\";\nimport React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport { G, Path, Rect, Svg } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\n\n    const { borderRadius = 0 } = style;\n\n    let chart = Pie({\n      center: this.props.center || [0, 0],\n      r: 0,\n      R: this.props.height / 2.5,\n      data: this.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\n    }, 0);\n\n    const divisor = total / 100.0;\n    let wholeTotal = 0;\n    chart.curves.forEach((c, i) => {\n      const percentage = c.item[this.props.accessor] / divisor;\n      const pieces = percentage.toString().split(\".\");\n      const whole = parseInt(pieces[0]);\n      const decimal = parseFloat(\".\" + pieces[1]);\n      wholeTotal += whole;\n      c.item[this.props.accessor] = {\n        index: i,\n        whole,\n        decimal\n      };\n    });\n\n    const hamiltonDiff = 100 - wholeTotal;\n    const sortedCurves = [...chart.curves].sort((a, b) =>\n      a.item[this.props.accessor].decimal < b.item[this.props.accessor].decimal\n        ? 1\n        : -1\n    );\n    let uppedIndices = [];\n    for (let i = 0; i < hamiltonDiff; i++) {\n      uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //TODO: calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width=\"16px\"\n              height=\"16px\"\n              fill={c.item.color}\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) / this.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\n              fontSize={c.item.legendFontSize}\n              fontFamily={c.item.legendFontFamily}\n              fontWeight={c.item.legendFontWeight}\n              x={this.props.width / 2.5}\n              y={\n                -(this.props.height / 2.5) +\n                ((this.props.height * 0.8) / this.props.data.length) * i +\n                12 * 2\n              }\n              // textAnchor={\"start\"}\n              width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={borderRadius}\n            fill={backgroundColor}\n          />\n          <G\n            x={\n              this.props.width / 2 / 2 +\n              Number(this.props.paddingLeft ? this.props.paddingLeft : 0)\n            }\n            y={this.props.height / 2}\n            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PieChart.js","sourceRoot":"","sources":["../src/PieChart.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 } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\n\n    const { borderRadius = 0 } = style;\n\n    let chart = Pie({\n      center: this.props.center || [0, 0],\n      r: 0,\n      R: this.props.height / 2.5,\n      data: this.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        const decimal = parseFloat(\".\" + pieces[1]);\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal < b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //TODO: calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width=\"16px\"\n              height=\"16px\"\n              fill={c.item.color}\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) / this.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\n              fontSize={c.item.legendFontSize}\n              fontFamily={c.item.legendFontFamily}\n              fontWeight={c.item.legendFontWeight}\n              x={this.props.width / 2.5}\n              y={\n                -(this.props.height / 2.5) +\n                ((this.props.height * 0.8) / this.props.data.length) * i +\n                12 * 2\n              }\n              // textAnchor={\"start\"}\n              width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={borderRadius}\n            fill={backgroundColor}\n          />\n          <G\n            x={\n              this.props.width / 2 / 2 +\n              Number(this.props.paddingLeft ? this.props.paddingLeft : 0)\n            }\n            y={this.props.height / 2}\n            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/dist/ProgressChart.d.ts b/dist/ProgressChart.d.ts index 19987f3d..9812d50f 100644 --- a/dist/ProgressChart.d.ts +++ b/dist/ProgressChart.d.ts @@ -1,4 +1,3 @@ -/// import { ViewStyle } from "react-native"; import AbstractChart, { AbstractChartConfig, diff --git a/dist/ProgressChart.d.ts.map b/dist/ProgressChart.d.ts.map index 1c2867ac..da25c3a6 100644 --- a/dist/ProgressChart.d.ts.map +++ b/dist/ProgressChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"ProgressChart.d.ts","sourceRoot":"","sources":["../src/ProgressChart.tsx"],"names":[],"mappings":";AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,aAAa,EAAE,EACpB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AAEzB,oBAAY,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,aAAK,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 +{"version":3,"file":"ProgressChart.d.ts","sourceRoot":"","sources":["../src/ProgressChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,aAAa,EAAE,EACpB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AAEzB,oBAAY,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,aAAK,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/StackedBarChart.d.ts b/dist/StackedBarChart.d.ts index 51632dda..be7a5f3a 100644 --- a/dist/StackedBarChart.d.ts +++ b/dist/StackedBarChart.d.ts @@ -1,4 +1,3 @@ -/// import { ViewStyle } from "react-native"; import AbstractChart, { AbstractChartConfig, @@ -70,20 +69,17 @@ declare class StackedBarChart extends AbstractChart< }: Pick< Pick< AbstractChartConfig, - | "color" - | "style" - | "backgroundColor" - | "height" - | "paddingRight" - | "paddingTop" - | "width" - | "strokeWidth" | "propsForBackgroundLines" | "propsForLabels" + | "color" | "labelColor" | "propsForVerticalLabels" | "propsForHorizontalLabels" | "count" + | "width" + | "height" + | "paddingTop" + | "paddingRight" | "horizontalLabelRotation" | "formatYLabel" | "labels" @@ -92,6 +88,7 @@ declare class StackedBarChart extends AbstractChart< | "verticalLabelRotation" | "formatXLabel" | "verticalLabelsHeightPercentage" + | "backgroundColor" | "backgroundGradientFrom" | "backgroundGradientFromOpacity" | "backgroundGradientTo" @@ -99,10 +96,12 @@ declare class StackedBarChart extends AbstractChart< | "fillShadowGradient" | "fillShadowGradientOpacity" | "useShadowColorFromDataset" + | "strokeWidth" | "barPercentage" | "barRadius" | "propsForDots" | "decimalPlaces" + | "style" | "linejoinType" | "scrollableDotFill" | "scrollableDotStrokeColor" @@ -114,10 +113,10 @@ declare class StackedBarChart extends AbstractChart< | "scrollableInfoOffset" | "scrollableInfoSize" >, + | "width" | "height" - | "paddingRight" | "paddingTop" - | "width" + | "paddingRight" | "stackedBar" | "verticalLabelsHeightPercentage" > & { @@ -130,7 +129,7 @@ declare class StackedBarChart extends AbstractChart< colors, width, height - }: Pick & { + }: Pick & { legend: string[]; colors: string[]; }) => JSX.Element[]; diff --git a/dist/StackedBarChart.d.ts.map b/dist/StackedBarChart.d.ts.map index 9efc9841..e119d9a7 100644 --- a/dist/StackedBarChart.d.ts.map +++ b/dist/StackedBarChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"StackedBarChart.d.ts","sourceRoot":"","sources":["../src/StackedBarChart.tsx"],"names":[],"mappings":";AACA,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,aAAK,oBAAoB,GAAG,EAAE,CAAC;AAE/B,cAAM,eAAgB,SAAQ,aAAa,CACzC,oBAAoB,EACpB,oBAAoB,CACrB;IACC,gBAAgB,eAGd;IAEF,YAAY,QAAS,MAAM,GAAG,GAAG,EAAE,KAAK,MAAM,GAAG,GAAG,EAAE,YAIpD;IAEF,UAAU;gBAmBA,MAAM;gBACN,MAAM,EAAE;cACV,MAAM,EAAE,EAAE;kBAsDb;IAEL,YAAY;gBAMF,MAAM,EAAE;gBACR,MAAM,EAAE;wBAuBb;IAEL,MAAM;CAsHP;AAED,eAAe,eAAe,CAAC"} \ No newline at end of file +{"version":3,"file":"StackedBarChart.d.ts","sourceRoot":"","sources":["../src/StackedBarChart.tsx"],"names":[],"mappings":"AACA,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,aAAK,oBAAoB,GAAG,EAAE,CAAC;AAE/B,cAAM,eAAgB,SAAQ,aAAa,CACzC,oBAAoB,EACpB,oBAAoB,CACrB;IACC,gBAAgB,eAGd;IAEF,YAAY,QAAS,MAAM,GAAG,GAAG,EAAE,KAAK,MAAM,GAAG,GAAG,EAAE,YAIpD;IAEF,UAAU;gBAmBA,MAAM;gBACN,MAAM,EAAE;cACV,MAAM,EAAE,EAAE;kBAsDb;IAEL,YAAY;gBAMF,MAAM,EAAE;gBACR,MAAM,EAAE;wBAuBb;IAEL,MAAM;CAsHP;AAED,eAAe,eAAe,CAAC"} \ No newline at end of file diff --git a/dist/contribution-graph/ContributionGraph.d.ts b/dist/contribution-graph/ContributionGraph.d.ts index 9861654c..6daa1101 100644 --- a/dist/contribution-graph/ContributionGraph.d.ts +++ b/dist/contribution-graph/ContributionGraph.d.ts @@ -1,4 +1,3 @@ -/// import { RectProps } from "react-native-svg"; import AbstractChart from "../AbstractChart"; import { ContributionGraphProps, ContributionGraphState } from "."; diff --git a/dist/contribution-graph/ContributionGraph.d.ts.map b/dist/contribution-graph/ContributionGraph.d.ts.map index b022bddc..0cdd6bab 100644 --- a/dist/contribution-graph/ContributionGraph.d.ts.map +++ b/dist/contribution-graph/ContributionGraph.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"ContributionGraph.d.ts","sourceRoot":"","sources":["../../src/contribution-graph/ContributionGraph.tsx"],"names":[],"mappings":";AAGA,OAAO,EAAW,SAAS,EAAa,MAAM,kBAAkB,CAAC;AAEjE,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAY7C,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,GAAG,CAAC;AAMnE,oBAAY,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,oBAAY,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 +{"version":3,"file":"ContributionGraph.d.ts","sourceRoot":"","sources":["../../src/contribution-graph/ContributionGraph.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAW,SAAS,EAAa,MAAM,kBAAkB,CAAC;AAEjE,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAY7C,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,GAAG,CAAC;AAMnE,oBAAY,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,oBAAY,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/line-chart/LegendItem.d.ts b/dist/line-chart/LegendItem.d.ts index 7e41e428..14d0a857 100644 --- a/dist/line-chart/LegendItem.d.ts +++ b/dist/line-chart/LegendItem.d.ts @@ -1,4 +1,3 @@ -/// import { Color, TextProps } from "react-native-svg"; export declare type LegendItemProps = { baseLegendItemX: number; diff --git a/dist/line-chart/LegendItem.d.ts.map b/dist/line-chart/LegendItem.d.ts.map index 174bfda3..0c993140 100644 --- a/dist/line-chart/LegendItem.d.ts.map +++ b/dist/line-chart/LegendItem.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"LegendItem.d.ts","sourceRoot":"","sources":["../../src/line-chart/LegendItem.tsx"],"names":[],"mappings":";AACA,OAAO,EAAE,KAAK,EAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAMhE,oBAAY,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,UAAW,eAAe,gBAmChD,CAAC"} \ No newline at end of file +{"version":3,"file":"LegendItem.d.ts","sourceRoot":"","sources":["../../src/line-chart/LegendItem.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAMhE,oBAAY,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,UAAW,eAAe,gBAmChD,CAAC"} \ No newline at end of file diff --git a/dist/line-chart/LineChart.d.ts b/dist/line-chart/LineChart.d.ts index 419d325e..806eb47e 100644 --- a/dist/line-chart/LineChart.d.ts +++ b/dist/line-chart/LineChart.d.ts @@ -211,7 +211,7 @@ declare class LineChart extends AbstractChart { onDataPointClick }: Pick< AbstractChartConfig, - "height" | "paddingRight" | "paddingTop" | "width" | "data" + "data" | "width" | "height" | "paddingTop" | "paddingRight" > & { onDataPointClick: LineChartProps["onDataPointClick"]; }) => React.ReactNode[]; @@ -244,7 +244,7 @@ declare class LineChart extends AbstractChart { useColorFromDataset }: Pick< AbstractChartConfig, - "height" | "paddingRight" | "paddingTop" | "width" | "data" + "data" | "width" | "height" | "paddingTop" | "paddingRight" > & { useColorFromDataset: AbstractChartConfig["useShadowColorFromDataset"]; }) => JSX.Element[]; @@ -291,7 +291,7 @@ declare class LineChart extends AbstractChart { useColorFromDataset }: Pick< AbstractChartConfig, - "height" | "paddingRight" | "paddingTop" | "width" | "data" + "data" | "width" | "height" | "paddingTop" | "paddingRight" > & { useColorFromDataset: AbstractChartConfig["useShadowColorFromDataset"]; }) => JSX.Element[]; diff --git a/src/PieChart.tsx b/src/PieChart.tsx index dcc63da4..9a106375 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -48,30 +48,34 @@ class PieChart extends AbstractChart { return sum + item[this.props.accessor]; }, 0); - const divisor = total / 100.0; - let wholeTotal = 0; - chart.curves.forEach((c, i) => { - const percentage = c.item[this.props.accessor] / divisor; - const pieces = percentage.toString().split("."); - const whole = parseInt(pieces[0]); - const decimal = parseFloat("." + pieces[1]); - wholeTotal += whole; - c.item[this.props.accessor] = { - index: i, - whole, - decimal - }; - }); - - const hamiltonDiff = 100 - wholeTotal; - const sortedCurves = [...chart.curves].sort((a, b) => - a.item[this.props.accessor].decimal < b.item[this.props.accessor].decimal - ? 1 - : -1 - ); let uppedIndices = []; - for (let i = 0; i < hamiltonDiff; i++) { - uppedIndices.push(sortedCurves[i].item[this.props.accessor].index); + + if (!absolute) { + const divisor = total / 100.0; + let wholeTotal = 0; + chart.curves.forEach((c, i) => { + const percentage = c.item[this.props.accessor] / divisor; + const pieces = percentage.toString().split("."); + const whole = parseInt(pieces[0]); + const decimal = parseFloat("." + pieces[1]); + wholeTotal += whole; + c.item[this.props.accessor] = { + index: i, + whole, + decimal + }; + }); + + const hamiltonDiff = 100 - wholeTotal; + const sortedCurves = [...chart.curves].sort((a, b) => + a.item[this.props.accessor].decimal < + b.item[this.props.accessor].decimal + ? 1 + : -1 + ); + for (let i = 0; i < hamiltonDiff; i++) { + uppedIndices.push(sortedCurves[i].item[this.props.accessor].index); + } } const slices = chart.curves.map((c, i) => { 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 } } From 293c9239bbe55b304532236567b6138471944e23 Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Fri, 25 Jun 2021 13:24:48 -0500 Subject: [PATCH 41/86] added the ability to adjust chart to legend ratio --- dist/PieChart.d.ts | 1 + dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 52 +++++++++++++++++++++++++++++++-------- src/PieChart.tsx | 55 ++++++++++++++++++++++++++++++++++++------ 4 files changed, 91 insertions(+), 19 deletions(-) diff --git a/dist/PieChart.d.ts b/dist/PieChart.d.ts index a0116758..149f96d1 100644 --- a/dist/PieChart.d.ts +++ b/dist/PieChart.d.ts @@ -12,6 +12,7 @@ export interface PieChartProps extends AbstractChartProps { hasLegend?: boolean; style?: Partial; avoidFalseZero?: boolean; + chartWidthPercentage: number; } declare type PieChartState = {}; declare class PieChart extends AbstractChart { diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 875d29da..e3474d6c 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC1B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CA+JP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAgMP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index d9de690f..7a14227e 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -74,10 +74,36 @@ var PieChart = /** @class */ (function(_super) { avoidFalseZero = _e === void 0 ? false : _e; var _f = style.borderRadius, borderRadius = _f === void 0 ? 0 : _f; + var chartWidthPercentage = this.props.chartWidthPercentage * 0.01; + var radius; + // let height = this.props.height + if ( + this.props.height / 2.5 < + (this.props.width * chartWidthPercentage) / 2 + ) { + console.log("1"); + radius = this.props.height / 2.5; + // if (radius > this.props.width / 2 / 2) { + // // console.log('2') + // height = this.props.width / 1.62 + // radius = height / 2.5 + // } + chartWidthPercentage = 2 * (radius / this.props.width); + } else { + console.log("3"); + radius = this.props.width * (chartWidthPercentage / 2); + } + if (chartWidthPercentage === 1) { + chartWidthPercentage = 0.5; + } var chart = Pie({ + //TODO: mess with this and move legend to adjust ration + //TODO: adjust radius based on available width, pick smallest between width and height + //this.props.height/2.5 vs this.props.width / denom / 2 center: this.props.center || [0, 0], r: 0, - R: this.props.height / 2.5, + R: radius, + // R: this.props.width / 4 / 2, data: this.props.data, accessor: function(x) { return x[_this.props.accessor]; @@ -118,7 +144,7 @@ var PieChart = /** @class */ (function(_super) { if (absolute) { value = c.item[_this.props.accessor]; } else { - //TODO: calculate percentage using Hamilton's method + //calculate percentage using Hamilton's method if (total === 0) { value = 0 + "%"; } else { @@ -143,12 +169,16 @@ var PieChart = /** @class */ (function(_super) { /> {hasLegend ? ( {value + " " + c.item.name} @@ -201,10 +231,12 @@ var PieChart = /** @class */ (function(_super) { fill={backgroundColor} /> ; avoidFalseZero?: boolean; + chartWidthPercentage: number; } type PieChartState = {}; @@ -34,10 +35,40 @@ class PieChart extends AbstractChart { const { borderRadius = 0 } = style; + let chartWidthPercentage = this.props.chartWidthPercentage * 0.01; + + let radius: number; + // let height = this.props.height + + if ( + this.props.height / 2.5 < + (this.props.width * chartWidthPercentage) / 2 + ) { + console.log("1"); + radius = this.props.height / 2.5; + // if (radius > this.props.width / 2 / 2) { + // // console.log('2') + // height = this.props.width / 1.62 + // radius = height / 2.5 + // } + chartWidthPercentage = 2 * (radius / this.props.width); + } else { + console.log("3"); + radius = this.props.width * (chartWidthPercentage / 2); + } + + if (chartWidthPercentage === 1) { + chartWidthPercentage = 0.5; + } + let chart = Pie({ + //TODO: mess with this and move legend to adjust ration + //TODO: adjust radius based on available width, pick smallest between width and height + //this.props.height/2.5 vs this.props.width / denom / 2 center: this.props.center || [0, 0], r: 0, - R: this.props.height / 2.5, + R: radius, + // R: this.props.width / 4 / 2, data: this.props.data, accessor: x => { return x[this.props.accessor]; @@ -84,7 +115,7 @@ class PieChart extends AbstractChart { if (absolute) { value = c.item[this.props.accessor]; } else { - //TODO: calculate percentage using Hamilton's method + //calculate percentage using Hamilton's method if (total === 0) { value = 0 + "%"; } else { @@ -109,12 +140,16 @@ class PieChart extends AbstractChart { /> {hasLegend ? ( { fontSize={c.item.legendFontSize} fontFamily={c.item.legendFontFamily} fontWeight={c.item.legendFontWeight} - x={this.props.width / 2.5} + //TODO: replace with denominator + x={this.props.width / (100 / (chartWidthPercentage * 100) + 0.5)} + // x={0} y={ -(this.props.height / 2.5) + ((this.props.height * 0.8) / this.props.data.length) * i + 12 * 2 } // textAnchor={"start"} - width={this.props.width / 2.5 - 16} + // width={this.props.width / 2.5 - 16} > {`${value} ${c.item.name}`} @@ -169,10 +206,12 @@ class PieChart extends AbstractChart { fill={backgroundColor} /> Date: Fri, 25 Jun 2021 13:25:06 -0500 Subject: [PATCH 42/86] build --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index e3474d6c..f9284a24 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAgMP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAsMP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 7a14227e..ac61a927 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -250,4 +250,4 @@ var PieChart = /** @class */ (function(_super) { 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 Pie from \"paths-js/pie\";\nimport React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport { G, Path, Rect, Svg } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\n\n    const { borderRadius = 0 } = style;\n\n    let chartWidthPercentage = this.props.chartWidthPercentage * 0.01\n\n    let radius: number\n    // let height = this.props.height\n\n    if (this.props.height / 2.5 < this.props.width * chartWidthPercentage / 2) {\n      console.log('1')\n      radius = this.props.height / 2.5\n      // if (radius > this.props.width / 2 / 2) {\n      //   // console.log('2')\n      //   height = this.props.width / 1.62\n      //   radius = height / 2.5\n      // }\n      chartWidthPercentage = 2 * (radius / this.props.width)\n    } else {\n      console.log('3')\n      radius = this.props.width * (chartWidthPercentage / 2)\n    }\n\n    if (chartWidthPercentage === 1) {\n      chartWidthPercentage = 0.5\n    }\n\n    let chart = Pie({\n      //TODO: mess with this and move legend to adjust ration\n      //TODO: adjust radius based on available width, pick smallest between width and height\n      //this.props.height/2.5 vs this.props.width / denom / 2\n      center: this.props.center || [0, 0],\n      r: 0,\n      R: radius,\n      // R: this.props.width / 4 / 2,\n      data: this.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        const decimal = parseFloat(\".\" + pieces[1]);\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={8}\n              //TODO: replace with denominator\n              x={this.props.width / (100 / (chartWidthPercentage * 100) + 0.5) - 24}\n              y={\n                -(this.props.height / 2.5) +\n                ((this.props.height * 0.8) / this.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\n              fontSize={c.item.legendFontSize}\n              fontFamily={c.item.legendFontFamily}\n              fontWeight={c.item.legendFontWeight}\n             //TODO: replace with denominator\n              x={this.props.width / (100 / (chartWidthPercentage * 100) + 0.5)}\n              // x={0}\n              y={\n                -(this.props.height / 2.5) +\n                ((this.props.height * 0.8) / this.props.data.length) * i +\n                12  * 2\n              }\n              // textAnchor={\"start\"}\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={borderRadius}\n            fill={backgroundColor}\n          />\n          <G\n          //TODO: replace with denominator * 2 (or denom / 2) ? \n            x={\n              this.props.width * chartWidthPercentage / 2 +\n              Number(this.props.paddingLeft ? this.props.paddingLeft : 0)\n            }\n            // x = { 0 }\n            y={this.props.height / 2}\n            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PieChart.js","sourceRoot":"","sources":["../src/PieChart.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 } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\n\n    const { borderRadius = 0 } = style;\n\n    let chartWidthPercentage = this.props.chartWidthPercentage * 0.01;\n\n    let radius: number;\n    // let height = this.props.height\n\n    if (\n      this.props.height / 2.5 <\n      (this.props.width * chartWidthPercentage) / 2\n    ) {\n      console.log(\"1\");\n      radius = this.props.height / 2.5;\n      // if (radius > this.props.width / 2 / 2) {\n      //   // console.log('2')\n      //   height = this.props.width / 1.62\n      //   radius = height / 2.5\n      // }\n      chartWidthPercentage = 2 * (radius / this.props.width);\n    } else {\n      console.log(\"3\");\n      radius = this.props.width * (chartWidthPercentage / 2);\n    }\n\n    if (chartWidthPercentage === 1) {\n      chartWidthPercentage = 0.5;\n    }\n\n    let chart = Pie({\n      //TODO: mess with this and move legend to adjust ration\n      //TODO: adjust radius based on available width, pick smallest between width and height\n      //this.props.height/2.5 vs this.props.width / denom / 2\n      center: this.props.center || [0, 0],\n      r: 0,\n      R: radius,\n      // R: this.props.width / 4 / 2,\n      data: this.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        const decimal = parseFloat(\".\" + pieces[1]);\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={8}\n              //TODO: replace with denominator\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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\n              fontSize={c.item.legendFontSize}\n              fontFamily={c.item.legendFontFamily}\n              fontWeight={c.item.legendFontWeight}\n              //TODO: replace with denominator\n              x={this.props.width / (100 / (chartWidthPercentage * 100) + 0.5)}\n              // x={0}\n              y={\n                -(this.props.height / 2.5) +\n                ((this.props.height * 0.8) / this.props.data.length) * i +\n                12 * 2\n              }\n              // textAnchor={\"start\"}\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={borderRadius}\n            fill={backgroundColor}\n          />\n          <G\n            //TODO: replace with denominator * 2 (or denom / 2) ?\n            x={\n              (this.props.width * chartWidthPercentage) / 2 +\n              Number(this.props.paddingLeft ? this.props.paddingLeft : 0)\n            }\n            // x = { 0 }\n            y={this.props.height / 2}\n            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} From 5f6225e99eea1f92b9b7b7d28f4c2912147fd0bd Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Fri, 25 Jun 2021 13:26:47 -0500 Subject: [PATCH 43/86] cleanup --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 18 +----------------- src/PieChart.tsx | 18 +----------------- 3 files changed, 3 insertions(+), 35 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index f9284a24..e82d3a40 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAsMP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAuLP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index ac61a927..4acd6ab1 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -76,34 +76,23 @@ var PieChart = /** @class */ (function(_super) { borderRadius = _f === void 0 ? 0 : _f; var chartWidthPercentage = this.props.chartWidthPercentage * 0.01; var radius; - // let height = this.props.height if ( this.props.height / 2.5 < (this.props.width * chartWidthPercentage) / 2 ) { console.log("1"); radius = this.props.height / 2.5; - // if (radius > this.props.width / 2 / 2) { - // // console.log('2') - // height = this.props.width / 1.62 - // radius = height / 2.5 - // } chartWidthPercentage = 2 * (radius / this.props.width); } else { - console.log("3"); radius = this.props.width * (chartWidthPercentage / 2); } if (chartWidthPercentage === 1) { chartWidthPercentage = 0.5; } var chart = Pie({ - //TODO: mess with this and move legend to adjust ration - //TODO: adjust radius based on available width, pick smallest between width and height - //this.props.height/2.5 vs this.props.width / denom / 2 center: this.props.center || [0, 0], r: 0, R: radius, - // R: this.props.width / 4 / 2, data: this.props.data, accessor: function(x) { return x[_this.props.accessor]; @@ -174,7 +163,6 @@ var PieChart = /** @class */ (function(_super) { fill={c.item.color} rx={8} ry={8} - //TODO: replace with denominator x={ _this.props.width / (100 / (chartWidthPercentage * 100) + 0.5) - 24 @@ -192,9 +180,7 @@ var PieChart = /** @class */ (function(_super) { fontSize={c.item.legendFontSize} fontFamily={c.item.legendFontFamily} fontWeight={c.item.legendFontWeight} - //TODO: replace with denominator x={_this.props.width / (100 / (chartWidthPercentage * 100) + 0.5)} - // x={0} y={ -(_this.props.height / 2.5) + ((_this.props.height * 0.8) / _this.props.data.length) * i + @@ -231,12 +217,10 @@ var PieChart = /** @class */ (function(_super) { fill={backgroundColor} /> { let chartWidthPercentage = this.props.chartWidthPercentage * 0.01; let radius: number; - // let height = this.props.height if ( this.props.height / 2.5 < @@ -46,14 +45,8 @@ class PieChart extends AbstractChart { ) { console.log("1"); radius = this.props.height / 2.5; - // if (radius > this.props.width / 2 / 2) { - // // console.log('2') - // height = this.props.width / 1.62 - // radius = height / 2.5 - // } chartWidthPercentage = 2 * (radius / this.props.width); } else { - console.log("3"); radius = this.props.width * (chartWidthPercentage / 2); } @@ -62,13 +55,9 @@ class PieChart extends AbstractChart { } let chart = Pie({ - //TODO: mess with this and move legend to adjust ration - //TODO: adjust radius based on available width, pick smallest between width and height - //this.props.height/2.5 vs this.props.width / denom / 2 center: this.props.center || [0, 0], r: 0, R: radius, - // R: this.props.width / 4 / 2, data: this.props.data, accessor: x => { return x[this.props.accessor]; @@ -145,7 +134,6 @@ class PieChart extends AbstractChart { fill={c.item.color} rx={8} ry={8} - //TODO: replace with denominator x={ this.props.width / (100 / (chartWidthPercentage * 100) + 0.5) - 24 @@ -163,15 +151,13 @@ class PieChart extends AbstractChart { fontSize={c.item.legendFontSize} fontFamily={c.item.legendFontFamily} fontWeight={c.item.legendFontWeight} - //TODO: replace with denominator x={this.props.width / (100 / (chartWidthPercentage * 100) + 0.5)} - // x={0} y={ -(this.props.height / 2.5) + ((this.props.height * 0.8) / this.props.data.length) * i + 12 * 2 } - // textAnchor={"start"} + //uncomment to wrap text (poor implementation) // width={this.props.width / 2.5 - 16} > {`${value} ${c.item.name}`} @@ -206,12 +192,10 @@ class PieChart extends AbstractChart { fill={backgroundColor} /> Date: Fri, 25 Jun 2021 14:40:15 -0500 Subject: [PATCH 44/86] fixed 0% entries showing as <1% --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 6 ++++-- src/PieChart.tsx | 6 ++++-- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index e82d3a40..98130a3e 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAuLP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAwLP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 4acd6ab1..efb5a974 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -80,7 +80,6 @@ var PieChart = /** @class */ (function(_super) { this.props.height / 2.5 < (this.props.width * chartWidthPercentage) / 2 ) { - console.log("1"); radius = this.props.height / 2.5; chartWidthPercentage = 2 * (radius / this.props.width); } else { @@ -110,6 +109,9 @@ var PieChart = /** @class */ (function(_super) { var pieces = percentage.toString().split("."); var whole = parseInt(pieces[0]); var decimal = parseFloat("." + pieces[1]); + if (isNaN(decimal)) { + decimal = 0; + } wholeTotal_1 += whole; c.item[_this.props.accessor] = { index: i, @@ -234,4 +236,4 @@ var PieChart = /** @class */ (function(_super) { 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 Pie from \"paths-js/pie\";\nimport React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport { G, Path, Rect, Svg } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\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      console.log(\"1\");\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      \n      center: this.props.center || [0, 0],\n      r: 0,\n      R: radius,\n      data: this.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        const decimal = parseFloat(\".\" + pieces[1]);\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n              //uncomment to wrap text (poor implementation)\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PieChart.js","sourceRoot":"","sources":["../src/PieChart.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 } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\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.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\"\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n              //uncomment to wrap text (poor implementation)\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 3afd96b2..fab23c73 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -43,7 +43,6 @@ class PieChart extends AbstractChart { this.props.height / 2.5 < (this.props.width * chartWidthPercentage) / 2 ) { - console.log("1"); radius = this.props.height / 2.5; chartWidthPercentage = 2 * (radius / this.props.width); } else { @@ -77,7 +76,10 @@ class PieChart extends AbstractChart { const percentage = c.item[this.props.accessor] / divisor; const pieces = percentage.toString().split("."); const whole = parseInt(pieces[0]); - const decimal = parseFloat("." + pieces[1]); + let decimal = parseFloat("." + pieces[1]); + if (isNaN(decimal)) { + decimal = 0; + } wholeTotal += whole; c.item[this.props.accessor] = { index: i, From 142b704fc5ba7324f3ccc4e8507947c9dc2ccbc0 Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Fri, 25 Jun 2021 14:57:30 -0500 Subject: [PATCH 45/86] build --- dist/PieChart.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dist/PieChart.js b/dist/PieChart.js index efb5a974..f9b248b9 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -236,4 +236,4 @@ var PieChart = /** @class */ (function(_super) { 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 Pie from \"paths-js/pie\";\nimport React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport { G, Path, Rect, Svg } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\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.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\"\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n              //uncomment to wrap text (poor implementation)\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PieChart.js","sourceRoot":"","sources":["../src/PieChart.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 } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\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.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0;\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n              //uncomment to wrap text (poor implementation)\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} From 84b223081fd4ed789382251e8086459dfcf6cd78 Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Mon, 28 Jun 2021 14:40:57 -0500 Subject: [PATCH 46/86] build --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 2 +- package.json | 6 +++--- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 98130a3e..992e307f 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAwLP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAyLP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index f9b248b9..74cbd3fc 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -236,4 +236,4 @@ var PieChart = /** @class */ (function(_super) { 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 Pie from \"paths-js/pie\";\nimport React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport { G, Path, Rect, Svg } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\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.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0;\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n              //uncomment to wrap text (poor implementation)\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PieChart.js","sourceRoot":"","sources":["../src/PieChart.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 } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\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.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0;\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n            \n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n              //uncomment to wrap text (poor implementation)\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/package.json b/package.json index 6e19e2bf..0215c807 100644 --- a/package.json +++ b/package.json @@ -1,5 +1,5 @@ { - "name": "react-native-chart-kit", + "name": "@adalo/react-native-chart-kit", "version": "6.11.0", "devDependencies": { "@types/react-native": "^0.62.13", @@ -63,10 +63,10 @@ } }, "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": "16.14.8" From becfa8b6fc3ccf7e711d8e7ec4b0bdf842ad81dd Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Mon, 28 Jun 2021 14:41:43 -0500 Subject: [PATCH 47/86] build --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 992e307f..98130a3e 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAyLP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAwLP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 74cbd3fc..f9b248b9 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -236,4 +236,4 @@ var PieChart = /** @class */ (function(_super) { 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 Pie from \"paths-js/pie\";\nimport React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport { G, Path, Rect, Svg } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\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.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0;\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n            \n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n              //uncomment to wrap text (poor implementation)\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PieChart.js","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,GAAG,MAAM,cAAc,CAAC;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,IAAI,EAAa,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAElC,OAAO,aAAqC,MAAM,iBAAiB,CAAC;AAmBpE;IAAuB,4BAA2C;IAAlE;;IAyLA,CAAC;IAxLC,yBAAM,GAAN;QAAA,iBAuLC;QAtLO,IAAA,KAMF,IAAI,CAAC,KAAK,EALZ,aAAU,EAAV,KAAK,mBAAG,EAAE,KAAA,EACV,eAAe,qBAAA,EACf,gBAAgB,EAAhB,QAAQ,mBAAG,KAAK,KAAA,EAChB,iBAAgB,EAAhB,SAAS,mBAAG,IAAI,KAAA,EAChB,sBAAsB,EAAtB,cAAc,mBAAG,KAAK,KACV,CAAC;QAEP,IAAA,KAAqB,KAAK,aAAV,EAAhB,YAAY,mBAAG,CAAC,KAAA,CAAW;QAEnC,IAAI,oBAAoB,GAAG,IAAI,CAAC,KAAK,CAAC,oBAAoB,GAAG,IAAI,CAAC;QAElE,IAAI,MAAc,CAAC;QAEnB,IACE,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG;YACvB,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,oBAAoB,CAAC,GAAG,CAAC,EAC7C;YACA,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC;YACjC,oBAAoB,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;SACxD;aAAM;YACL,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,oBAAoB,GAAG,CAAC,CAAC,CAAC;SACxD;QAED,IAAI,oBAAoB,KAAK,CAAC,EAAE;YAC9B,oBAAoB,GAAG,GAAG,CAAC;SAC5B;QAED,IAAI,KAAK,GAAG,GAAG,CAAC;YACd,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;YACnC,CAAC,EAAE,CAAC;YACJ,CAAC,EAAE,MAAM;YACT,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;YACrB,QAAQ,EAAE,UAAA,CAAC;gBACT,OAAO,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YAChC,CAAC;SACF,CAAC,CAAC;QAEH,IAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,UAAC,GAAG,EAAE,IAAI;YAC7C,OAAO,GAAG,GAAG,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACzC,CAAC,EAAE,CAAC,CAAC,CAAC;QAEN,IAAI,YAAY,GAAG,EAAE,CAAC;QAEtB,IAAI,CAAC,QAAQ,EAAE;YACb,IAAM,SAAO,GAAG,KAAK,GAAG,KAAK,CAAC;YAC9B,IAAI,YAAU,GAAG,CAAC,CAAC;YACnB,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,UAAC,CAAC,EAAE,CAAC;gBACxB,IAAM,UAAU,GAAG,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,SAAO,CAAC;gBACzD,IAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAChD,IAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAClC,IAAI,OAAO,GAAG,UAAU,CAAC,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC1C,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE;oBAClB,OAAO,GAAG,CAAC,CAAC;iBACb;gBACD,YAAU,IAAI,KAAK,CAAC;gBACpB,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG;oBAC5B,KAAK,EAAE,CAAC;oBACR,KAAK,OAAA;oBACL,OAAO,SAAA;iBACR,CAAC;YACJ,CAAC,CAAC,CAAC;YAEH,IAAM,YAAY,GAAG,GAAG,GAAG,YAAU,CAAC;YACtC,IAAM,YAAY,GAAG,eAAI,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,UAAC,CAAC,EAAE,CAAC;gBAC/C,OAAA,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO;oBACnC,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO;oBACjC,CAAC,CAAC,CAAC;oBACH,CAAC,CAAC,CAAC,CAAC;YAHN,CAGM,CACP,CAAC;YACF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE;gBACrC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC;aACpE;SACF;QAED,IAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,UAAC,CAAC,EAAE,CAAC;YACnC,IAAI,KAAa,CAAC;YAElB,IAAI,QAAQ,EAAE;gBACZ,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;aACrC;iBAAM;gBACL,8CAA8C;gBAC9C,IAAI,KAAK,KAAK,CAAC,EAAE;oBACf,KAAK,GAAG,CAAC,GAAG,GAAG,CAAC;iBACjB;qBAAM;oBACL,IAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;oBACzC,IAAI,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC;oBAC5B,IAAI,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;wBACrC,UAAU,IAAI,CAAC,CAAC;qBACjB;oBACD,IAAI,cAAc,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,KAAK,CAAC,EAAE;wBAC5D,KAAK,GAAG,KAAK,CAAC;qBACf;yBAAM;wBACL,KAAK,GAAG,UAAU,GAAG,GAAG,CAAC;qBAC1B;iBACF;aACF;YACD,OAAO,CACL,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CACpB;UAAA,CAAC,IAAI,CACH,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CACzB,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CACnB,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAEzB;UAAA,CAAC,SAAS,CAAC,CAAC,CAAC,CACX,CAAC,IAAI,CACH,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAC7B,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAC9B,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CACnB,EAAE,CAAC,CAAC,CAAC,CAAC,CACN,EAAE,CAAC,CAAC,CAAC,CAAC,CACN,CAAC,CAAC,CACA,KAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,GAAG,GAAG,CAAC,oBAAoB,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;gBAC7D,EAAE,CACH,CACD,CAAC,CAAC,CACA,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC;gBAC1B,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,KAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;gBACxD,EAAE,CACH,EACD,CACH,CAAC,CAAC,CAAC,IAAI,CACR;UAAA,CAAC,SAAS,CAAC,CAAC,CAAC,CACX,CAAC,IAAI,CACH,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAC7B,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAChC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CACpC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CACpC,CAAC,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,GAAG,GAAG,CAAC,oBAAoB,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CACjE,CAAC,CAAC,CACA,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC;gBAC1B,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,KAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;gBACxD,EAAE,GAAG,CAAC,CACP,CAID;cAAA,CAAI,KAAK,SAAI,CAAC,CAAC,IAAI,CAAC,IAAM,CAC5B;YAAA,EAAE,IAAI,CAAC,CACR,CAAC,CAAC,CAAC,IAAI,CACV;QAAA,EAAE,CAAC,CAAC,CACL,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,OAAO,CACL,CAAC,IAAI,CACH,KAAK,CAAC,YACJ,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,EACvB,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EACzB,OAAO,EAAE,CAAC,IACP,KAAK,EACR,CAEF;QAAA,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CACtD;UAAA,CAAC,CAAC,CACA;YAAA,CAAC,IAAI,CAAC,UAAU,YACd,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EACxB,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,IACtB,IAAI,CAAC,KAAK,CAAC,WAAW,EACzB,CACJ;UAAA,EAAE,CAAC,CACH;UAAA,CAAC,IAAI,CACH,KAAK,CAAC,MAAM,CACZ,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAC1B,EAAE,CAAC,CAAC,YAAY,CAAC,CACjB,EAAE,CAAC,CAAC,YAAY,CAAC,CACjB,IAAI,CAAC,CAAC,eAAe,CAAC,EAExB;UAAA,CAAC,CAAC,CACA,CAAC,CAAC,CACA,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,oBAAoB,CAAC,GAAG,CAAC;YAC7C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAC5D,CACD,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QACzB,mBAAmB;QACnB,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAExB;YAAA,CAAC,MAAM,CACT;UAAA,EAAE,CAAC,CACL;QAAA,EAAE,GAAG,CACP;MAAA,EAAE,IAAI,CAAC,CACR,CAAC;IACJ,CAAC;IACH,eAAC;AAAD,CAAC,AAzLD,CAAuB,aAAa,GAyLnC;AAED,eAAe,QAAQ,CAAC","sourcesContent":["import Pie from \"paths-js/pie\";\nimport React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport { G, Path, Rect, Svg } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\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.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0;\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n              //uncomment to wrap text (poor implementation)\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} From 8663ee34ef74313ea2713e331548ce253044a045 Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Mon, 28 Jun 2021 14:53:38 -0500 Subject: [PATCH 48/86] add on click --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 4 +++- src/PieChart.tsx | 2 ++ 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 98130a3e..9b6e8d1f 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CAwLP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CA2LP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index f9b248b9..96671809 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -157,6 +157,8 @@ var PieChart = /** @class */ (function(_super) { d={c.sector.path.print()} fill={c.item.color} onPress={c.item.action} + //@ts-ignore + onClick={c.item.action} /> {hasLegend ? ( { d={c.sector.path.print()} fill={c.item.color} onPress={c.item.action} + //@ts-ignore + onClick={c.item.action} /> {hasLegend ? ( Date: Tue, 29 Jun 2021 14:13:58 -0500 Subject: [PATCH 49/86] modified onpress w/ bable --- .babelrc | 16 +++++++++++++++- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 4 +--- package.json | 1 + src/PieChart.tsx | 2 +- 5 files changed, 19 insertions(+), 6 deletions(-) diff --git a/.babelrc b/.babelrc index 7d30f8bf..f04109ce 100644 --- a/.babelrc +++ b/.babelrc @@ -1,3 +1,17 @@ +// { +// "presets": ["babel-preset-expo"] +// } { - "presets": ["babel-preset-expo"] + "presets": ["react"], + "plugins": [ + [ + "rename-jsx-attribute", + { + "attributes": { + "onPress": "onClick" + } + } + ] + ] } + diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 9b6e8d1f..7cc85452 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CA2LP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CA0LP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 96671809..c3fc93be 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -157,8 +157,6 @@ var PieChart = /** @class */ (function(_super) { d={c.sector.path.print()} fill={c.item.color} onPress={c.item.action} - //@ts-ignore - onClick={c.item.action} /> {hasLegend ? ( { fill={c.item.color} onPress={c.item.action} //@ts-ignore - onClick={c.item.action} + // onClick={c.item.action} /> {hasLegend ? ( Date: Tue, 29 Jun 2021 14:21:29 -0500 Subject: [PATCH 50/86] changing onPress in bable did not work --- .babelrc | 16 +--------------- dist/PieChart.js | 4 +++- package.json | 1 - src/PieChart.tsx | 2 +- 4 files changed, 5 insertions(+), 18 deletions(-) diff --git a/.babelrc b/.babelrc index f04109ce..7d30f8bf 100644 --- a/.babelrc +++ b/.babelrc @@ -1,17 +1,3 @@ -// { -// "presets": ["babel-preset-expo"] -// } { - "presets": ["react"], - "plugins": [ - [ - "rename-jsx-attribute", - { - "attributes": { - "onPress": "onClick" - } - } - ] - ] + "presets": ["babel-preset-expo"] } - diff --git a/dist/PieChart.js b/dist/PieChart.js index c3fc93be..1e826955 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -157,6 +157,8 @@ var PieChart = /** @class */ (function(_super) { d={c.sector.path.print()} fill={c.item.color} onPress={c.item.action} + //@ts-ignore + onClick={c.item.action} /> {hasLegend ? ( { fill={c.item.color} onPress={c.item.action} //@ts-ignore - // onClick={c.item.action} + onClick={c.item.action} /> {hasLegend ? ( Date: Tue, 29 Jun 2021 15:28:11 -0500 Subject: [PATCH 51/86] removed visx/text --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 5 ++--- src/PieChart.tsx | 3 +-- 3 files changed, 4 insertions(+), 6 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 7cc85452..26f50349 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CA0LP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CA0LP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 1e826955..e29f574e 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -52,8 +52,7 @@ var __spreadArrays = import Pie from "paths-js/pie"; import React from "react"; import { View } from "react-native"; -import { G, Path, Rect, Svg } from "react-native-svg"; -import { Text } from "@visx/text"; +import { G, Path, Rect, Svg, Text } from "react-native-svg"; import AbstractChart from "./AbstractChart"; var PieChart = /** @class */ (function(_super) { __extends(PieChart, _super); @@ -238,4 +237,4 @@ var PieChart = /** @class */ (function(_super) { return PieChart; })(AbstractChart); export default PieChart; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PieChart.js","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,GAAG,MAAM,cAAc,CAAC;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,IAAI,EAAa,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAElC,OAAO,aAAqC,MAAM,iBAAiB,CAAC;AAmBpE;IAAuB,4BAA2C;IAAlE;;IA2LA,CAAC;IA1LC,yBAAM,GAAN;QAAA,iBAyLC;QAxLO,IAAA,KAMF,IAAI,CAAC,KAAK,EALZ,aAAU,EAAV,KAAK,mBAAG,EAAE,KAAA,EACV,eAAe,qBAAA,EACf,gBAAgB,EAAhB,QAAQ,mBAAG,KAAK,KAAA,EAChB,iBAAgB,EAAhB,SAAS,mBAAG,IAAI,KAAA,EAChB,sBAAsB,EAAtB,cAAc,mBAAG,KAAK,KACV,CAAC;QAEP,IAAA,KAAqB,KAAK,aAAV,EAAhB,YAAY,mBAAG,CAAC,KAAA,CAAW;QAEnC,IAAI,oBAAoB,GAAG,IAAI,CAAC,KAAK,CAAC,oBAAoB,GAAG,IAAI,CAAC;QAElE,IAAI,MAAc,CAAC;QAEnB,IACE,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG;YACvB,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,oBAAoB,CAAC,GAAG,CAAC,EAC7C;YACA,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC;YACjC,oBAAoB,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;SACxD;aAAM;YACL,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,oBAAoB,GAAG,CAAC,CAAC,CAAC;SACxD;QAED,IAAI,oBAAoB,KAAK,CAAC,EAAE;YAC9B,oBAAoB,GAAG,GAAG,CAAC;SAC5B;QAED,IAAI,KAAK,GAAG,GAAG,CAAC;YACd,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;YACnC,CAAC,EAAE,CAAC;YACJ,CAAC,EAAE,MAAM;YACT,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;YACrB,QAAQ,EAAE,UAAA,CAAC;gBACT,OAAO,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YAChC,CAAC;SACF,CAAC,CAAC;QAEH,IAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,UAAC,GAAG,EAAE,IAAI;YAC7C,OAAO,GAAG,GAAG,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACzC,CAAC,EAAE,CAAC,CAAC,CAAC;QAEN,IAAI,YAAY,GAAG,EAAE,CAAC;QAEtB,IAAI,CAAC,QAAQ,EAAE;YACb,IAAM,SAAO,GAAG,KAAK,GAAG,KAAK,CAAC;YAC9B,IAAI,YAAU,GAAG,CAAC,CAAC;YACnB,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,UAAC,CAAC,EAAE,CAAC;gBACxB,IAAM,UAAU,GAAG,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,SAAO,CAAC;gBACzD,IAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAChD,IAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAClC,IAAI,OAAO,GAAG,UAAU,CAAC,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC1C,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE;oBAClB,OAAO,GAAG,CAAC,CAAC;iBACb;gBACD,YAAU,IAAI,KAAK,CAAC;gBACpB,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG;oBAC5B,KAAK,EAAE,CAAC;oBACR,KAAK,OAAA;oBACL,OAAO,SAAA;iBACR,CAAC;YACJ,CAAC,CAAC,CAAC;YAEH,IAAM,YAAY,GAAG,GAAG,GAAG,YAAU,CAAC;YACtC,IAAM,YAAY,GAAG,eAAI,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,UAAC,CAAC,EAAE,CAAC;gBAC/C,OAAA,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO;oBACnC,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO;oBACjC,CAAC,CAAC,CAAC;oBACH,CAAC,CAAC,CAAC,CAAC;YAHN,CAGM,CACP,CAAC;YACF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE;gBACrC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC;aACpE;SACF;QAED,IAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,UAAC,CAAC,EAAE,CAAC;YACnC,IAAI,KAAa,CAAC;YAElB,IAAI,QAAQ,EAAE;gBACZ,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;aACrC;iBAAM;gBACL,8CAA8C;gBAC9C,IAAI,KAAK,KAAK,CAAC,EAAE;oBACf,KAAK,GAAG,CAAC,GAAG,GAAG,CAAC;iBACjB;qBAAM;oBACL,IAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;oBACzC,IAAI,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC;oBAC5B,IAAI,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;wBACrC,UAAU,IAAI,CAAC,CAAC;qBACjB;oBACD,IAAI,cAAc,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,KAAK,CAAC,EAAE;wBAC5D,KAAK,GAAG,KAAK,CAAC;qBACf;yBAAM;wBACL,KAAK,GAAG,UAAU,GAAG,GAAG,CAAC;qBAC1B;iBACF;aACF;YACD,OAAO,CACL,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CACpB;UAAA,CAAC,IAAI,CACH,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CACzB,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CACnB,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;YACvB,YAAY;YACZ,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAEzB;UAAA,CAAC,SAAS,CAAC,CAAC,CAAC,CACX,CAAC,IAAI,CACH,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAC7B,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAC9B,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CACnB,EAAE,CAAC,CAAC,CAAC,CAAC,CACN,EAAE,CAAC,CAAC,CAAC,CAAC,CACN,CAAC,CAAC,CACA,KAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,GAAG,GAAG,CAAC,oBAAoB,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;gBAC7D,EAAE,CACH,CACD,CAAC,CAAC,CACA,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC;gBAC1B,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,KAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;gBACxD,EAAE,CACH,EACD,CACH,CAAC,CAAC,CAAC,IAAI,CACR;UAAA,CAAC,SAAS,CAAC,CAAC,CAAC,CACX,CAAC,IAAI,CACH,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAC7B,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAChC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CACpC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CACpC,CAAC,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,GAAG,GAAG,CAAC,oBAAoB,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CACjE,CAAC,CAAC,CACA,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC;gBAC1B,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,KAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;gBACxD,EAAE,GAAG,CAAC,CACP,CAID;cAAA,CAAI,KAAK,SAAI,CAAC,CAAC,IAAI,CAAC,IAAM,CAC5B;YAAA,EAAE,IAAI,CAAC,CACR,CAAC,CAAC,CAAC,IAAI,CACV;QAAA,EAAE,CAAC,CAAC,CACL,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,OAAO,CACL,CAAC,IAAI,CACH,KAAK,CAAC,YACJ,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,EACvB,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EACzB,OAAO,EAAE,CAAC,IACP,KAAK,EACR,CAEF;QAAA,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CACtD;UAAA,CAAC,CAAC,CACA;YAAA,CAAC,IAAI,CAAC,UAAU,YACd,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EACxB,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,IACtB,IAAI,CAAC,KAAK,CAAC,WAAW,EACzB,CACJ;UAAA,EAAE,CAAC,CACH;UAAA,CAAC,IAAI,CACH,KAAK,CAAC,MAAM,CACZ,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAC1B,EAAE,CAAC,CAAC,YAAY,CAAC,CACjB,EAAE,CAAC,CAAC,YAAY,CAAC,CACjB,IAAI,CAAC,CAAC,eAAe,CAAC,EAExB;UAAA,CAAC,CAAC,CACA,CAAC,CAAC,CACA,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,oBAAoB,CAAC,GAAG,CAAC;YAC7C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAC5D,CACD,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QACzB,mBAAmB;QACnB,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAExB;YAAA,CAAC,MAAM,CACT;UAAA,EAAE,CAAC,CACL;QAAA,EAAE,GAAG,CACP;MAAA,EAAE,IAAI,CAAC,CACR,CAAC;IACJ,CAAC;IACH,eAAC;AAAD,CAAC,AA3LD,CAAuB,aAAa,GA2LnC;AAED,eAAe,QAAQ,CAAC","sourcesContent":["import Pie from \"paths-js/pie\";\nimport React from \"react\";\nimport { View, ViewStyle } from \"react-native\";\nimport { G, Path, Rect, Svg } from \"react-native-svg\";\nimport { Text } from \"@visx/text\";\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\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.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0;\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n            //@ts-ignore\n            onClick={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n              //uncomment to wrap text (poor implementation)\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PieChart.js","sourceRoot":"","sources":["../src/PieChart.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, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\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.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0;\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n            //@ts-ignore\n            onClick={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n              //uncomment to wrap text (poor implementation)\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index e9388d00..8e21243b 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -1,8 +1,7 @@ import Pie from "paths-js/pie"; import React from "react"; import { View, ViewStyle } from "react-native"; -import { G, Path, Rect, Svg } from "react-native-svg"; -import { Text } from "@visx/text"; +import { G, Path, Rect, Svg, Text } from "react-native-svg"; import AbstractChart, { AbstractChartProps } from "./AbstractChart"; From 667e93baf5227554e3fb3dfda02afec31e4a7492 Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Tue, 29 Jun 2021 15:40:52 -0500 Subject: [PATCH 52/86] rebuild --- package.json | 1 - 1 file changed, 1 deletion(-) diff --git a/package.json b/package.json index 0215c807..9d3571a7 100644 --- a/package.json +++ b/package.json @@ -52,7 +52,6 @@ "react-native-svg": "> 6.4.1" }, "dependencies": { - "@visx/text": "^1.10.0", "lodash": "^4.17.13", "paths-js": "^0.4.10", "point-in-polygon": "^1.0.1" From 3972599ebb5591d9a75ffff69805c642055b3823 Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Thu, 1 Jul 2021 12:42:26 -0500 Subject: [PATCH 53/86] added truncating for the legend --- dist/PieChart.d.ts | 7 +- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 100 ++++++++++++++++++++++++--- dist/TextWidthFinder.d.ts | 1 + dist/TextWidthFinder.d.ts.map | 1 + dist/TextWidthFinder.js | 19 ++++++ src/PieChart.tsx | 123 +++++++++++++++++++++++++++++++--- src/TextWidthFinder.tsx | 21 ++++++ 8 files changed, 253 insertions(+), 21 deletions(-) create mode 100644 dist/TextWidthFinder.d.ts create mode 100644 dist/TextWidthFinder.d.ts.map create mode 100644 dist/TextWidthFinder.js create mode 100644 src/TextWidthFinder.tsx diff --git a/dist/PieChart.d.ts b/dist/PieChart.d.ts index 149f96d1..25dadc19 100644 --- a/dist/PieChart.d.ts +++ b/dist/PieChart.d.ts @@ -14,8 +14,13 @@ export interface PieChartProps extends AbstractChartProps { avoidFalseZero?: boolean; chartWidthPercentage: number; } -declare type PieChartState = {}; +declare type PieChartState = { + data: Array; + calculating: Array; +}; declare class PieChart extends AbstractChart { + componentDidUpdate(prevProps: any): void; + constructor(props: any); render(): JSX.Element; } export default PieChart; diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 26f50349..31817368 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,aAAa,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,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;CAC9B;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,MAAM;CA0LP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAA;CACxB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAchB,KAAK,KAAA;IAajB,MAAM;CAiPP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index e29f574e..9ed92ec0 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -51,14 +51,33 @@ var __spreadArrays = }; import Pie from "paths-js/pie"; import React from "react"; -import { View } from "react-native"; +import { View, Text as NativeText } from "react-native"; import { G, Path, Rect, Svg, Text } from "react-native-svg"; import AbstractChart from "./AbstractChart"; var PieChart = /** @class */ (function(_super) { __extends(PieChart, _super); - function PieChart() { - return (_super !== null && _super.apply(this, arguments)) || this; + 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({ calculating: calculating }, props); + return _this; } + PieChart.prototype.componentDidUpdate = function(prevProps) { + if ( + this.props.width !== prevProps.width || + this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || + 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 }; + } + this.setState(__assign({ calculating: calculating }, this.props)); + } + }; PieChart.prototype.render = function() { var _this = this; var _a = this.props, @@ -71,6 +90,62 @@ var PieChart = /** @class */ (function(_super) { hasLegend = _d === void 0 ? true : _d, _e = _a.avoidFalseZero, avoidFalseZero = _e === void 0 ? false : _e; + var onLayout = function(e, index, fontSize) { + var width = e.nativeEvent.layout.width; + var target = + _this.props.width - _this.props.width * chartWidthPercentage - 84; + var calculating = _this.state.calculating; + console.log("width", width); + if (width < target) { + calculating[index].calculating = false; + _this.setState(__assign({ calculating: calculating }, _this.state)); + } else { + var label = calculating[index].label.name; + if (label.slice(-3) === "...") { + label = label.slice(0, -3); + } + target = target - fontSize.split("p")[0] * 2; + var numberOfCharacters = label.length; + var ratio = target / width; + var targetCharacters = Math.floor(ratio * numberOfCharacters); + label = label.slice(0, targetCharacters) + "..."; + calculating[index].label.name = label; + if (label === "...") { + calculating[index].calculating = false; + } + _this.setState(__assign({ calculating: calculating }, _this.state)); + } + }; + 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) { + return ( + + + {value + " " + name} + + + ); + } + }); var _f = style.borderRadius, borderRadius = _f === void 0 ? 0 : _f; var chartWidthPercentage = this.props.chartWidthPercentage * 0.01; @@ -91,7 +166,7 @@ var PieChart = /** @class */ (function(_super) { center: this.props.center || [0, 0], r: 0, R: radius, - data: this.props.data, + data: this.state.data, accessor: function(x) { return x[_this.props.accessor]; } @@ -161,8 +236,8 @@ var PieChart = /** @class */ (function(_super) { /> {hasLegend ? ( - {value + " " + c.item.name} + {_this.state.calculating[c.index].label.value + + " " + + _this.state.calculating[c.index].label.name} ) : null} @@ -203,7 +280,11 @@ var PieChart = /** @class */ (function(_super) { style )} > - + {this.renderDefs( __assign( @@ -231,10 +312,11 @@ var PieChart = /** @class */ (function(_super) { {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 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, { AbstractChartProps } from \"./AbstractChart\";\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}\n\ntype PieChartState = {};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  render() {\n    const {\n      style = {},\n      backgroundColor,\n      absolute = false,\n      hasLegend = true,\n      avoidFalseZero = false\n    } = this.props;\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.props.data,\n      accessor: x => {\n        return x[this.props.accessor];\n      }\n    });\n\n    const total = this.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0;\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\n            onPress={c.item.action}\n            //@ts-ignore\n            onClick={c.item.action}\n          />\n          {hasLegend ? (\n            <Rect\n              width={c.item.legendFontSize}\n              height={c.item.legendFontSize}\n              fill={c.item.color}\n              rx={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n              //uncomment to wrap text (poor implementation)\n              // width={this.props.width / 2.5 - 16}\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 width={this.props.width} height={this.props.height}>\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PieChart.js","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,GAAG,MAAM,cAAc,CAAC;AAC/B,OAAO,KAAmB,MAAM,OAAO,CAAC;AACxC,OAAO,EAAE,IAAI,EAAa,IAAI,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,aAAqC,MAAM,iBAAiB,CAAC;AAuBpE;IAAuB,4BAA2C;IAehE,kBAAY,KAAK;QAAjB,YACE,kBAAM,KAAK,CAAC,SAUb;QATC,IAAI,WAAW,GAAG,EAAE,CAAC;QACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC/C,WAAW,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,KAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;SACnE;QAED,KAAI,CAAC,KAAK,cACR,WAAW,aAAA,IACR,KAAK,CACT,CAAC;;IACJ,CAAC;IAzBD,qCAAkB,GAAlB,UAAmB,SAAS;QAC1B,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,oBAAoB,KAAK,SAAS,CAAC,oBAAoB,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,SAAS,CAAC,IAAI,EAAE;YACnJ,IAAI,WAAW,GAAG,EAAE,CAAC;YACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAC/C,WAAW,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;aACnE;YAED,IAAI,CAAC,QAAQ,YACX,WAAW,aAAA,IACR,IAAI,CAAC,KAAK,EACb,CAAC;SACJ;IACH,CAAC;IAeD,yBAAM,GAAN;QAAA,iBAgPC;QA/OO,IAAA,KAMF,IAAI,CAAC,KAAK,EALZ,aAAU,EAAV,KAAK,mBAAG,EAAE,KAAA,EACV,eAAe,qBAAA,EACf,gBAAgB,EAAhB,QAAQ,mBAAG,KAAK,KAAA,EAChB,iBAAgB,EAAhB,SAAS,mBAAG,IAAI,KAAA,EAChB,sBAAsB,EAAtB,cAAc,mBAAG,KAAK,KACV,CAAC;QAEf,IAAM,QAAQ,GAAG,UAAC,CAAC,EAAE,KAAK,EAAE,QAAQ;YAClC,IAAI,KAAK,GAAG,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAA;YACtC,IAAI,MAAM,GAAG,KAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,KAAI,CAAC,KAAK,CAAC,KAAK,GAAG,oBAAoB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;YAChF,IAAI,WAAW,GAAG,KAAI,CAAC,KAAK,CAAC,WAAW,CAAA;YAExC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;YAE3B,IAAI,KAAK,GAAG,MAAM,EAAE;gBAClB,WAAW,CAAC,KAAK,CAAC,CAAC,WAAW,GAAG,KAAK,CAAA;gBACtC,KAAI,CAAC,QAAQ,YACX,WAAW,aAAA,IACR,KAAI,CAAC,KAAK,EACb,CAAA;aACH;iBAAM;gBACL,IAAI,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,CAAA;gBACzC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,EAAE;oBAC7B,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;iBAC3B;gBACD,MAAM,GAAG,MAAM,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;gBAC9C,IAAM,kBAAkB,GAAG,KAAK,CAAC,MAAM,CAAA;gBACvC,IAAM,KAAK,GAAG,MAAM,GAAG,KAAK,CAAA;gBAC5B,IAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,kBAAkB,CAAC,CAAA;gBAC/D,KAAK,GAAM,KAAK,CAAC,KAAK,CAAC,CAAC,EAAC,gBAAgB,CAAC,QAAK,CAAA;gBAC/C,WAAW,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,GAAG,KAAK,CAAA;gBACrC,IAAI,KAAK,KAAK,KAAK,EAAE;oBACnB,WAAW,CAAC,KAAK,CAAC,CAAC,WAAW,GAAG,KAAK,CAAA;iBACvC;gBACD,KAAI,CAAC,QAAQ,YACX,WAAW,aAAA,IACR,KAAI,CAAC,KAAK,EACb,CAAA;aAEH;QACH,CAAC,CAAC;QAEF,IAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,UAAC,IAAI,EAAE,KAAK;YACtD,IAAA,KAMA,IAAI,CAAC,KAAK,EALZ,IAAI,UAAA,EACJ,gBAAgB,sBAAA,EAChB,cAAc,oBAAA,EACd,gBAAgB,sBAAA,EAChB,KAAK,WACO,CAAA;YACd,IAAI,IAAI,CAAC,WAAW,IAAI,KAAI,CAAC,KAAK,CAAC,SAAS,EAAE;gBAC5C,OAAO,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAC,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,UAAC,CAAC,IAAK,OAAA,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,EAAlC,CAAkC,CAAE,CAC7H;YAAA,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAC,UAAU,EAAE,gBAAgB,EAAE,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,gBAAgB,EAAE,KAAK,EAAE,aAAa,EAAC,CAAC,CAAC,CAAI,KAAK,SAAI,IAAM,CAAC,EAAE,UAAU,CACnK;UAAA,EAAE,IAAI,CAAC,CACR,CAAC;aACH;QACH,CAAC,CAAC,CAAC;QAEK,IAAA,KAAqB,KAAK,aAAV,EAAhB,YAAY,mBAAG,CAAC,KAAA,CAAW;QAEnC,IAAI,oBAAoB,GAAG,IAAI,CAAC,KAAK,CAAC,oBAAoB,GAAG,IAAI,CAAC;QAElE,IAAI,MAAc,CAAC;QAEnB,IACE,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG;YACvB,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,oBAAoB,CAAC,GAAG,CAAC,EAC7C;YACA,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC;YACjC,oBAAoB,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;SACxD;aAAM;YACL,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,oBAAoB,GAAG,CAAC,CAAC,CAAC;SACxD;QAED,IAAI,oBAAoB,KAAK,CAAC,EAAE;YAC9B,oBAAoB,GAAG,GAAG,CAAC;SAC5B;QAED,IAAI,KAAK,GAAG,GAAG,CAAC;YACd,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;YACnC,CAAC,EAAE,CAAC;YACJ,CAAC,EAAE,MAAM;YACT,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;YACrB,QAAQ,EAAE,UAAA,CAAC;gBACT,OAAO,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YAChC,CAAC;SACF,CAAC,CAAC;QAEH,IAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,UAAC,GAAG,EAAE,IAAI;YAC7C,OAAO,GAAG,GAAG,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACzC,CAAC,EAAE,CAAC,CAAC,CAAC;QAEN,IAAI,YAAY,GAAG,EAAE,CAAC;QAEtB,IAAI,CAAC,QAAQ,EAAE;YACb,IAAM,SAAO,GAAG,KAAK,GAAG,KAAK,CAAC;YAC9B,IAAI,YAAU,GAAG,CAAC,CAAC;YACnB,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,UAAC,CAAC,EAAE,CAAC;gBACxB,IAAM,UAAU,GAAG,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,SAAO,CAAC;gBACzD,IAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAChD,IAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAClC,IAAI,OAAO,GAAG,UAAU,CAAC,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC1C,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE;oBAClB,OAAO,GAAG,CAAC,CAAC;iBACb;gBACD,YAAU,IAAI,KAAK,CAAC;gBACpB,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG;oBAC5B,KAAK,EAAE,CAAC;oBACR,KAAK,OAAA;oBACL,OAAO,SAAA;iBACR,CAAC;YACJ,CAAC,CAAC,CAAC;YAEH,IAAM,YAAY,GAAG,GAAG,GAAG,YAAU,CAAC;YACtC,IAAM,YAAY,GAAG,eAAI,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,UAAC,CAAC,EAAE,CAAC;gBAC/C,OAAA,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO;oBACnC,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO;oBACjC,CAAC,CAAC,CAAC;oBACH,CAAC,CAAC,CAAC,CAAC;YAHN,CAGM,CACP,CAAC;YACF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE;gBACrC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC;aACpE;SACF;QAED,IAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,UAAC,CAAC,EAAE,CAAC;YACnC,IAAI,KAAa,CAAC;YAElB,IAAI,QAAQ,EAAE;gBACZ,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;aACrC;iBAAM;gBACL,8CAA8C;gBAC9C,IAAI,KAAK,KAAK,CAAC,EAAE;oBACf,KAAK,GAAG,CAAC,GAAG,GAAG,CAAC;iBACjB;qBAAM;oBACL,IAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;oBACzC,IAAI,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC;oBAC5B,IAAI,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;wBACrC,UAAU,IAAI,CAAC,CAAC;qBACjB;oBACD,IAAI,cAAc,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,KAAK,CAAC,EAAE;wBAC5D,KAAK,GAAG,KAAK,CAAC;qBACf;yBAAM;wBACL,KAAK,GAAG,UAAU,GAAG,GAAG,CAAC;qBAC1B;iBACF;aACF;YACD,OAAO,CACL,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CACpB;UAAA,CAAC,IAAI,CACH,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CACzB,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CACnB,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;YACvB,YAAY;YACZ,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAEzB;UAAA,CAAC,SAAS,CAAC,CAAC,CAAC,CACX,CAAC,IAAI,CACH,KAAK,CAAC,CAAC,EAAE,CAAC,CACV,MAAM,CAAC,CAAC,EAAE,CAAC,CACX,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CACnB,EAAE,CAAC,CAAC,CAAC,CAAC,CACN,EAAE,CAAC,CAAC,CAAC,CAAC,CACN,CAAC,CAAC,CACA,KAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,GAAG,GAAG,CAAC,oBAAoB,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;gBAC7D,EAAE,CACH,CACD,CAAC,CAAC,CACA,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC;gBAC1B,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,KAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;gBACxD,EAAE,CACH,EACD,CACH,CAAC,CAAC,CAAC,IAAI,CACR;UAAA,CAAC,SAAS,CAAC,CAAC,CAAC,CACX,CAAC,IAAI,CACH,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAC7B,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAChC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CACpC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CACpC,CAAC,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,GAAG,GAAG,CAAC,oBAAoB,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CACjE,CAAC,CAAC,CACA,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC;gBAC1B,CAAC,CAAC,KAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,KAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;gBACxD,EAAE,GAAG,CAAC,CACP,CAED;cAAA,CAAI,KAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,SAAI,KAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,IAAM,CACjG;YAAA,EAAE,IAAI,CAAC,CACR,CAAC,CAAC,CAAC,IAAI,CACV;QAAA,EAAE,CAAC,CAAC,CACL,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,OAAO,CACL,CAAC,IAAI,CACH,KAAK,CAAC,YACJ,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,EACvB,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EACzB,OAAO,EAAE,CAAC,IACP,KAAK,EACR,CAEF;QAAA,CAAC,GAAG,CACF,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CACxB,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAC1B,KAAK,CAAC,CAAC,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC,CAE5B;UAAA,CAAC,CAAC,CACA;YAAA,CAAC,IAAI,CAAC,UAAU,YACd,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EACxB,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,IACtB,IAAI,CAAC,KAAK,CAAC,WAAW,EACzB,CACJ;UAAA,EAAE,CAAC,CACH;UAAA,CAAC,IAAI,CACH,KAAK,CAAC,MAAM,CACZ,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAC1B,EAAE,CAAC,CAAC,YAAY,CAAC,CACjB,EAAE,CAAC,CAAC,YAAY,CAAC,CACjB,IAAI,CAAC,CAAC,eAAe,CAAC,EAExB;UAAA,CAAC,CAAC,CACA,CAAC,CAAC,CACA,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,oBAAoB,CAAC,GAAG,CAAC;YAC7C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAC5D,CACD,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QACzB,mBAAmB;QACnB,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAExB;YAAA,CAAC,MAAM,CACT;UAAA,EAAE,CAAC,CACL;QAAA,EAAE,GAAG,CACL;QAAA,CAAC,YAAY,CACf;MAAA,EAAE,IAAI,CAAC,CACR,CAAC;IACJ,CAAC;IACH,eAAC;AAAD,CAAC,AA7QD,CAAuB,aAAa,GA6QnC;AAED,eAAe,QAAQ,CAAC","sourcesContent":["import 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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}\n\ntype PieChartState = {\n  data: Array<any>;\n  calculating: Array<any>\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (this.props.width !== prevProps.width || this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || this.props.data != prevProps.data) {\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\n      this.setState({\n        calculating,\n        ...this.props\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\n    this.state = {\n      calculating,\n      ...props\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 onLayout = (e, index, fontSize) => {\n      let width = e.nativeEvent.layout.width\n      let target = this.props.width - (this.props.width * chartWidthPercentage) - (84)\n      let calculating = this.state.calculating\n\n      console.log('width', width)\n\n      if (width < target) {\n        calculating[index].calculating = false\n        this.setState({\n          calculating,\n          ...this.state\n        })\n      } else {\n        let label = calculating[index].label.name\n        if (label.slice(-3) === \"...\") {\n          label = label.slice(0, -3)\n        }\n        target = target - (fontSize.split('p')[0] * 2)\n        const numberOfCharacters = label.length\n        const ratio = target / width\n        const targetCharacters = Math.floor(ratio * numberOfCharacters)\n        label = `${label.slice(0,targetCharacters)}...`\n        calculating[index].label.name = label\n        if (label === '...') {\n          calculating[index].calculating = false\n        }\n        this.setState({\n          calculating,\n          ...this.state\n        })\n\n      }\n    };\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        return (\n          <View key={index} style={{alignSelf: 'flex-start', position: 'absolute'}} onLayout={(e) => onLayout(e, index, legendFontSize) }>\n            <NativeText style={{fontFamily: legendFontFamily, fontSize: legendFontSize, fontWeight: legendFontWeight, color: 'transparent'}}>{`${value} ${name}`}</NativeText>\n          </View>\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.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0;\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n            >\n              {`${this.state.calculating[c.index].label.value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/dist/TextWidthFinder.d.ts b/dist/TextWidthFinder.d.ts new file mode 100644 index 00000000..c506b7b4 --- /dev/null +++ b/dist/TextWidthFinder.d.ts @@ -0,0 +1 @@ +//# sourceMappingURL=TextWidthFinder.d.ts.map 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..eb925002 --- /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== diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 8e21243b..cdfa0847 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -1,9 +1,10 @@ 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 TextWidthFinder from "./TextWidthFinder"; export interface PieChartProps extends AbstractChartProps { data: Array; @@ -20,9 +21,43 @@ export interface PieChartProps extends AbstractChartProps { chartWidthPercentage: number; } -type PieChartState = {}; +type PieChartState = { + data: Array; + calculating: Array; +}; class PieChart extends AbstractChart { + componentDidUpdate(prevProps) { + if ( + this.props.width !== prevProps.width || + this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || + 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 }; + } + + 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 + }; + } + render() { const { style = {}, @@ -32,6 +67,69 @@ class PieChart extends AbstractChart { avoidFalseZero = false } = this.props; + const onLayout = (e, index, fontSize) => { + let width = e.nativeEvent.layout.width; + let target = + this.props.width - this.props.width * chartWidthPercentage - 84; + let calculating = this.state.calculating; + + console.log("width", width); + + if (width < target) { + calculating[index].calculating = false; + this.setState({ + calculating, + ...this.state + }); + } else { + let label = calculating[index].label.name; + if (label.slice(-3) === "...") { + label = label.slice(0, -3); + } + target = target - fontSize.split("p")[0] * 2; + const numberOfCharacters = label.length; + const ratio = target / width; + const targetCharacters = Math.floor(ratio * numberOfCharacters); + label = `${label.slice(0, targetCharacters)}...`; + calculating[index].label.name = label; + if (label === "...") { + calculating[index].calculating = false; + } + this.setState({ + calculating, + ...this.state + }); + } + }; + + const calculations = this.state.calculating.map((item, index) => { + let { + name, + legendFontFamily, + legendFontSize, + legendFontWeight, + value + } = item.label; + if (item.calculating && this.props.hasLegend) { + return ( + onLayout(e, index, legendFontSize)} + > + {`${value} ${name}`} + + ); + } + }); + const { borderRadius = 0 } = style; let chartWidthPercentage = this.props.chartWidthPercentage * 0.01; @@ -56,7 +154,7 @@ class PieChart extends AbstractChart { center: this.props.center || [0, 0], r: 0, R: radius, - data: this.props.data, + data: this.state.data, accessor: x => { return x[this.props.accessor]; } @@ -132,8 +230,8 @@ class PieChart extends AbstractChart { /> {hasLegend ? ( { ((this.props.height * 0.8) / this.props.data.length) * i + 12 * 2 } - //uncomment to wrap text (poor implementation) - // width={this.props.width / 2.5 - 16} > - {`${value} ${c.item.name}`} + {`${this.state.calculating[c.index].label.value} ${ + this.state.calculating[c.index].label.name + }`} ) : null} @@ -179,7 +277,11 @@ class PieChart extends AbstractChart { ...style }} > - + {this.renderDefs({ width: this.props.height, @@ -206,6 +308,7 @@ class PieChart extends AbstractChart { {slices} + {calculations} ); } diff --git a/src/TextWidthFinder.tsx b/src/TextWidthFinder.tsx new file mode 100644 index 00000000..60ee3e5b --- /dev/null +++ b/src/TextWidthFinder.tsx @@ -0,0 +1,21 @@ +// 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} +// +// ); +// } From c49edf1c5ddbb315334b18a8a07171657f801f9a Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Thu, 1 Jul 2021 13:02:18 -0500 Subject: [PATCH 54/86] removed console.log --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 3 +-- src/PieChart.tsx | 2 -- 3 files changed, 2 insertions(+), 5 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 31817368..9899cde4 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAA;CACxB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAchB,KAAK,KAAA;IAajB,MAAM;CAiPP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAkBhB,KAAK,KAAA;IAajB,MAAM;CA4PP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 9ed92ec0..68795ffe 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -95,7 +95,6 @@ var PieChart = /** @class */ (function(_super) { var target = _this.props.width - _this.props.width * chartWidthPercentage - 84; var calculating = _this.state.calculating; - console.log("width", width); if (width < target) { calculating[index].calculating = false; _this.setState(__assign({ calculating: calculating }, _this.state)); @@ -319,4 +318,4 @@ var PieChart = /** @class */ (function(_super) { 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 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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}\n\ntype PieChartState = {\n  data: Array<any>;\n  calculating: Array<any>\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (this.props.width !== prevProps.width || this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || this.props.data != prevProps.data) {\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\n      this.setState({\n        calculating,\n        ...this.props\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\n    this.state = {\n      calculating,\n      ...props\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 onLayout = (e, index, fontSize) => {\n      let width = e.nativeEvent.layout.width\n      let target = this.props.width - (this.props.width * chartWidthPercentage) - (84)\n      let calculating = this.state.calculating\n\n      console.log('width', width)\n\n      if (width < target) {\n        calculating[index].calculating = false\n        this.setState({\n          calculating,\n          ...this.state\n        })\n      } else {\n        let label = calculating[index].label.name\n        if (label.slice(-3) === \"...\") {\n          label = label.slice(0, -3)\n        }\n        target = target - (fontSize.split('p')[0] * 2)\n        const numberOfCharacters = label.length\n        const ratio = target / width\n        const targetCharacters = Math.floor(ratio * numberOfCharacters)\n        label = `${label.slice(0,targetCharacters)}...`\n        calculating[index].label.name = label\n        if (label === '...') {\n          calculating[index].calculating = false\n        }\n        this.setState({\n          calculating,\n          ...this.state\n        })\n\n      }\n    };\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        return (\n          <View key={index} style={{alignSelf: 'flex-start', position: 'absolute'}} onLayout={(e) => onLayout(e, index, legendFontSize) }>\n            <NativeText style={{fontFamily: legendFontFamily, fontSize: legendFontSize, fontWeight: legendFontWeight, color: 'transparent'}}>{`${value} ${name}`}</NativeText>\n          </View>\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.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0;\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n            >\n              {`${this.state.calculating[c.index].label.value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PieChart.js","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"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","sourcesContent":["import 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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}\n\ntype PieChartState = {\n  data: Array<any>;\n  calculating: Array<any>;\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      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\n      this.setState({\n        calculating,\n        ...this.props\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\n    this.state = {\n      calculating,\n      ...props\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 onLayout = (e, index, fontSize) => {\n      let width = e.nativeEvent.layout.width;\n      let target =\n        this.props.width - this.props.width * chartWidthPercentage - 84;\n      let calculating = this.state.calculating;\n\n      if (width < target) {\n        calculating[index].calculating = false;\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      } else {\n        let label = calculating[index].label.name;\n        if (label.slice(-3) === \"...\") {\n          label = label.slice(0, -3);\n        }\n        target = target - fontSize.split(\"p\")[0] * 2;\n        const numberOfCharacters = label.length;\n        const ratio = target / width;\n        const targetCharacters = Math.floor(ratio * numberOfCharacters);\n        label = `${label.slice(0, targetCharacters)}...`;\n        calculating[index].label.name = label;\n        if (label === \"...\") {\n          calculating[index].calculating = false;\n        }\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      }\n    };\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        return (\n          <View\n            key={index}\n            style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n            onLayout={e => onLayout(e, index, legendFontSize)}\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      }\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.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0;\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n            >\n              {`${this.state.calculating[c.index].label.value} ${\n                this.state.calculating[c.index].label.name\n              }`}\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index cdfa0847..9999474a 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -73,8 +73,6 @@ class PieChart extends AbstractChart { this.props.width - this.props.width * chartWidthPercentage - 84; let calculating = this.state.calculating; - console.log("width", width); - if (width < target) { calculating[index].calculating = false; this.setState({ From 83b4d0700dfcd8057ab3b429f7679bb2b2a9dc6f Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Thu, 1 Jul 2021 14:20:55 -0500 Subject: [PATCH 55/86] fixed percentages w/ truncating --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 97 +++++++++++++++++++++++++++--------------- src/PieChart.tsx | 89 ++++++++++++++++++++++++-------------- 3 files changed, 122 insertions(+), 66 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 9899cde4..274c5b01 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAEA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAkBhB,KAAK,KAAA;IAajB,MAAM;CA4PP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAkBhB,KAAK,KAAA;IAajB,MAAM;CA2RP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 68795ffe..15360a07 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -49,6 +49,7 @@ var __spreadArrays = r[k] = a[j]; return r; }; +import { isObject } from "lodash"; import Pie from "paths-js/pie"; import React from "react"; import { View, Text as NativeText } from "react-native"; @@ -95,6 +96,7 @@ var PieChart = /** @class */ (function(_super) { var target = _this.props.width - _this.props.width * chartWidthPercentage - 84; var calculating = _this.state.calculating; + console.log("width", width, "target", target); if (width < target) { calculating[index].calculating = false; _this.setState(__assign({ calculating: calculating }, _this.state)); @@ -123,26 +125,51 @@ var PieChart = /** @class */ (function(_super) { legendFontWeight = _a.legendFontWeight, value = _a.value; if (item.calculating && _this.props.hasLegend) { - return ( - - + + {value + " " + name} + + + ); + } else { + return ( + - {value + " " + name} - - - ); + + {//@ts-ignore + value.whole + "% " + name} + + + ); + } } }); var _f = style.borderRadius, @@ -178,19 +205,23 @@ var PieChart = /** @class */ (function(_super) { var divisor_1 = total / 100.0; var wholeTotal_1 = 0; chart.curves.forEach(function(c, i) { - 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; + if (!isObject(c.item[_this.props.accessor])) { + 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; + c.item[_this.props.accessor] = { + index: i, + whole: whole, + decimal: decimal + }; + } else { + wholeTotal_1 += c.item[_this.props.accessor].whole; } - wholeTotal_1 += whole; - c.item[_this.props.accessor] = { - index: i, - whole: whole, - decimal: decimal - }; }); var hamiltonDiff = 100 - wholeTotal_1; var sortedCurves = __spreadArrays(chart.curves).sort(function(a, b) { @@ -264,9 +295,7 @@ var PieChart = /** @class */ (function(_super) { 12 * 2 } > - {_this.state.calculating[c.index].label.value + - " " + - _this.state.calculating[c.index].label.name} + {value + " " + _this.state.calculating[c.index].label.name} ) : null} @@ -318,4 +347,4 @@ var PieChart = /** @class */ (function(_super) { 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 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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}\n\ntype PieChartState = {\n  data: Array<any>;\n  calculating: Array<any>;\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      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\n      this.setState({\n        calculating,\n        ...this.props\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\n    this.state = {\n      calculating,\n      ...props\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 onLayout = (e, index, fontSize) => {\n      let width = e.nativeEvent.layout.width;\n      let target =\n        this.props.width - this.props.width * chartWidthPercentage - 84;\n      let calculating = this.state.calculating;\n\n      if (width < target) {\n        calculating[index].calculating = false;\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      } else {\n        let label = calculating[index].label.name;\n        if (label.slice(-3) === \"...\") {\n          label = label.slice(0, -3);\n        }\n        target = target - fontSize.split(\"p\")[0] * 2;\n        const numberOfCharacters = label.length;\n        const ratio = target / width;\n        const targetCharacters = Math.floor(ratio * numberOfCharacters);\n        label = `${label.slice(0, targetCharacters)}...`;\n        calculating[index].label.name = label;\n        if (label === \"...\") {\n          calculating[index].calculating = false;\n        }\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      }\n    };\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        return (\n          <View\n            key={index}\n            style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n            onLayout={e => onLayout(e, index, legendFontSize)}\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      }\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.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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        const percentage = c.item[this.props.accessor] / divisor;\n        const pieces = percentage.toString().split(\".\");\n        const whole = parseInt(pieces[0]);\n        let decimal = parseFloat(\".\" + pieces[1]);\n        if (isNaN(decimal)) {\n          decimal = 0;\n        }\n        wholeTotal += whole;\n        c.item[this.props.accessor] = {\n          index: i,\n          whole,\n          decimal\n        };\n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n            >\n              {`${this.state.calculating[c.index].label.value} ${\n                this.state.calculating[c.index].label.name\n              }`}\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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}\n\ntype PieChartState = {\n  data: Array<any>;\n  calculating: Array<any>;\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      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\n      this.setState({\n        calculating,\n        ...this.props\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\n    this.state = {\n      calculating,\n      ...props\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 onLayout = (e, index, fontSize) => {\n      let width = e.nativeEvent.layout.width;\n      let target =\n        this.props.width - this.props.width * chartWidthPercentage - 84;\n      let calculating = this.state.calculating;\n\n      console.log('width', width, 'target', target)\n      if (width < target) {\n        calculating[index].calculating = false;\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      } else {\n        let label = calculating[index].label.name;\n        if (label.slice(-3) === \"...\") {\n          label = label.slice(0, -3);\n        }\n        target = target - fontSize.split(\"p\")[0] * 2;\n        const numberOfCharacters = label.length;\n        const ratio = target / width;\n        const targetCharacters = Math.floor(ratio * numberOfCharacters);\n        label = `${label.slice(0, targetCharacters)}...`;\n        calculating[index].label.name = label;\n        if (label === \"...\") {\n          calculating[index].calculating = false;\n        }\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      }\n    };\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        console.log('value', value)\n        if(!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize)}\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              onLayout={e => onLayout(e, index, legendFontSize)}\n            >\n              <NativeText\n                style={{\n                  fontFamily: legendFontFamily,\n                  fontSize: legendFontSize,\n                  fontWeight: legendFontWeight,\n                  color: \"transparent\"\n                }}\n              >\n                {\n                  //@ts-ignore\n                 `${value.whole}% ${name}`\n                }\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.props.data.reduce((sum, item) => {\n      return sum + item[this.props.accessor];\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[this.props.accessor])){\n          const percentage = c.item[this.props.accessor] / divisor;\n          const pieces = percentage.toString().split(\".\");\n          const whole = parseInt(pieces[0]);\n          let decimal = parseFloat(\".\" + pieces[1]);\n          if (isNaN(decimal)) {\n            decimal = 0;\n          }\n          wholeTotal += whole;\n          c.item[this.props.accessor] = {\n            index: i,\n            whole,\n            decimal,\n          };\n        } else {\n          wholeTotal += c.item[this.props.accessor].whole\n        }\n        \n      });\n\n      const hamiltonDiff = 100 - wholeTotal;\n      const sortedCurves = [...chart.curves].sort((a, b) =>\n        a.item[this.props.accessor].decimal <\n        b.item[this.props.accessor].decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item[this.props.accessor].index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\n      } else {\n        //calculate percentage using Hamilton's method\n        if (total === 0) {\n          value = 0 + \"%\";\n        } else {\n          const item = c.item[this.props.accessor];\n          let percentage = item.whole;\n          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n            >\n              {`${value} ${\n                this.state.calculating[c.index].label.name\n              }`}\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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 9999474a..49361dbd 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -1,3 +1,4 @@ +import { isObject } from "lodash"; import Pie from "paths-js/pie"; import React, { Fragment } from "react"; import { View, ViewStyle, Text as NativeText } from "react-native"; @@ -73,6 +74,7 @@ class PieChart extends AbstractChart { this.props.width - this.props.width * chartWidthPercentage - 84; let calculating = this.state.calculating; + console.log("width", width, "target", target); if (width < target) { calculating[index].calculating = false; this.setState({ @@ -109,22 +111,45 @@ class PieChart extends AbstractChart { value } = item.label; if (item.calculating && this.props.hasLegend) { - return ( - onLayout(e, index, legendFontSize)} - > - {`${value} ${name}`} - - ); + console.log("value", value); + if (!isObject(value)) { + return ( + onLayout(e, index, legendFontSize)} + > + {`${value} ${name}`} + + ); + } else { + return ( + onLayout(e, index, legendFontSize)} + > + + {//@ts-ignore + `${value.whole}% ${name}`} + + + ); + } } }); @@ -168,19 +193,23 @@ class PieChart extends AbstractChart { const divisor = total / 100.0; let wholeTotal = 0; chart.curves.forEach((c, i) => { - const percentage = c.item[this.props.accessor] / divisor; - const pieces = percentage.toString().split("."); - const whole = parseInt(pieces[0]); - let decimal = parseFloat("." + pieces[1]); - if (isNaN(decimal)) { - decimal = 0; + if (!isObject(c.item[this.props.accessor])) { + const percentage = c.item[this.props.accessor] / divisor; + const pieces = percentage.toString().split("."); + const whole = parseInt(pieces[0]); + let decimal = parseFloat("." + pieces[1]); + if (isNaN(decimal)) { + decimal = 0; + } + wholeTotal += whole; + c.item[this.props.accessor] = { + index: i, + whole, + decimal + }; + } else { + wholeTotal += c.item[this.props.accessor].whole; } - wholeTotal += whole; - c.item[this.props.accessor] = { - index: i, - whole, - decimal - }; }); const hamiltonDiff = 100 - wholeTotal; @@ -257,9 +286,7 @@ class PieChart extends AbstractChart { 12 * 2 } > - {`${this.state.calculating[c.index].label.value} ${ - this.state.calculating[c.index].label.name - }`} + {`${value} ${this.state.calculating[c.index].label.name}`} ) : null} From 9b069a0060b5a44ec120df5e3cdeb59d86815f5a Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Thu, 1 Jul 2021 14:48:59 -0500 Subject: [PATCH 56/86] Revert "rebuild" This reverts commit 0813f75c462b4ec82ea2f52137afe10e289cddeb. --- package.json | 1 + 1 file changed, 1 insertion(+) diff --git a/package.json b/package.json index 9d3571a7..0215c807 100644 --- a/package.json +++ b/package.json @@ -52,6 +52,7 @@ "react-native-svg": "> 6.4.1" }, "dependencies": { + "@visx/text": "^1.10.0", "lodash": "^4.17.13", "paths-js": "^0.4.10", "point-in-polygon": "^1.0.1" From 66e60001326025b49e0a4b8068b193874f251bd8 Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Thu, 1 Jul 2021 15:43:59 -0500 Subject: [PATCH 57/86] fixed issues with color in editor --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 38 ++++++++++++++++++++++++++++---------- package.json | 1 - src/PieChart.tsx | 34 ++++++++++++++++++++++++++-------- 4 files changed, 55 insertions(+), 20 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 274c5b01..2d4f72bc 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAkBhB,KAAK,KAAA;IAajB,MAAM;CA2RP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAuBhB,KAAK,KAAA;IAajB,MAAM;CA8RP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 15360a07..c0db187e 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -72,12 +72,18 @@ var PieChart = /** @class */ (function(_super) { this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || this.props.data != prevProps.data ) { + console.log("update"); + console.log(this.props); + console.log(prevProps); + console.log(this.state); var calculating = []; for (var i = 0; i < this.props.data.length; i++) { calculating[i] = { label: this.props.data[i], calculating: true }; } + console.log("set state1", calculating); this.setState(__assign({ calculating: calculating }, this.props)); } + console.log("updated state", this.state.calculating); }; PieChart.prototype.render = function() { var _this = this; @@ -91,21 +97,30 @@ var PieChart = /** @class */ (function(_super) { hasLegend = _d === void 0 ? true : _d, _e = _a.avoidFalseZero, avoidFalseZero = _e === void 0 ? false : _e; - var onLayout = function(e, index, fontSize) { + var onLayout = function(e, index, fontSize, label) { + console.log("index", index, "label", label); var width = e.nativeEvent.layout.width; var target = _this.props.width - _this.props.width * chartWidthPercentage - 84; var calculating = _this.state.calculating; - console.log("width", width, "target", target); if (width < target) { calculating[index].calculating = false; + console.log( + "set state 2", + calculating, + index, + calculating[index].calculating + ); _this.setState(__assign({ calculating: calculating }, _this.state)); } else { - var label = calculating[index].label.name; if (label.slice(-3) === "...") { label = label.slice(0, -3); } - target = target - fontSize.split("p")[0] * 2; + if (isNaN(fontSize)) { + target = target - fontSize.split("p")[0] * 2; + } else { + target = target - fontSize * 2; + } var numberOfCharacters = label.length; var ratio = target / width; var targetCharacters = Math.floor(ratio * numberOfCharacters); @@ -114,6 +129,8 @@ var PieChart = /** @class */ (function(_super) { if (label === "...") { calculating[index].calculating = false; } + console.log("width", width, "target", target, "label", label); + console.log("set state 3", calculating); _this.setState(__assign({ calculating: calculating }, _this.state)); } }; @@ -124,15 +141,16 @@ var PieChart = /** @class */ (function(_super) { legendFontSize = _a.legendFontSize, legendFontWeight = _a.legendFontWeight, value = _a.value; + console.log("calc index", index); if (item.calculating && _this.props.hasLegend) { - console.log("value", value); + console.log(item); if (!isObject(value)) { return ( - {//@ts-ignore - value.whole + "% " + name} + {value.whole + "% " + name} ); @@ -255,6 +272,7 @@ var PieChart = /** @class */ (function(_super) { } } } + console.log("label name", _this.state.calculating[c.index].label.name); return ( 6.4.1" }, "dependencies": { - "@visx/text": "^1.10.0", "lodash": "^4.17.13", "paths-js": "^0.4.10", "point-in-polygon": "^1.0.1" diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 49361dbd..a51011bf 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -34,16 +34,21 @@ class PieChart extends AbstractChart { this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || this.props.data != prevProps.data ) { + console.log("update"); + console.log(this.props); + console.log(prevProps); + console.log(this.state); let calculating = []; for (let i = 0; i < this.props.data.length; i++) { calculating[i] = { label: this.props.data[i], calculating: true }; } - + console.log("set state1", calculating); this.setState({ calculating, ...this.props }); } + console.log("updated state", this.state.calculating); } constructor(props) { @@ -68,25 +73,34 @@ class PieChart extends AbstractChart { avoidFalseZero = false } = this.props; - const onLayout = (e, index, fontSize) => { + const onLayout = (e, index, fontSize, label) => { + console.log("index", index, "label", label); let width = e.nativeEvent.layout.width; let target = this.props.width - this.props.width * chartWidthPercentage - 84; let calculating = this.state.calculating; - console.log("width", width, "target", target); if (width < target) { calculating[index].calculating = false; + console.log( + "set state 2", + calculating, + index, + calculating[index].calculating + ); this.setState({ calculating, ...this.state }); } else { - let label = calculating[index].label.name; if (label.slice(-3) === "...") { label = label.slice(0, -3); } - target = target - fontSize.split("p")[0] * 2; + if (isNaN(fontSize)) { + target = target - fontSize.split("p")[0] * 2; + } else { + target = target - fontSize * 2; + } const numberOfCharacters = label.length; const ratio = target / width; const targetCharacters = Math.floor(ratio * numberOfCharacters); @@ -95,6 +109,8 @@ class PieChart extends AbstractChart { if (label === "...") { calculating[index].calculating = false; } + console.log("width", width, "target", target, "label", label); + console.log("set state 3", calculating); this.setState({ calculating, ...this.state @@ -110,14 +126,15 @@ class PieChart extends AbstractChart { legendFontWeight, value } = item.label; + console.log("calc index", index); if (item.calculating && this.props.hasLegend) { - console.log("value", value); + console.log(item); if (!isObject(value)) { return ( onLayout(e, index, legendFontSize)} + onLayout={e => onLayout(e, index, legendFontSize, name)} > { onLayout(e, index, legendFontSize)} + onLayout={e => onLayout(e, index, legendFontSize, name)} > { } } } + console.log("label name", this.state.calculating[c.index].label.name); return ( Date: Fri, 2 Jul 2021 10:20:11 -0500 Subject: [PATCH 58/86] fixed issue with chart not showing when values are percentages --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 47 +++++++++++++++--------------------------- src/PieChart.tsx | 47 +++++++++++++++--------------------------- 3 files changed, 35 insertions(+), 61 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 2d4f72bc..f80f51a2 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAuBhB,KAAK,KAAA;IAajB,MAAM;CA8RP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAiBhB,KAAK,KAAA;IAcjB,MAAM;CA8RP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index c0db187e..634e4d2f 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -63,7 +63,9 @@ var PieChart = /** @class */ (function(_super) { for (var i = 0; i < _this.props.data.length; i++) { calculating[i] = { label: _this.props.data[i], calculating: true }; } - _this.state = __assign({ calculating: calculating }, props); + _this.state = __assign(__assign({ calculating: calculating }, props), { + labelData: _this.props.data + }); return _this; } PieChart.prototype.componentDidUpdate = function(prevProps) { @@ -72,18 +74,12 @@ var PieChart = /** @class */ (function(_super) { this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || this.props.data != prevProps.data ) { - console.log("update"); - console.log(this.props); - console.log(prevProps); - console.log(this.state); var calculating = []; for (var i = 0; i < this.props.data.length; i++) { calculating[i] = { label: this.props.data[i], calculating: true }; } - console.log("set state1", calculating); this.setState(__assign({ calculating: calculating }, this.props)); } - console.log("updated state", this.state.calculating); }; PieChart.prototype.render = function() { var _this = this; @@ -98,19 +94,12 @@ var PieChart = /** @class */ (function(_super) { _e = _a.avoidFalseZero, avoidFalseZero = _e === void 0 ? false : _e; var onLayout = function(e, index, fontSize, label) { - console.log("index", index, "label", label); var width = e.nativeEvent.layout.width; var target = _this.props.width - _this.props.width * chartWidthPercentage - 84; var calculating = _this.state.calculating; if (width < target) { calculating[index].calculating = false; - console.log( - "set state 2", - calculating, - index, - calculating[index].calculating - ); _this.setState(__assign({ calculating: calculating }, _this.state)); } else { if (label.slice(-3) === "...") { @@ -129,8 +118,6 @@ var PieChart = /** @class */ (function(_super) { if (label === "...") { calculating[index].calculating = false; } - console.log("width", width, "target", target, "label", label); - console.log("set state 3", calculating); _this.setState(__assign({ calculating: calculating }, _this.state)); } }; @@ -141,9 +128,7 @@ var PieChart = /** @class */ (function(_super) { legendFontSize = _a.legendFontSize, legendFontWeight = _a.legendFontWeight, value = _a.value; - console.log("calc index", index); if (item.calculating && _this.props.hasLegend) { - console.log(item); if (!isObject(value)) { return ( { this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || this.props.data != prevProps.data ) { - console.log("update"); - console.log(this.props); - console.log(prevProps); - console.log(this.state); let calculating = []; for (let i = 0; i < this.props.data.length; i++) { calculating[i] = { label: this.props.data[i], calculating: true }; } - console.log("set state1", calculating); this.setState({ calculating, ...this.props }); } - console.log("updated state", this.state.calculating); } constructor(props) { @@ -60,7 +54,8 @@ class PieChart extends AbstractChart { this.state = { calculating, - ...props + ...props, + labelData: this.props.data }; } @@ -74,7 +69,6 @@ class PieChart extends AbstractChart { } = this.props; const onLayout = (e, index, fontSize, label) => { - console.log("index", index, "label", label); let width = e.nativeEvent.layout.width; let target = this.props.width - this.props.width * chartWidthPercentage - 84; @@ -82,12 +76,6 @@ class PieChart extends AbstractChart { if (width < target) { calculating[index].calculating = false; - console.log( - "set state 2", - calculating, - index, - calculating[index].calculating - ); this.setState({ calculating, ...this.state @@ -109,8 +97,6 @@ class PieChart extends AbstractChart { if (label === "...") { calculating[index].calculating = false; } - console.log("width", width, "target", target, "label", label); - console.log("set state 3", calculating); this.setState({ calculating, ...this.state @@ -126,9 +112,7 @@ class PieChart extends AbstractChart { legendFontWeight, value } = item.label; - console.log("calc index", index); if (item.calculating && this.props.hasLegend) { - console.log(item); if (!isObject(value)) { return ( { }); const total = this.props.data.reduce((sum, item) => { - return sum + item[this.props.accessor]; + if (isObject(item[this.props.accessor])) { + return sum + item[this.props.accessor].whole; + } else { + return sum + item[this.props.accessor]; + } }, 0); let uppedIndices = []; @@ -210,34 +198,33 @@ class PieChart extends AbstractChart { const divisor = total / 100.0; let wholeTotal = 0; chart.curves.forEach((c, i) => { - if (!isObject(c.item[this.props.accessor])) { + if (!isObject(c.item.values)) { const percentage = c.item[this.props.accessor] / divisor; const pieces = percentage.toString().split("."); - const whole = parseInt(pieces[0]); + let whole = parseInt(pieces[0]); let decimal = parseFloat("." + pieces[1]); if (isNaN(decimal)) { decimal = 0; } wholeTotal += whole; - c.item[this.props.accessor] = { + //this is causing the issue + //change this to label instead of this.props.accessor? + c.item.values = { index: i, whole, decimal }; } else { - wholeTotal += c.item[this.props.accessor].whole; + wholeTotal += c.item.values.whole; } }); const hamiltonDiff = 100 - wholeTotal; const sortedCurves = [...chart.curves].sort((a, b) => - a.item[this.props.accessor].decimal < - b.item[this.props.accessor].decimal - ? 1 - : -1 + a.item.values.decimal < b.item.values.decimal ? 1 : -1 ); for (let i = 0; i < hamiltonDiff; i++) { - uppedIndices.push(sortedCurves[i].item[this.props.accessor].index); + uppedIndices.push(sortedCurves[i].item.values.index); } } @@ -251,7 +238,7 @@ class PieChart extends AbstractChart { if (total === 0) { value = 0 + "%"; } else { - const item = c.item[this.props.accessor]; + const item = c.item.values; let percentage = item.whole; if (uppedIndices.includes(item.index)) { percentage += 1; @@ -263,7 +250,7 @@ class PieChart extends AbstractChart { } } } - console.log("label name", this.state.calculating[c.index].label.name); + return ( Date: Tue, 6 Jul 2021 11:09:05 -0500 Subject: [PATCH 59/86] build to fix percentage bugs --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 5 ++--- src/PieChart.tsx | 3 +-- 3 files changed, 4 insertions(+), 6 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index f80f51a2..240cac04 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAiBhB,KAAK,KAAA;IAcjB,MAAM;CA8RP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAiBhB,KAAK,KAAA;IAcjB,MAAM;CA0RP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 634e4d2f..06bb972c 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -220,8 +220,7 @@ var PieChart = /** @class */ (function(_super) { decimal = 0; } wholeTotal_1 += whole; - //this is causing the issue - //change this to label instead of this.props.accessor? + //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, @@ -352,4 +351,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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}\n\ntype PieChartState = {\n  data: Array<any>;\n  calculating: Array<any>;\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      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      this.setState({\n        calculating,\n        ...this.props\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\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 onLayout = (e, index, fontSize, label) => {\n      let width = e.nativeEvent.layout.width;\n      let target =\n        this.props.width - this.props.width * chartWidthPercentage - 84;\n      let calculating = this.state.calculating;\n\n      if (width < target) {\n        calculating[index].calculating = false;\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      } else {\n        if (label.slice(-3) === \"...\") {\n          label = label.slice(0, -3);\n        }\n        if (isNaN(fontSize)) {\n          target = target - fontSize.split(\"p\")[0] * 2;\n        } else {\n          target = target - fontSize * 2;\n        }\n        const numberOfCharacters = label.length;\n        const ratio = target / width;\n        const targetCharacters = Math.floor(ratio * numberOfCharacters);\n        label = `${label.slice(0, targetCharacters)}...`;\n        calculating[index].label.name = label;\n        if (label === \"...\") {\n          calculating[index].calculating = false;\n        }\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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          //this is causing the issue\n          //change this to label instead of 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 <\n        b.item.values.decimal\n          ? 1\n          : -1\n      );\n      for (let i = 0; i < hamiltonDiff; i++) {\n        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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}\n\ntype PieChartState = {\n  data: Array<any>;\n  calculating: Array<any>;\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      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      this.setState({\n        calculating,\n        ...this.props\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\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 onLayout = (e, index, fontSize, label) => {\n      let width = e.nativeEvent.layout.width;\n      let target =\n        this.props.width - this.props.width * chartWidthPercentage - 84;\n      let calculating = this.state.calculating;\n\n      if (width < target) {\n        calculating[index].calculating = false;\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      } else {\n        if (label.slice(-3) === \"...\") {\n          label = label.slice(0, -3);\n        }\n        if (isNaN(fontSize)) {\n          target = target - fontSize.split(\"p\")[0] * 2;\n        } else {\n          target = target - fontSize * 2;\n        }\n        const numberOfCharacters = label.length;\n        const ratio = target / width;\n        const targetCharacters = Math.floor(ratio * numberOfCharacters);\n        label = `${label.slice(0, targetCharacters)}...`;\n        calculating[index].label.name = label;\n        if (label === \"...\") {\n          calculating[index].calculating = false;\n        }\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 54e60a1a..2ee37c16 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -207,8 +207,7 @@ class PieChart extends AbstractChart { decimal = 0; } wholeTotal += whole; - //this is causing the issue - //change this to label instead of this.props.accessor? + //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, From 51becf0f07e0c53ef7b8c0a2f362a1014cfc946e Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Wed, 7 Jul 2021 13:55:43 -0500 Subject: [PATCH 60/86] added check to see if fontsize is defined --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 5 ++++- src/PieChart.tsx | 3 +++ 3 files changed, 8 insertions(+), 2 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 240cac04..ad8c0a92 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAiBhB,KAAK,KAAA;IAcjB,MAAM;CA0RP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAiBhB,KAAK,KAAA;IAcjB,MAAM;CA6RP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 06bb972c..d5096243 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -106,6 +106,9 @@ var PieChart = /** @class */ (function(_super) { label = label.slice(0, -3); } if (isNaN(fontSize)) { + if (!fontSize) { + fontSize = "12px"; + } target = target - fontSize.split("p")[0] * 2; } else { target = target - fontSize * 2; @@ -351,4 +354,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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}\n\ntype PieChartState = {\n  data: Array<any>;\n  calculating: Array<any>;\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      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      this.setState({\n        calculating,\n        ...this.props\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\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 onLayout = (e, index, fontSize, label) => {\n      let width = e.nativeEvent.layout.width;\n      let target =\n        this.props.width - this.props.width * chartWidthPercentage - 84;\n      let calculating = this.state.calculating;\n\n      if (width < target) {\n        calculating[index].calculating = false;\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      } else {\n        if (label.slice(-3) === \"...\") {\n          label = label.slice(0, -3);\n        }\n        if (isNaN(fontSize)) {\n          target = target - fontSize.split(\"p\")[0] * 2;\n        } else {\n          target = target - fontSize * 2;\n        }\n        const numberOfCharacters = label.length;\n        const ratio = target / width;\n        const targetCharacters = Math.floor(ratio * numberOfCharacters);\n        label = `${label.slice(0, targetCharacters)}...`;\n        calculating[index].label.name = label;\n        if (label === \"...\") {\n          calculating[index].calculating = false;\n        }\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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}\n\ntype PieChartState = {\n  data: Array<any>;\n  calculating: Array<any>;\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      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      this.setState({\n        calculating,\n        ...this.props\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\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 onLayout = (e, index, fontSize, label) => {\n      let width = e.nativeEvent.layout.width;\n      let target =\n        this.props.width - this.props.width * chartWidthPercentage - 84;\n      let calculating = this.state.calculating;\n\n      if (width < target) {\n        calculating[index].calculating = false;\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      } else {\n        if (label.slice(-3) === \"...\") {\n          label = label.slice(0, -3);\n        }\n        if (isNaN(fontSize)) {\n          if (!fontSize) {\n            fontSize = '12px'\n          }\n          target = target - fontSize.split(\"p\")[0] * 2;\n        } else {\n          target = target - fontSize * 2;\n        }\n        const numberOfCharacters = label.length;\n        const ratio = target / width;\n        const targetCharacters = Math.floor(ratio * numberOfCharacters);\n        label = `${label.slice(0, targetCharacters)}...`;\n        calculating[index].label.name = label;\n        if (label === \"...\") {\n          calculating[index].calculating = false;\n        }\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 2ee37c16..8f7d8462 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -85,6 +85,9 @@ class PieChart extends AbstractChart { label = label.slice(0, -3); } if (isNaN(fontSize)) { + if (!fontSize) { + fontSize = "12px"; + } target = target - fontSize.split("p")[0] * 2; } else { target = target - fontSize * 2; From 6c62383e818e0d148c9586c9fd60e35c0e3f3f8c Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Thu, 8 Jul 2021 10:14:03 -0500 Subject: [PATCH 61/86] added remove legedn prefix --- dist/PieChart.d.ts | 1 + dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 14 ++++++++++++-- src/PieChart.tsx | 13 ++++++++++++- 4 files changed, 26 insertions(+), 4 deletions(-) diff --git a/dist/PieChart.d.ts b/dist/PieChart.d.ts index 25dadc19..9b278538 100644 --- a/dist/PieChart.d.ts +++ b/dist/PieChart.d.ts @@ -13,6 +13,7 @@ export interface PieChartProps extends AbstractChartProps { style?: Partial; avoidFalseZero?: boolean; chartWidthPercentage: number; + showLabelPrefix: boolean; } declare type PieChartState = { data: Array; diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index ad8c0a92..ae0ea8f2 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC9B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAiBhB,KAAK,KAAA;IAcjB,MAAM;CA6RP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC1B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAiBhB,KAAK,KAAA;IAcjB,MAAM;CAuSP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index d5096243..2ff1eb20 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -244,7 +244,11 @@ var PieChart = /** @class */ (function(_super) { var slices = chart.curves.map(function(c, i) { var value; 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) { @@ -287,6 +291,9 @@ var PieChart = /** @class */ (function(_super) { ((_this.props.height * 0.8) / _this.props.data.length) * i + 12 } + onPress={c.item.action} + //@ts-ignore + onClick={c.item.action} /> ) : null} {hasLegend ? ( @@ -301,6 +308,9 @@ var PieChart = /** @class */ (function(_super) { ((_this.props.height * 0.8) / _this.props.data.length) * i + 12 * 2 } + onPress={c.item.action} + //@ts-ignore + onClick={c.item.action} > {value + " " + _this.state.calculating[c.index].label.name} @@ -354,4 +364,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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}\n\ntype PieChartState = {\n  data: Array<any>;\n  calculating: Array<any>;\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      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      this.setState({\n        calculating,\n        ...this.props\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\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 onLayout = (e, index, fontSize, label) => {\n      let width = e.nativeEvent.layout.width;\n      let target =\n        this.props.width - this.props.width * chartWidthPercentage - 84;\n      let calculating = this.state.calculating;\n\n      if (width < target) {\n        calculating[index].calculating = false;\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      } else {\n        if (label.slice(-3) === \"...\") {\n          label = label.slice(0, -3);\n        }\n        if (isNaN(fontSize)) {\n          if (!fontSize) {\n            fontSize = '12px'\n          }\n          target = target - fontSize.split(\"p\")[0] * 2;\n        } else {\n          target = target - fontSize * 2;\n        }\n        const numberOfCharacters = label.length;\n        const ratio = target / width;\n        const targetCharacters = Math.floor(ratio * numberOfCharacters);\n        label = `${label.slice(0, targetCharacters)}...`;\n        calculating[index].label.name = label;\n        if (label === \"...\") {\n          calculating[index].calculating = false;\n        }\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.map((c, i) => {\n      let value: string;\n\n      if (absolute) {\n        value = c.item[this.props.accessor];\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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.data.length) * i +\n                12\n              }\n            />\n          ) : null}\n          {hasLegend ? (\n            <Text\n              fill={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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}\n\ntype PieChartState = {\n  data: Array<any>;\n  calculating: Array<any>;\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      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      this.setState({\n        calculating,\n        ...this.props\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\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 onLayout = (e, index, fontSize, label) => {\n      let width = e.nativeEvent.layout.width;\n      let target =\n        this.props.width - this.props.width * chartWidthPercentage - 84;\n      let calculating = this.state.calculating;\n\n      if (width < target) {\n        calculating[index].calculating = false;\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      } else {\n        if (label.slice(-3) === \"...\") {\n          label = label.slice(0, -3);\n        }\n        if (isNaN(fontSize)) {\n          if (!fontSize) {\n            fontSize = \"12px\";\n          }\n          target = target - fontSize.split(\"p\")[0] * 2;\n        } else {\n          target = target - fontSize * 2;\n        }\n        const numberOfCharacters = label.length;\n        const ratio = target / width;\n        const targetCharacters = Math.floor(ratio * numberOfCharacters);\n        label = `${label.slice(0, targetCharacters)}...`;\n        calculating[index].label.name = label;\n        if (label === \"...\") {\n          calculating[index].calculating = false;\n        }\n        this.setState({\n          calculating,\n          ...this.state\n        });\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.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={c.item.legendFontColor}\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.props.data.length) * i +\n                12 * 2\n              }\n              onPress={c.item.action}\n              //@ts-ignore\n              onClick={c.item.action}\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 8f7d8462..602a8b22 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -20,6 +20,7 @@ export interface PieChartProps extends AbstractChartProps { style?: Partial; avoidFalseZero?: boolean; chartWidthPercentage: number; + showLabelPrefix: boolean; } type PieChartState = { @@ -234,7 +235,11 @@ class PieChart extends AbstractChart { 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) { @@ -278,6 +283,9 @@ class PieChart extends AbstractChart { ((this.props.height * 0.8) / this.props.data.length) * i + 12 } + onPress={c.item.action} + //@ts-ignore + onClick={c.item.action} /> ) : null} {hasLegend ? ( @@ -292,6 +300,9 @@ class PieChart extends AbstractChart { ((this.props.height * 0.8) / this.props.data.length) * i + 12 * 2 } + onPress={c.item.action} + //@ts-ignore + onClick={c.item.action} > {`${value} ${this.state.calculating[c.index].label.name}`} From 5c1572fcdc4401c934d8cc4807d3dac6e209382a Mon Sep 17 00:00:00 2001 From: Taylor Howard Date: Thu, 8 Jul 2021 18:02:01 -0500 Subject: [PATCH 62/86] made label transparent while calculating --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 8 ++++++-- src/PieChart.tsx | 6 +++++- 3 files changed, 12 insertions(+), 4 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index ae0ea8f2..dd3cf2c3 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC1B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAiBhB,KAAK,KAAA;IAcjB,MAAM;CAuSP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC1B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAiBhB,KAAK,KAAA;IAcjB,MAAM;CAySP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 2ff1eb20..64d927d3 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -298,7 +298,11 @@ var PieChart = /** @class */ (function(_super) { ) : null} {hasLegend ? ( { ) : null} {hasLegend ? ( Date: Fri, 9 Jul 2021 14:17:52 -0500 Subject: [PATCH 63/86] fixed issue with label flashing --- dist/PieChart.d.ts | 2 + dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 115 +++++++++++++++++++++++++++------------ src/PieChart.tsx | 118 ++++++++++++++++++++++++++++------------- 4 files changed, 166 insertions(+), 71 deletions(-) diff --git a/dist/PieChart.d.ts b/dist/PieChart.d.ts index 9b278538..109a8b26 100644 --- a/dist/PieChart.d.ts +++ b/dist/PieChart.d.ts @@ -14,9 +14,11 @@ export interface PieChartProps extends AbstractChartProps { avoidFalseZero?: boolean; chartWidthPercentage: number; showLabelPrefix: boolean; + editor: boolean; } declare type PieChartState = { data: Array; + onLayout: boolean; calculating: Array; }; declare class PieChart extends AbstractChart { diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index dd3cf2c3..a90cc2b3 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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;CAC1B;AAED,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAiBhB,KAAK,KAAA;IAcjB,MAAM;CAySP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAuChB,KAAK,KAAA;IAgBjB,MAAM;CA8SP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 64d927d3..73089185 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -58,14 +58,17 @@ import AbstractChart from "./AbstractChart"; var PieChart = /** @class */ (function(_super) { __extends(PieChart, _super); function PieChart(props) { - var _this = _super.call(this, props) || this; + var _this = this; + console.log("constructor"); + _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 - }); + _this.state = __assign( + __assign({ calculating: calculating, onLayout: true }, props), + { labelData: _this.props.data } + ); return _this; } PieChart.prototype.componentDidUpdate = function(prevProps) { @@ -78,7 +81,50 @@ var PieChart = /** @class */ (function(_super) { for (var i = 0; i < this.props.data.length; i++) { calculating[i] = { label: this.props.data[i], calculating: true }; } - this.setState(__assign({ calculating: calculating }, this.props)); + // this.setState({ + // calculating, + // onLayout: true, + // ...this.props, + // }) + if ( + this.state.calculating.filter(function(i) { + return i.calculating === true; + }).length === 0 && + this.props.width === prevProps.width && + !this.props.editor + ) { + console.log("same", this.state); + this.setState( + __assign( + __assign({ calculating: calculating, onLayout: false }, this.props), + this.state + ) + ); + } else { + console.log( + "this", + this.props.width, + "prev", + prevProps.width, + this.props.width === prevProps.width + ); + console.log( + this.state.calculating.filter(function(i) { + return i.calculating === true; + }) + ); + console.log( + this.state.calculating.filter(function(i) { + return i.calculating === true; + }).length === 0 && + this.props.width !== prevProps.width && + this.props.width === prevProps.width + ); + console.log("diff", this.state); + this.setState( + __assign({ calculating: calculating, onLayout: true }, this.props) + ); + } } }; PieChart.prototype.render = function() { @@ -94,34 +140,37 @@ var PieChart = /** @class */ (function(_super) { _e = _a.avoidFalseZero, avoidFalseZero = _e === void 0 ? false : _e; var onLayout = function(e, index, fontSize, label) { - var width = e.nativeEvent.layout.width; - var target = - _this.props.width - _this.props.width * chartWidthPercentage - 84; - var calculating = _this.state.calculating; - if (width < target) { - calculating[index].calculating = false; - _this.setState(__assign({ calculating: calculating }, _this.state)); - } else { - if (label.slice(-3) === "...") { - label = label.slice(0, -3); - } - if (isNaN(fontSize)) { - if (!fontSize) { - fontSize = "12px"; - } - target = target - fontSize.split("p")[0] * 2; - } else { - target = target - fontSize * 2; - } - var numberOfCharacters = label.length; - var ratio = target / width; - var targetCharacters = Math.floor(ratio * numberOfCharacters); - label = label.slice(0, targetCharacters) + "..."; - calculating[index].label.name = label; - if (label === "...") { + console.log("onlayout", _this.state.onLayout); + if (_this.state.onLayout) { + var width = e.nativeEvent.layout.width; + var target = + _this.props.width - _this.props.width * chartWidthPercentage - 84; + var calculating = _this.state.calculating; + if (width < target) { calculating[index].calculating = false; + _this.setState(__assign({ calculating: calculating }, _this.state)); + } else { + if (label.slice(-3) === "...") { + label = label.slice(0, -3); + } + if (isNaN(fontSize)) { + if (!fontSize) { + fontSize = "12px"; + } + target = target - fontSize.split("p")[0] * 2; + } else { + target = target - fontSize * 2; + } + var numberOfCharacters = label.length; + var ratio = target / width; + var targetCharacters = Math.floor(ratio * numberOfCharacters); + label = label.slice(0, targetCharacters) + "..."; + calculating[index].label.name = label; + if (label === "...") { + calculating[index].calculating = false; + } + _this.setState(__assign({ calculating: calculating }, _this.state)); } - _this.setState(__assign({ calculating: calculating }, _this.state)); } }; var calculations = this.state.calculating.map(function(item, index) { @@ -299,7 +348,7 @@ var PieChart = /** @class */ (function(_super) { {hasLegend ? ( ; + onLayout: boolean; calculating: Array; }; @@ -39,14 +41,52 @@ class PieChart extends AbstractChart { for (let i = 0; i < this.props.data.length; i++) { calculating[i] = { label: this.props.data[i], calculating: true }; } - this.setState({ - calculating, - ...this.props - }); + // this.setState({ + // calculating, + // onLayout: true, + // ...this.props, + // }) + if ( + this.state.calculating.filter(i => i.calculating === true).length === + 0 && + this.props.width === prevProps.width && + !this.props.editor + ) { + console.log("same", this.state); + this.setState({ + calculating, + onLayout: false, + ...this.props, + ...this.state + }); + } else { + console.log( + "this", + this.props.width, + "prev", + prevProps.width, + this.props.width === prevProps.width + ); + console.log(this.state.calculating.filter(i => i.calculating === true)); + console.log( + this.state.calculating.filter(i => i.calculating === true).length === + 0 && + this.props.width !== prevProps.width && + this.props.width === prevProps.width + ); + console.log("diff", this.state); + this.setState({ + calculating, + onLayout: true, + ...this.props + // ...this.state + }); + } } } constructor(props) { + console.log("constructor"); super(props); let calculating = []; for (let i = 0; i < this.props.data.length; i++) { @@ -55,6 +95,7 @@ class PieChart extends AbstractChart { this.state = { calculating, + onLayout: true, ...props, labelData: this.props.data }; @@ -70,41 +111,44 @@ class PieChart extends AbstractChart { } = this.props; const onLayout = (e, index, fontSize, label) => { - let width = e.nativeEvent.layout.width; - let target = - this.props.width - this.props.width * chartWidthPercentage - 84; - let calculating = this.state.calculating; + console.log("onlayout", this.state.onLayout); + if (this.state.onLayout) { + let width = e.nativeEvent.layout.width; + let target = + this.props.width - this.props.width * chartWidthPercentage - 84; + let calculating = this.state.calculating; - if (width < target) { - calculating[index].calculating = false; - this.setState({ - calculating, - ...this.state - }); - } else { - if (label.slice(-3) === "...") { - label = label.slice(0, -3); - } - if (isNaN(fontSize)) { - if (!fontSize) { - fontSize = "12px"; - } - target = target - fontSize.split("p")[0] * 2; - } else { - target = target - fontSize * 2; - } - const numberOfCharacters = label.length; - const ratio = target / width; - const targetCharacters = Math.floor(ratio * numberOfCharacters); - label = `${label.slice(0, targetCharacters)}...`; - calculating[index].label.name = label; - if (label === "...") { + if (width < target) { calculating[index].calculating = false; + this.setState({ + calculating, + ...this.state + }); + } else { + if (label.slice(-3) === "...") { + label = label.slice(0, -3); + } + if (isNaN(fontSize)) { + if (!fontSize) { + fontSize = "12px"; + } + target = target - fontSize.split("p")[0] * 2; + } else { + target = target - fontSize * 2; + } + const numberOfCharacters = label.length; + const ratio = target / width; + const targetCharacters = Math.floor(ratio * numberOfCharacters); + label = `${label.slice(0, targetCharacters)}...`; + calculating[index].label.name = label; + if (label === "...") { + calculating[index].calculating = false; + } + this.setState({ + calculating, + ...this.state + }); } - this.setState({ - calculating, - ...this.state - }); } }; @@ -291,7 +335,7 @@ class PieChart extends AbstractChart { {hasLegend ? ( Date: Fri, 9 Jul 2021 14:43:55 -0500 Subject: [PATCH 64/86] removed console logs --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 33 ++------------------------------- src/PieChart.tsx | 23 ----------------------- 3 files changed, 3 insertions(+), 55 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index a90cc2b3..76ee41b7 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAuChB,KAAK,KAAA;IAgBjB,MAAM;CA8SP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAkChB,KAAK,KAAA;IAejB,MAAM;CA6SP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 73089185..221c48b0 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -58,9 +58,7 @@ import AbstractChart from "./AbstractChart"; var PieChart = /** @class */ (function(_super) { __extends(PieChart, _super); function PieChart(props) { - var _this = this; - console.log("constructor"); - _this = _super.call(this, props) || this; + 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 }; @@ -81,11 +79,6 @@ var PieChart = /** @class */ (function(_super) { for (var i = 0; i < this.props.data.length; i++) { calculating[i] = { label: this.props.data[i], calculating: true }; } - // this.setState({ - // calculating, - // onLayout: true, - // ...this.props, - // }) if ( this.state.calculating.filter(function(i) { return i.calculating === true; @@ -93,7 +86,6 @@ var PieChart = /** @class */ (function(_super) { this.props.width === prevProps.width && !this.props.editor ) { - console.log("same", this.state); this.setState( __assign( __assign({ calculating: calculating, onLayout: false }, this.props), @@ -101,26 +93,6 @@ var PieChart = /** @class */ (function(_super) { ) ); } else { - console.log( - "this", - this.props.width, - "prev", - prevProps.width, - this.props.width === prevProps.width - ); - console.log( - this.state.calculating.filter(function(i) { - return i.calculating === true; - }) - ); - console.log( - this.state.calculating.filter(function(i) { - return i.calculating === true; - }).length === 0 && - this.props.width !== prevProps.width && - this.props.width === prevProps.width - ); - console.log("diff", this.state); this.setState( __assign({ calculating: calculating, onLayout: true }, this.props) ); @@ -140,7 +112,6 @@ var PieChart = /** @class */ (function(_super) { _e = _a.avoidFalseZero, avoidFalseZero = _e === void 0 ? false : _e; var onLayout = function(e, index, fontSize, label) { - console.log("onlayout", _this.state.onLayout); if (_this.state.onLayout) { var width = e.nativeEvent.layout.width; var target = @@ -417,4 +388,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\n  calculating: Array<any>;\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      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      // this.setState({\n      //   calculating,\n      //   onLayout: true,\n      //   ...this.props,\n      // })\n      if (this.state.calculating.filter(i => i.calculating === true).length === 0 && this.props.width === prevProps.width && !this.props.editor) {\n        console.log('same', this.state)\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state,\n        })\n      } else {\n        console.log('this', this.props.width, 'prev', prevProps.width, this.props.width === prevProps.width)\n        console.log(this.state.calculating.filter(i => i.calculating === true))\n        console.log((this.state.calculating.filter(i => i.calculating === true).length === 0) && this.props.width !== prevProps.width && this.props.width === prevProps.width)\n        console.log('diff', this.state)\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props,\n          // ...this.state\n        })\n      }\n      \n    }\n  }\n\n  constructor(props) {\n    console.log('constructor')\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\n    this.state = {\n      calculating,\n      onLayout: true,\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 onLayout = (e, index, fontSize, label) => {\n      console.log('onlayout', this.state.onLayout)\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n  \n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.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={\n                this.state.calculating[i].calculating && !this.props.editor\n                  ? \"transparent\"\n                  : c.item.legendFontColor\n              }\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.props.data.length) * i +\n                12 * 2\n              }\n              onPress={c.item.action}\n              //@ts-ignore\n              onClick={c.item.action}\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\n  calculating: Array<any>;\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      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        !this.props.editor\n      ) \n      {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props,\n          // ...this.state\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\n    this.state = {\n      calculating,\n      onLayout: true,\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 onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.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={\n                this.state.calculating[i].calculating && !this.props.editor\n                  ? \"transparent\"\n                  : c.item.legendFontColor\n              }\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.props.data.length) * i +\n                12 * 2\n              }\n              onPress={c.item.action}\n              //@ts-ignore\n              onClick={c.item.action}\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index edd9d3f4..11b284c9 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -41,18 +41,12 @@ class PieChart extends AbstractChart { for (let i = 0; i < this.props.data.length; i++) { calculating[i] = { label: this.props.data[i], calculating: true }; } - // this.setState({ - // calculating, - // onLayout: true, - // ...this.props, - // }) if ( this.state.calculating.filter(i => i.calculating === true).length === 0 && this.props.width === prevProps.width && !this.props.editor ) { - console.log("same", this.state); this.setState({ calculating, onLayout: false, @@ -60,21 +54,6 @@ class PieChart extends AbstractChart { ...this.state }); } else { - console.log( - "this", - this.props.width, - "prev", - prevProps.width, - this.props.width === prevProps.width - ); - console.log(this.state.calculating.filter(i => i.calculating === true)); - console.log( - this.state.calculating.filter(i => i.calculating === true).length === - 0 && - this.props.width !== prevProps.width && - this.props.width === prevProps.width - ); - console.log("diff", this.state); this.setState({ calculating, onLayout: true, @@ -86,7 +65,6 @@ class PieChart extends AbstractChart { } constructor(props) { - console.log("constructor"); super(props); let calculating = []; for (let i = 0; i < this.props.data.length; i++) { @@ -111,7 +89,6 @@ class PieChart extends AbstractChart { } = this.props; const onLayout = (e, index, fontSize, label) => { - console.log("onlayout", this.state.onLayout); if (this.state.onLayout) { let width = e.nativeEvent.layout.width; let target = From 4224b6f53c45f09c4195ea1d16822d08a73e91f0 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Tue, 13 Jul 2021 14:37:49 -0500 Subject: [PATCH 65/86] fixed issue where data didn't refresh --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 21 +++++++++++++++++---- src/PieChart.tsx | 14 ++++++++++++-- 3 files changed, 30 insertions(+), 7 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 76ee41b7..3e575196 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAEF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAkChB,KAAK,KAAA;IAejB,MAAM;CA6SP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAMF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAejB,MAAM;CA6SP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 221c48b0..eb0a751b 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -55,6 +55,14 @@ 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"; +var compareArrays = function(a, b) { + return ( + a.length === b.length && + a.every(function(value, index) { + return JSON.stringify(value) === JSON.stringify(b[index]); + }) + ); +}; var PieChart = /** @class */ (function(_super) { __extends(PieChart, _super); function PieChart(props) { @@ -73,7 +81,7 @@ var PieChart = /** @class */ (function(_super) { if ( this.props.width !== prevProps.width || this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || - this.props.data != prevProps.data + !compareArrays(this.props.data, prevProps.data) ) { var calculating = []; for (var i = 0; i < this.props.data.length; i++) { @@ -84,7 +92,8 @@ var PieChart = /** @class */ (function(_super) { return i.calculating === true; }).length === 0 && this.props.width === prevProps.width && - !this.props.editor + !this.props.editor && + compareArrays(this.props.data, prevProps.data) ) { this.setState( __assign( @@ -94,7 +103,11 @@ var PieChart = /** @class */ (function(_super) { ); } else { this.setState( - __assign({ calculating: calculating, onLayout: true }, this.props) + __assign( + { calculating: calculating, onLayout: true }, + this.props + // ...this.state + ) ); } } @@ -388,4 +401,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\n  calculating: Array<any>;\n};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      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        !this.props.editor\n      ) \n      {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props,\n          // ...this.state\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\n    this.state = {\n      calculating,\n      onLayout: true,\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 onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.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={\n                this.state.calculating[i].calculating && !this.props.editor\n                  ? \"transparent\"\n                  : c.item.legendFontColor\n              }\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.props.data.length) * i +\n                12 * 2\n              }\n              onPress={c.item.action}\n              //@ts-ignore\n              onClick={c.item.action}\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\n  calculating: Array<any>;\n};\n\nconst compareArrays = (a, b) => {\n  return a.length === b.length && a.every((value, index) => JSON.stringify(value) === JSON.stringify(b[index]))\n}\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    \n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      !compareArrays(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        !this.props.editor &&\n        compareArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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\n    this.state = {\n      calculating,\n      onLayout: true,\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 onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.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={\n                this.state.calculating[i].calculating && !this.props.editor\n                  ? \"transparent\"\n                  : c.item.legendFontColor\n              }\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.props.data.length) * i +\n                12 * 2\n              }\n              onPress={c.item.action}\n              //@ts-ignore\n              onClick={c.item.action}\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 11b284c9..c3c28f98 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -30,12 +30,21 @@ type PieChartState = { calculating: Array; }; +const compareArrays = (a, b) => { + return ( + a.length === b.length && + a.every( + (value, index) => JSON.stringify(value) === JSON.stringify(b[index]) + ) + ); +}; + class PieChart extends AbstractChart { componentDidUpdate(prevProps) { if ( this.props.width !== prevProps.width || this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || - this.props.data != prevProps.data + !compareArrays(this.props.data, prevProps.data) ) { let calculating = []; for (let i = 0; i < this.props.data.length; i++) { @@ -45,7 +54,8 @@ class PieChart extends AbstractChart { this.state.calculating.filter(i => i.calculating === true).length === 0 && this.props.width === prevProps.width && - !this.props.editor + !this.props.editor && + compareArrays(this.props.data, prevProps.data) ) { this.setState({ calculating, From 3251f50efad1f16caf01972543f5435df33215a0 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Tue, 13 Jul 2021 18:01:16 -0500 Subject: [PATCH 66/86] fixed issue with percentages flashing --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 21 ++++++++++++++++----- src/PieChart.tsx | 31 +++++++++++++++++++++++++------ 3 files changed, 42 insertions(+), 12 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 3e575196..66e798eb 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAMF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAejB,MAAM;CA6SP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAgCF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAkChB,KAAK,KAAA;IAejB,MAAM;CA6SP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index eb0a751b..da6b4fba 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -55,11 +55,22 @@ 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"; -var compareArrays = function(a, b) { +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) { - return JSON.stringify(value) === JSON.stringify(b[index]); + var aCopy = __assign(__assign({}, value), { values: null }); + var bCopy = __assign(__assign({}, b[index]), { values: null }); + return JSON.stringify(aCopy) === JSON.stringify(bCopy); }) ); }; @@ -81,7 +92,7 @@ var PieChart = /** @class */ (function(_super) { if ( this.props.width !== prevProps.width || this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || - !compareArrays(this.props.data, prevProps.data) + !compareDataArrays(this.props.data, prevProps.data) ) { var calculating = []; for (var i = 0; i < this.props.data.length; i++) { @@ -93,7 +104,7 @@ var PieChart = /** @class */ (function(_super) { }).length === 0 && this.props.width === prevProps.width && !this.props.editor && - compareArrays(this.props.data, prevProps.data) + compareDataArrays(this.props.data, prevProps.data) ) { this.setState( __assign( @@ -401,4 +412,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\n  calculating: Array<any>;\n};\n\nconst compareArrays = (a, b) => {\n  return a.length === b.length && a.every((value, index) => JSON.stringify(value) === JSON.stringify(b[index]))\n}\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    \n    if (\n      this.props.width !== prevProps.width ||\n      this.props.chartWidthPercentage !== prevProps.chartWidthPercentage ||\n      !compareArrays(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        !this.props.editor &&\n        compareArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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\n    this.state = {\n      calculating,\n      onLayout: true,\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 onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.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={\n                this.state.calculating[i].calculating && !this.props.editor\n                  ? \"transparent\"\n                  : c.item.legendFontColor\n              }\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.props.data.length) * i +\n                12 * 2\n              }\n              onPress={c.item.action}\n              //@ts-ignore\n              onClick={c.item.action}\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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(\n      (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};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\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        !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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\n    this.state = {\n      calculating,\n      onLayout: true,\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 onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.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={\n                this.state.calculating[i].calculating && !this.props.editor\n                  ? \"transparent\"\n                  : c.item.legendFontColor\n              }\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.props.data.length) * i +\n                12 * 2\n              }\n              onPress={c.item.action}\n              //@ts-ignore\n              onClick={c.item.action}\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index c3c28f98..09587589 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -30,12 +30,31 @@ type PieChartState = { calculating: Array; }; -const compareArrays = (a, b) => { +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) => JSON.stringify(value) === JSON.stringify(b[index]) - ) + a.every((value, index) => { + const aCopy = { + ...value, + values: null + }; + const bCopy = { + ...b[index], + values: null + }; + return JSON.stringify(aCopy) === JSON.stringify(bCopy); + }) ); }; @@ -44,7 +63,7 @@ class PieChart extends AbstractChart { if ( this.props.width !== prevProps.width || this.props.chartWidthPercentage !== prevProps.chartWidthPercentage || - !compareArrays(this.props.data, prevProps.data) + !compareDataArrays(this.props.data, prevProps.data) ) { let calculating = []; for (let i = 0; i < this.props.data.length; i++) { @@ -55,7 +74,7 @@ class PieChart extends AbstractChart { 0 && this.props.width === prevProps.width && !this.props.editor && - compareArrays(this.props.data, prevProps.data) + compareDataArrays(this.props.data, prevProps.data) ) { this.setState({ calculating, From b714db62925edc696fa85c8339576f5045a1a891 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Thu, 15 Jul 2021 14:29:08 -0500 Subject: [PATCH 67/86] reworked truncation to fix flashing issues --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 27 +++++++++++++++++---------- src/PieChart.tsx | 27 +++++++++++++++++---------- 3 files changed, 35 insertions(+), 21 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 66e798eb..5ae712d9 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AAgCF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAkChB,KAAK,KAAA;IAejB,MAAM;CA6SP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CAkTP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index da6b4fba..e9cfee3f 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -91,6 +91,7 @@ var PieChart = /** @class */ (function(_super) { 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) ) { @@ -176,6 +177,12 @@ var PieChart = /** @class */ (function(_super) { 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 ( - {value + " " + _this.state.calculating[c.index].label.name} + {value + " " + c.item.name} ) : null} @@ -412,4 +419,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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(\n      (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};\n\nclass PieChart extends AbstractChart<PieChartProps, PieChartState> {\n  componentDidUpdate(prevProps) {\n    if (\n      this.props.width !== prevProps.width ||\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        !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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\n    this.state = {\n      calculating,\n      onLayout: true,\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 onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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 (!isObject(value)) {\n          return (\n            <View\n              key={index}\n              style={{ alignSelf: \"flex-start\", position: \"absolute\" }}\n              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.props.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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\n          }\n          if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) {\n            value = \"<1%\";\n          } else {\n            value = percentage + \"%\";\n          }\n        }\n      }\n\n      return (\n        <G key={Math.random()}>\n          <Path\n            d={c.sector.path.print()}\n            fill={c.item.color}\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={8}\n              ry={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.props.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={\n                this.state.calculating[i].calculating && !this.props.editor\n                  ? \"transparent\"\n                  : c.item.legendFontColor\n              }\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.props.data.length) * i +\n                12 * 2\n              }\n              onPress={c.item.action}\n              //@ts-ignore\n              onClick={c.item.action}\n            >\n              {`${value} ${this.state.calculating[c.index].label.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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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 onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\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] ? c.item.legendFontColor : 'transparent'\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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 09587589..b17a3182 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -62,6 +62,7 @@ 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) ) { @@ -99,7 +100,6 @@ class PieChart extends AbstractChart { for (let i = 0; i < this.props.data.length; i++) { calculating[i] = { label: this.props.data[i], calculating: true }; } - this.state = { calculating, onLayout: true, @@ -167,6 +167,12 @@ class PieChart extends AbstractChart { 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 ( { } }); - const total = this.props.data.reduce((sum, item) => { + const total = this.state.data.reduce((sum, item) => { if (isObject(item[this.props.accessor])) { return sum + item[this.props.accessor].whole; } else { @@ -308,11 +314,16 @@ class PieChart extends AbstractChart { } } + let textColor = this.state.calculating[i] + ? c.item.legendFontColor + : "transparent"; + return ( { } y={ -(this.props.height / 2.5) + - ((this.props.height * 0.8) / this.props.data.length) * i + + ((this.props.height * 0.8) / this.state.data.length) * i + 12 } onPress={c.item.action} @@ -340,25 +351,21 @@ class PieChart extends AbstractChart { ) : null} {hasLegend ? ( - {`${value} ${this.state.calculating[c.index].label.name}`} + {`${value} ${c.item.name}`} ) : null} From 5c660fb7d624d30ace9cd6177944ae0bbe693803 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Thu, 15 Jul 2021 17:13:12 -0500 Subject: [PATCH 68/86] fixed issue with percentage ordering when rounded --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 7 ++++++- src/PieChart.tsx | 6 ++++++ 3 files changed, 13 insertions(+), 2 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 5ae712d9..224646d0 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CAkTP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CAwTP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index e9cfee3f..31e082b9 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -292,6 +292,11 @@ var PieChart = /** @class */ (function(_super) { uppedIndices.push(sortedCurves[i].item.values.index); } } + if (!absolute) { + chart.curves = chart.curves.sort(function(a, b) { + return a.item.values.whole > b.item.values.whole; + }); + } var slices = chart.curves.map(function(c, i) { var value; if (absolute) { @@ -419,4 +424,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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 onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\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] ? c.item.legendFontColor : 'transparent'\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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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 onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    if(!absolute) {\n      chart.curves = chart.curves.sort((a, b) => a.item.values.whole > b.item.values.whole)\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index b17a3182..93b79668 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -287,6 +287,12 @@ class PieChart extends AbstractChart { } } + if (!absolute) { + chart.curves = chart.curves.sort( + (a, b) => a.item.values.whole > b.item.values.whole + ); + } + const slices = chart.curves.map((c, i) => { let value: string; From b56f07de7e178bf8205631b5c441883f4f88320d Mon Sep 17 00:00:00 2001 From: TDH55 Date: Fri, 16 Jul 2021 10:58:18 -0500 Subject: [PATCH 69/86] ran yarn build --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 6 ++++-- package.json | 3 ++- src/PieChart.tsx | 5 ++++- 4 files changed, 11 insertions(+), 5 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 224646d0..c1ab398c 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CAwTP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAQ,SAAS,EAAsB,MAAM,cAAc,CAAC;AAInE,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CA4TP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 31e082b9..5de5a8a7 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -104,7 +104,7 @@ var PieChart = /** @class */ (function(_super) { return i.calculating === true; }).length === 0 && this.props.width === prevProps.width && - !this.props.editor && + // !this.props.editor && compareDataArrays(this.props.data, prevProps.data) ) { this.setState( @@ -136,6 +136,7 @@ var PieChart = /** @class */ (function(_super) { hasLegend = _d === void 0 ? true : _d, _e = _a.avoidFalseZero, avoidFalseZero = _e === void 0 ? false : _e; + //TODO: move setState out of onlayout since it runs in a for loop var onLayout = function(e, index, fontSize, label) { if (_this.state.onLayout) { var width = e.nativeEvent.layout.width; @@ -177,6 +178,7 @@ var PieChart = /** @class */ (function(_super) { legendFontWeight = _a.legendFontWeight, value = _a.value; if (item.calculating && _this.props.hasLegend) { + console.log("item", item, "index", index); if (_this.props.absolute === false) { value = "55%"; } @@ -424,4 +426,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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 onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    if(!absolute) {\n      chart.curves = chart.curves.sort((a, b) => a.item.values.whole > b.item.values.whole)\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\nimport clone from 'rfdc/default'\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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        console.log('item', item, 'index', index)\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    if (!absolute) {\n      chart.curves = chart.curves.sort(\n        (a, b) => a.item.values.whole > b.item.values.whole\n      );\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/package.json b/package.json index 9d3571a7..e1821da9 100644 --- a/package.json +++ b/package.json @@ -54,7 +54,8 @@ "dependencies": { "lodash": "^4.17.13", "paths-js": "^0.4.10", - "point-in-polygon": "^1.0.1" + "point-in-polygon": "^1.0.1", + "rfdc": "^1.3.0" }, "husky": { "hooks": { diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 93b79668..0beaef41 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -3,6 +3,7 @@ import Pie from "paths-js/pie"; 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 clone from "rfdc/default"; import AbstractChart, { AbstractChartProps } from "./AbstractChart"; // import TextWidthFinder from "./TextWidthFinder"; @@ -74,7 +75,7 @@ class PieChart extends AbstractChart { this.state.calculating.filter(i => i.calculating === true).length === 0 && this.props.width === prevProps.width && - !this.props.editor && + // !this.props.editor && compareDataArrays(this.props.data, prevProps.data) ) { this.setState({ @@ -117,6 +118,7 @@ class PieChart extends AbstractChart { avoidFalseZero = false } = this.props; + //TODO: move setState out of onlayout since it runs in a for loop const onLayout = (e, index, fontSize, label) => { if (this.state.onLayout) { let width = e.nativeEvent.layout.width; @@ -167,6 +169,7 @@ class PieChart extends AbstractChart { value } = item.label; if (item.calculating && this.props.hasLegend) { + console.log("item", item, "index", index); if (this.props.absolute === false) { value = "55%"; } From 49cc449676a84f04f9d3121498c4115b8d7f885c Mon Sep 17 00:00:00 2001 From: TDH55 Date: Fri, 16 Jul 2021 10:59:22 -0500 Subject: [PATCH 70/86] removed unneded dependency --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 2 +- package.json | 3 +-- src/PieChart.tsx | 1 - 4 files changed, 3 insertions(+), 5 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index c1ab398c..0e66f43c 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAQ,SAAS,EAAsB,MAAM,cAAc,CAAC;AAInE,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CA4TP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CA4TP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 5de5a8a7..cb34c0c3 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -426,4 +426,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\nimport clone from 'rfdc/default'\n\nimport AbstractChart, { AbstractChartProps } from \"./AbstractChart\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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        console.log('item', item, 'index', index)\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    if (!absolute) {\n      chart.curves = chart.curves.sort(\n        (a, b) => a.item.values.whole > b.item.values.whole\n      );\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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        console.log(\"item\", item, \"index\", index);\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    if (!absolute) {\n      chart.curves = chart.curves.sort(\n        (a, b) => a.item.values.whole > b.item.values.whole\n      );\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/package.json b/package.json index e1821da9..9d3571a7 100644 --- a/package.json +++ b/package.json @@ -54,8 +54,7 @@ "dependencies": { "lodash": "^4.17.13", "paths-js": "^0.4.10", - "point-in-polygon": "^1.0.1", - "rfdc": "^1.3.0" + "point-in-polygon": "^1.0.1" }, "husky": { "hooks": { diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 0beaef41..68775a17 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -3,7 +3,6 @@ import Pie from "paths-js/pie"; 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 clone from "rfdc/default"; import AbstractChart, { AbstractChartProps } from "./AbstractChart"; // import TextWidthFinder from "./TextWidthFinder"; From 94ed7398b65c336f86156b000cfc472201d8a63b Mon Sep 17 00:00:00 2001 From: TDH55 Date: Fri, 16 Jul 2021 12:30:52 -0500 Subject: [PATCH 71/86] remove console.log --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 3 +-- src/PieChart.tsx | 1 - 3 files changed, 2 insertions(+), 4 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 0e66f43c..f5fa15d3 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CA4TP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CA2TP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index cb34c0c3..db10ce73 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -178,7 +178,6 @@ var PieChart = /** @class */ (function(_super) { legendFontWeight = _a.legendFontWeight, value = _a.value; if (item.calculating && _this.props.hasLegend) { - console.log("item", item, "index", index); if (_this.props.absolute === false) { value = "55%"; } @@ -426,4 +425,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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        console.log(\"item\", item, \"index\", index);\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    if (!absolute) {\n      chart.curves = chart.curves.sort(\n        (a, b) => a.item.values.whole > b.item.values.whole\n      );\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    if (!absolute) {\n      chart.curves = chart.curves.sort(\n        (a, b) => a.item.values.whole > b.item.values.whole\n      );\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 68775a17..2461f696 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -168,7 +168,6 @@ class PieChart extends AbstractChart { value } = item.label; if (item.calculating && this.props.hasLegend) { - console.log("item", item, "index", index); if (this.props.absolute === false) { value = "55%"; } From da775b2f5a0b404c6764853dfa2690135998fd76 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Tue, 20 Jul 2021 17:09:10 -0500 Subject: [PATCH 72/86] fixed sorting when percentages round --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 13 +++++++++++-- src/PieChart.tsx | 8 +++++++- 3 files changed, 19 insertions(+), 4 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index f5fa15d3..51c221e6 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CA2TP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CAiUP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index db10ce73..17c58ac7 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -289,8 +289,17 @@ var PieChart = /** @class */ (function(_super) { var sortedCurves = __spreadArrays(chart.curves).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.reverse().some(function(item) { + if (item.item.values.whole === uppedVal) { + uppedIndices.push(item.item.values.index); + return true; + } + }); + }; for (var i = 0; i < hamiltonDiff; i++) { - uppedIndices.push(sortedCurves[i].item.values.index); + _loop_1(i); } } if (!absolute) { @@ -425,4 +434,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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        uppedIndices.push(sortedCurves[i].item.values.index);\n      }\n    }\n\n    if (!absolute) {\n      chart.curves = chart.curves.sort(\n        (a, b) => a.item.values.whole > b.item.values.whole\n      );\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.reverse().some(item => {\n          if (item.item.values.whole === uppedVal) {\n            uppedIndices.push(item.item.values.index)\n            return true\n          }\n        })\n      }\n    }\n\n    if (!absolute) {\n      chart.curves = chart.curves.sort(\n        (a, b) => a.item.values.whole > b.item.values.whole\n      );\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 2461f696..6a52c6e1 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -284,7 +284,13 @@ class PieChart extends AbstractChart { a.item.values.decimal < b.item.values.decimal ? 1 : -1 ); for (let i = 0; i < hamiltonDiff; i++) { - uppedIndices.push(sortedCurves[i].item.values.index); + let uppedVal = sortedCurves[i].item.values.whole; + sortedCurves.reverse().some(item => { + if (item.item.values.whole === uppedVal) { + uppedIndices.push(item.item.values.index); + return true; + } + }); } } From e60f713e829c0cb4f145590c9d083a5e8e2e0809 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Wed, 21 Jul 2021 14:53:30 -0500 Subject: [PATCH 73/86] fixed sorting when percentages round --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 24 ++++++++++++++++-------- src/PieChart.tsx | 24 +++++++++++++++++------- 3 files changed, 34 insertions(+), 16 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 51c221e6..ed919b87 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CAiUP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CAuUP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 17c58ac7..98031508 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -291,9 +291,10 @@ var PieChart = /** @class */ (function(_super) { }); var _loop_1 = function(i) { var uppedVal = sortedCurves[i].item.values.whole; - sortedCurves.reverse().some(function(item) { + 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; } }); @@ -302,12 +303,19 @@ var PieChart = /** @class */ (function(_super) { _loop_1(i); } } + var chartCurvesSorted = __spreadArrays(chart.curves).filter(function(item) { + return item.item.otherSlice !== true; + }); + var otherSlice = __spreadArrays(chart.curves).find(function(item) { + return item.item.otherSlice === true; + }); if (!absolute) { - chart.curves = chart.curves.sort(function(a, b) { - return a.item.values.whole > b.item.values.whole; + chartCurvesSorted = chartCurvesSorted.sort(function(a, b) { + return a.item.values.whole < b.item.values.whole ? 1 : -1; }); } - var slices = chart.curves.map(function(c, i) { + chartCurvesSorted.push(otherSlice); + var slices = chartCurvesSorted.map(function(c, i) { var value; if (absolute) { if (_this.props.showLabelPrefix) { @@ -322,9 +330,9 @@ var PieChart = /** @class */ (function(_super) { } else { var item = c.item.values; var percentage = item.whole; - if (uppedIndices.includes(item.index)) { - percentage += 1; - } + // if (uppedIndices.includes(item.index)) { + // percentage += 1; + // } if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) { value = "<1%"; } else { @@ -434,4 +442,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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.reverse().some(item => {\n          if (item.item.values.whole === uppedVal) {\n            uppedIndices.push(item.item.values.index)\n            return true\n          }\n        })\n      }\n    }\n\n    if (!absolute) {\n      chart.curves = chart.curves.sort(\n        (a, b) => a.item.values.whole > b.item.values.whole\n      );\n    }\n\n    const slices = chart.curves.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          if (uppedIndices.includes(item.index)) {\n            percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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((item) => item.item.otherSlice !== true)\n    let otherSlice = [...chart.curves].find((item) => item.item.otherSlice === true)\n\n    if (!absolute) {\n      chartCurvesSorted = chartCurvesSorted.sort(\n        (a, b) => a.item.values.whole < b.item.values.whole ? 1 : -1\n      );\n    }\n\n    chartCurvesSorted.push(otherSlice)\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          // if (uppedIndices.includes(item.index)) {\n          //   percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 6a52c6e1..804d8f3a 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -285,22 +285,32 @@ class PieChart extends AbstractChart { ); for (let i = 0; i < hamiltonDiff; i++) { let uppedVal = sortedCurves[i].item.values.whole; - sortedCurves.reverse().some(item => { + 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) { - chart.curves = chart.curves.sort( - (a, b) => a.item.values.whole > b.item.values.whole + chartCurvesSorted = chartCurvesSorted.sort((a, b) => + a.item.values.whole < b.item.values.whole ? 1 : -1 ); } - const slices = chart.curves.map((c, i) => { + chartCurvesSorted.push(otherSlice); + + const slices = chartCurvesSorted.map((c, i) => { let value: string; if (absolute) { @@ -316,9 +326,9 @@ class PieChart extends AbstractChart { } else { const item = c.item.values; let percentage = item.whole; - if (uppedIndices.includes(item.index)) { - percentage += 1; - } + // if (uppedIndices.includes(item.index)) { + // percentage += 1; + // } if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) { value = "<1%"; } else { From 389a4054fa8a04c79615d11d7c8c4cf1d95b7cd4 Mon Sep 17 00:00:00 2001 From: TDH55 Date: Wed, 21 Jul 2021 16:06:32 -0500 Subject: [PATCH 74/86] added check for undefined other slice --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 6 ++++-- src/PieChart.tsx | 4 +++- 3 files changed, 8 insertions(+), 4 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index ed919b87..13522b83 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CAuUP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CA6UP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 98031508..7689a8f8 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -314,7 +314,9 @@ var PieChart = /** @class */ (function(_super) { return a.item.values.whole < b.item.values.whole ? 1 : -1; }); } - chartCurvesSorted.push(otherSlice); + if (otherSlice) { + chartCurvesSorted.push(otherSlice); + } var slices = chartCurvesSorted.map(function(c, i) { var value; if (absolute) { @@ -442,4 +444,4 @@ var PieChart = /** @class */ (function(_super) { 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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((item) => item.item.otherSlice !== true)\n    let otherSlice = [...chart.curves].find((item) => item.item.otherSlice === true)\n\n    if (!absolute) {\n      chartCurvesSorted = chartCurvesSorted.sort(\n        (a, b) => a.item.values.whole < b.item.values.whole ? 1 : -1\n      );\n    }\n\n    chartCurvesSorted.push(otherSlice)\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          // if (uppedIndices.includes(item.index)) {\n          //   percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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          // if (uppedIndices.includes(item.index)) {\n          //   percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 804d8f3a..d0db56ca 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -308,7 +308,9 @@ class PieChart extends AbstractChart { ); } - chartCurvesSorted.push(otherSlice); + if (otherSlice) { + chartCurvesSorted.push(otherSlice); + } const slices = chartCurvesSorted.map((c, i) => { let value: string; From 53c0c2ff9977e190bc46b807234473af5010e2fb Mon Sep 17 00:00:00 2001 From: Alex Kalashnik Date: Tue, 8 Apr 2025 13:53:19 +0300 Subject: [PATCH 75/86] Upgrade libs --- dist/AbstractChart.d.ts | 848 +++++------- dist/AbstractChart.d.ts.map | 2 +- dist/AbstractChart.js | 672 +++------- dist/BarChart.d.ts | 261 +--- dist/BarChart.d.ts.map | 2 +- dist/BarChart.js | 451 ++----- dist/HelperTypes.d.ts | 276 ++-- dist/HelperTypes.d.ts.map | 2 +- dist/HelperTypes.js | 3 +- dist/PieChart.d.ts | 45 +- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 702 ++++------ dist/ProgressChart.d.ts | 63 +- dist/ProgressChart.d.ts.map | 2 +- dist/ProgressChart.js | 304 ++--- dist/StackedBarChart.d.ts | 191 +-- dist/StackedBarChart.d.ts.map | 2 +- dist/StackedBarChart.js | 382 ++---- dist/TextWidthFinder.d.ts | 2 +- dist/TextWidthFinder.js | 2 +- dist/Utils.d.ts | 10 +- dist/Utils.js | 4 +- .../contribution-graph/ContributionGraph.d.ts | 120 +- .../ContributionGraph.d.ts.map | 2 +- dist/contribution-graph/ContributionGraph.js | 654 ++++----- dist/contribution-graph/DateHelpers.d.ts | 2 +- dist/contribution-graph/DateHelpers.js | 12 +- dist/contribution-graph/constants.d.ts | 26 +- dist/contribution-graph/constants.js | 26 +- dist/contribution-graph/index.d.ts | 58 +- dist/contribution-graph/index.d.ts.map | 2 +- dist/contribution-graph/index.js | 2 +- dist/index.d.ts | 12 +- dist/index.js | 12 +- dist/line-chart/LegendItem.d.ts | 23 +- dist/line-chart/LegendItem.d.ts.map | 2 +- dist/line-chart/LegendItem.js | 47 +- dist/line-chart/LineChart.d.ts | 503 +++---- dist/line-chart/LineChart.d.ts.map | 2 +- dist/line-chart/LineChart.js | 1181 ++++++----------- dist/line-chart/index.d.ts | 2 +- dist/line-chart/index.js | 2 +- package.json | 52 +- src/BarChart.tsx | 4 +- src/PieChart.tsx | 9 +- src/ProgressChart.tsx | 4 +- src/StackedBarChart.tsx | 4 +- src/contribution-graph/ContributionGraph.tsx | 4 +- src/contribution-graph/index.tsx | 2 +- src/line-chart/LegendItem.tsx | 3 +- src/line-chart/LineChart.tsx | 4 +- 51 files changed, 2582 insertions(+), 4422 deletions(-) diff --git a/dist/AbstractChart.d.ts b/dist/AbstractChart.d.ts index 3a5efa0e..7d6eb3e9 100644 --- a/dist/AbstractChart.d.ts +++ b/dist/AbstractChart.d.ts @@ -1,538 +1,332 @@ -import { Component } from "react"; +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[]; + 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; + 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 declare type AbstractChartState = {}; +export type AbstractChartState = {}; export declare const DEFAULT_X_LABELS_HEIGHT_PERCENTAGE = 0.75; -declare class AbstractChart< - IProps extends AbstractChartProps, - IState extends AbstractChartState -> 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(): { - 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?: string | number; - inlineSize?: string | number; - alignmentBaseline?: import("react-native-svg").AlignmentBaseline; - baselineShift?: import("react-native-svg").BaselineShift; - verticalAlign?: string | number; - lengthAdjust?: import("react-native-svg").LengthAdjust; - textLength?: string | number; - fontData?: { - [name: string]: unknown; +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; }; - fontFeatureSettings?: string; - fill: import("react-native-svg").Color; - fillOpacity?: string | number; - fillRule?: import("react-native-svg").FillRule; - stroke?: import("react-native-svg").Color; - strokeWidth?: string | number; - strokeOpacity?: string | number; - strokeDasharray?: string | number | readonly (string | number)[]; - strokeDashoffset?: string | number; - strokeLinecap?: import("react-native-svg").Linecap; - strokeLinejoin?: "miter" | "bevel" | "round"; - strokeMiterlimit?: string | number; - clipRule?: import("react-native-svg").FillRule; - clipPath?: string; - transform?: - | string - | import("react-native-svg").TransformObject - | import("react-native-svg").ColumnMajorTransformMatrix; - translate?: import("react-native-svg").NumberArray; - translateX?: string | number; - translateY?: string | number; - origin?: import("react-native-svg").NumberArray; - originX?: string | number; - originY?: string | number; - scale?: import("react-native-svg").NumberArray; - scaleX?: string | number; - scaleY?: string | number; - skew?: import("react-native-svg").NumberArray; - skewX?: string | number; - skewY?: string | number; - rotation?: string | number; - vectorEffect?: - | "none" - | "non-scaling-stroke" - | "nonScalingStroke" - | "default" - | "inherit" - | "uri"; - pointerEvents?: "none" | "box-none" | "box-only" | "auto"; - onStartShouldSetResponder?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - onMoveShouldSetResponder?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - onResponderEnd?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderGrant?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderReject?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderMove?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderRelease?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderStart?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderTerminationRequest?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - onResponderTerminate?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onStartShouldSetResponderCapture?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - onMoveShouldSetResponderCapture?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - 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; - font?: import("react-native-svg").FontObject; - fontStyle?: import("react-native-svg").FontStyle; - fontVariant?: import("react-native-svg").FontVariant; - fontWeight?: string | number; - fontStretch?: import("react-native-svg").FontStretch; - fontSize: string | number; - fontFamily?: string; - textAnchor?: import("react-native-svg").TextAnchor; - textDecoration?: import("react-native-svg").TextDecoration; - letterSpacing?: string | number; - wordSpacing?: string | number; - kerning?: string | number; - fontVariantLigatures?: import("react-native-svg").FontVariantLigatures; - fontVariationSettings?: string; - }; - getPropsForVerticalLabels(): { - 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?: string | number; - inlineSize?: string | number; - alignmentBaseline?: import("react-native-svg").AlignmentBaseline; - baselineShift?: import("react-native-svg").BaselineShift; - verticalAlign?: string | number; - lengthAdjust?: import("react-native-svg").LengthAdjust; - textLength?: string | number; - fontData?: { - [name: string]: unknown; + 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; + 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; + 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; }; - fontFeatureSettings?: string; - fill: import("react-native-svg").Color; - fillOpacity?: string | number; - fillRule?: import("react-native-svg").FillRule; - stroke?: import("react-native-svg").Color; - strokeWidth?: string | number; - strokeOpacity?: string | number; - strokeDasharray?: string | number | readonly (string | number)[]; - strokeDashoffset?: string | number; - strokeLinecap?: import("react-native-svg").Linecap; - strokeLinejoin?: "miter" | "bevel" | "round"; - strokeMiterlimit?: string | number; - clipRule?: import("react-native-svg").FillRule; - clipPath?: string; - transform?: - | string - | import("react-native-svg").TransformObject - | import("react-native-svg").ColumnMajorTransformMatrix; - translate?: import("react-native-svg").NumberArray; - translateX?: string | number; - translateY?: string | number; - origin?: import("react-native-svg").NumberArray; - originX?: string | number; - originY?: string | number; - scale?: import("react-native-svg").NumberArray; - scaleX?: string | number; - scaleY?: string | number; - skew?: import("react-native-svg").NumberArray; - skewX?: string | number; - skewY?: string | number; - rotation?: string | number; - vectorEffect?: - | "none" - | "non-scaling-stroke" - | "nonScalingStroke" - | "default" - | "inherit" - | "uri"; - pointerEvents?: "none" | "box-none" | "box-only" | "auto"; - onStartShouldSetResponder?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - onMoveShouldSetResponder?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - onResponderEnd?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderGrant?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderReject?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderMove?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderRelease?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderStart?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderTerminationRequest?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - onResponderTerminate?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onStartShouldSetResponderCapture?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - onMoveShouldSetResponderCapture?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - 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; - font?: import("react-native-svg").FontObject; - fontStyle?: import("react-native-svg").FontStyle; - fontVariant?: import("react-native-svg").FontVariant; - fontWeight?: string | number; - fontStretch?: import("react-native-svg").FontStretch; - fontSize?: string | number; - fontFamily?: string; - textAnchor?: import("react-native-svg").TextAnchor; - textDecoration?: import("react-native-svg").TextDecoration; - letterSpacing?: string | number; - wordSpacing?: string | number; - kerning?: string | number; - fontVariantLigatures?: import("react-native-svg").FontVariantLigatures; - fontVariationSettings?: string; - }; - getPropsForHorizontalLabels(): { - 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?: string | number; - inlineSize?: string | number; - alignmentBaseline?: import("react-native-svg").AlignmentBaseline; - baselineShift?: import("react-native-svg").BaselineShift; - verticalAlign?: string | number; - lengthAdjust?: import("react-native-svg").LengthAdjust; - textLength?: string | number; - fontData?: { - [name: string]: unknown; + 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; + 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; + 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; }; - fontFeatureSettings?: string; - fill: import("react-native-svg").Color; - fillOpacity?: string | number; - fillRule?: import("react-native-svg").FillRule; - stroke?: import("react-native-svg").Color; - strokeWidth?: string | number; - strokeOpacity?: string | number; - strokeDasharray?: string | number | readonly (string | number)[]; - strokeDashoffset?: string | number; - strokeLinecap?: import("react-native-svg").Linecap; - strokeLinejoin?: "miter" | "bevel" | "round"; - strokeMiterlimit?: string | number; - clipRule?: import("react-native-svg").FillRule; - clipPath?: string; - transform?: - | string - | import("react-native-svg").TransformObject - | import("react-native-svg").ColumnMajorTransformMatrix; - translate?: import("react-native-svg").NumberArray; - translateX?: string | number; - translateY?: string | number; - origin?: import("react-native-svg").NumberArray; - originX?: string | number; - originY?: string | number; - scale?: import("react-native-svg").NumberArray; - scaleX?: string | number; - scaleY?: string | number; - skew?: import("react-native-svg").NumberArray; - skewX?: string | number; - skewY?: string | number; - rotation?: string | number; - vectorEffect?: - | "none" - | "non-scaling-stroke" - | "nonScalingStroke" - | "default" - | "inherit" - | "uri"; - pointerEvents?: "none" | "box-none" | "box-only" | "auto"; - onStartShouldSetResponder?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - onMoveShouldSetResponder?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - onResponderEnd?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderGrant?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderReject?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderMove?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderRelease?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderStart?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onResponderTerminationRequest?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - onResponderTerminate?: ( - event: import("react-native").GestureResponderEvent - ) => void; - onStartShouldSetResponderCapture?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - onMoveShouldSetResponderCapture?: ( - event: import("react-native").GestureResponderEvent - ) => boolean; - 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; - font?: import("react-native-svg").FontObject; - fontStyle?: import("react-native-svg").FontStyle; - fontVariant?: import("react-native-svg").FontVariant; - fontWeight?: string | number; - fontStretch?: import("react-native-svg").FontStretch; - fontSize?: string | number; - fontFamily?: string; - textAnchor?: import("react-native-svg").TextAnchor; - textDecoration?: import("react-native-svg").TextDecoration; - letterSpacing?: string | number; - wordSpacing?: string | number; - kerning?: string | number; - fontVariantLigatures?: import("react-native-svg").FontVariantLigatures; - fontVariationSettings?: string; - }; - renderHorizontalLines: (config: any) => JSX.Element[]; - renderHorizontalLine: (config: any) => JSX.Element; - renderHorizontalLabels: ( - config: Pick< - AbstractChartConfig, - | "propsForBackgroundLines" - | "propsForLabels" - | "color" - | "labelColor" - | "propsForVerticalLabels" - | "propsForHorizontalLabels" - | "count" - | "width" - | "height" - | "paddingTop" - | "paddingRight" - | "horizontalLabelRotation" - | "formatYLabel" - | "labels" - | "horizontalOffset" - | "stackedBar" - | "verticalLabelRotation" - | "formatXLabel" - | "verticalLabelsHeightPercentage" - | "backgroundColor" - | "backgroundGradientFrom" - | "backgroundGradientFromOpacity" - | "backgroundGradientTo" - | "backgroundGradientToOpacity" - | "fillShadowGradient" - | "fillShadowGradientOpacity" - | "useShadowColorFromDataset" - | "strokeWidth" - | "barPercentage" - | "barRadius" - | "propsForDots" - | "decimalPlaces" - | "style" - | "linejoinType" - | "scrollableDotFill" - | "scrollableDotStrokeColor" - | "scrollableDotStrokeWidth" - | "scrollableDotRadius" - | "scrollableInfoViewStyle" - | "scrollableInfoTextStyle" - | "scrollableInfoTextDecorator" - | "scrollableInfoOffset" - | "scrollableInfoSize" - > & { - data: number[]; - } - ) => JSX.Element[]; - renderVerticalLabels: ({ - labels, - width, - height, - paddingRight, - paddingTop, - horizontalOffset, - stackedBar, - verticalLabelRotation, - formatXLabel, - verticalLabelsHeightPercentage - }: Pick< - AbstractChartConfig, - | "labels" - | "width" - | "height" - | "paddingRight" - | "paddingTop" - | "horizontalOffset" - | "stackedBar" - | "verticalLabelRotation" - | "formatXLabel" - | "verticalLabelsHeightPercentage" - >) => JSX.Element[]; - renderVerticalLines: ({ - data, - width, - height, - paddingTop, - paddingRight, - verticalLabelsHeightPercentage - }: Pick< - Pick< - AbstractChartConfig, - | "data" - | "width" - | "height" - | "paddingTop" - | "paddingRight" - | "verticalLabelsHeightPercentage" - >, - | "width" - | "height" - | "paddingTop" - | "paddingRight" - | "verticalLabelsHeightPercentage" - > & { - data: number[]; - }) => JSX.Element[]; - renderVerticalLine: ({ - height, - paddingTop, - paddingRight, - verticalLabelsHeightPercentage - }: Pick< - AbstractChartConfig, - "height" | "paddingRight" | "paddingTop" | "verticalLabelsHeightPercentage" - >) => JSX.Element; - renderDefs: ( - config: Pick< - PartialBy< - AbstractChartConfig, - | "backgroundGradientFromOpacity" - | "backgroundGradientToOpacity" - | "fillShadowGradient" - | "fillShadowGradientOpacity" - >, - | "width" - | "height" - | "backgroundGradientFrom" - | "backgroundGradientTo" - | "useShadowColorFromDataset" - | "data" - | "backgroundGradientFromOpacity" - | "backgroundGradientToOpacity" - | "fillShadowGradient" - | "fillShadowGradientOpacity" - > - ) => JSX.Element; + 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; + 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; + 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 +//# 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 index 187f8941..a9b702cd 100644 --- a/dist/AbstractChart.d.ts.map +++ b/dist/AbstractChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"AbstractChart.d.ts","sourceRoot":"","sources":["../src/AbstractChart.tsx"],"names":[],"mappings":"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"} \ No newline at end of file +{"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 index 65200aab..f3a455c4 100644 --- a/dist/AbstractChart.js +++ b/dist/AbstractChart.js @@ -1,468 +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 (b.hasOwnProperty(p)) d[p] = b[p]; - }; - return extendStatics(d, b); +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) { - extendStatics(d, b); - function __() { - this.constructor = d; - } - d.prototype = - b === null - ? Object.create(b) - : ((__.prototype = b.prototype), new __()); + 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) { +})(); +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]; + 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 __spreadArrays = - (this && this.__spreadArrays) || - function() { - for (var s = 0, i = 0, il = arguments.length; i < il; i++) - s += arguments[i].length; - for (var r = Array(s), k = 0, i = 0; i < il; i++) - for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) - r[k] = a[j]; - return r; - }; +}; +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) { - return ( - Math.max.apply(Math, __spreadArrays(data, [0])) - - Math.min.apply(Math, __spreadArrays(data, [0])) || 1 - ); - } else if (_this.props.fromNumber) { - return ( - Math.max.apply(Math, __spreadArrays(data, [_this.props.fromNumber])) - - Math.min.apply( - Math, - __spreadArrays(data, [_this.props.fromNumber]) - ) || 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 __spreadArrays(new Array(count + 1)).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 = - "" + - yAxisLabel + - formatYLabel(data[0].toFixed(decimalPlaces)) + - yAxisSuffix; - } else { - var label = _this.props.fromZero - ? (_this.calcScaler(data) / count) * i + - Math.min.apply(Math, __spreadArrays(data, [0])) - : (_this.calcScaler(data) / count) * i + Math.min.apply(Math, data); - yLabel = - "" + - yAxisLabel + - formatYLabel(label.toFixed(decimalPlaces)) + - 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 ( - - {"" + formatXLabel(label) + xAxisLabel} - - ); - }); +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); }; - _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 __spreadArrays( - new Array(Math.ceil(data.length / yAxisInterval)) - ).map(function(_, i) { - return ( - - ); - }); + 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); }; - _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 ( - - ); + 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); }; - _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; - return ( - - - - - - {useShadowColorFromDataset ? ( - data.map(function(dataset, index) { - return ( - - - - - ); - }) - ) : ( - - - - - )} - - ); + 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 _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); + 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}\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) {\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      >,\n      | \"width\"\n      | \"height\"\n      | \"backgroundGradientFrom\"\n      | \"backgroundGradientTo\"\n      | \"useShadowColorFromDataset\"\n      | \"data\"\n      | \"backgroundGradientFromOpacity\"\n      | \"backgroundGradientToOpacity\"\n      | \"fillShadowGradient\"\n      | \"fillShadowGradientOpacity\"\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    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={`fillShadowGradient_${index}`}\n              key={`${index}`}\n              x1={0}\n              y1={0}\n              x2={0}\n              y2={height}\n              gradientUnits=\"userSpaceOnUse\"\n            >\n              <Stop\n                offset=\"0\"\n                stopColor={\n                  dataset.color ? dataset.color(1.0) : fillShadowGradient\n                }\n                stopOpacity={fillShadowGradientOpacity}\n              />\n              <Stop\n                offset=\"1\"\n                stopColor={\n                  dataset.color\n                    ? dataset.color(fillShadowGradientOpacity)\n                    : fillShadowGradient\n                }\n                stopOpacity=\"0\"\n              />\n            </LinearGradient>\n          ))\n        ) : (\n          <LinearGradient\n            id=\"fillShadowGradient\"\n            x1={0}\n            y1={0}\n            x2={0}\n            y2={height}\n            gradientUnits=\"userSpaceOnUse\"\n          >\n            <Stop\n              offset=\"0\"\n              stopColor={fillShadowGradient}\n              stopOpacity={fillShadowGradientOpacity}\n            />\n            <Stop offset=\"1\" stopColor={fillShadowGradient} stopOpacity=\"0\" />\n          </LinearGradient>\n        )}\n      </Defs>\n    );\n  };\n}\n\nexport default AbstractChart;\n"]} +//# 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 index e85b5a3a..0eadd819 100644 --- a/dist/BarChart.d.ts +++ b/dist/BarChart.d.ts @@ -1,222 +1,53 @@ +import React from "react"; import { ViewStyle } from "react-native"; -import AbstractChart, { - AbstractChartConfig, - AbstractChartProps -} from "./AbstractChart"; +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; + 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; } -declare type BarChartState = {}; +type BarChartState = {}; declare class BarChart extends AbstractChart { - getBarPercentage: () => number; - renderBars: ({ - data, - width, - height, - paddingTop, - paddingRight, - barRadius, - withCustomBarColorFromData - }: Pick< - Pick< - AbstractChartConfig, - | "propsForBackgroundLines" - | "propsForLabels" - | "color" - | "labelColor" - | "propsForVerticalLabels" - | "propsForHorizontalLabels" - | "count" - | "width" - | "height" - | "paddingTop" - | "paddingRight" - | "horizontalLabelRotation" - | "formatYLabel" - | "labels" - | "horizontalOffset" - | "stackedBar" - | "verticalLabelRotation" - | "formatXLabel" - | "verticalLabelsHeightPercentage" - | "backgroundColor" - | "backgroundGradientFrom" - | "backgroundGradientFromOpacity" - | "backgroundGradientTo" - | "backgroundGradientToOpacity" - | "fillShadowGradient" - | "fillShadowGradientOpacity" - | "useShadowColorFromDataset" - | "strokeWidth" - | "barPercentage" - | "barRadius" - | "propsForDots" - | "decimalPlaces" - | "style" - | "linejoinType" - | "scrollableDotFill" - | "scrollableDotStrokeColor" - | "scrollableDotStrokeWidth" - | "scrollableDotRadius" - | "scrollableInfoViewStyle" - | "scrollableInfoTextStyle" - | "scrollableInfoTextDecorator" - | "scrollableInfoOffset" - | "scrollableInfoSize" - >, - "width" | "height" | "paddingTop" | "paddingRight" | "barRadius" - > & { - data: number[]; - withCustomBarColorFromData: boolean; - }) => JSX.Element[]; - renderBarTops: ({ - data, - width, - height, - paddingTop, - paddingRight - }: Pick< - Pick< - AbstractChartConfig, - | "propsForBackgroundLines" - | "propsForLabels" - | "color" - | "labelColor" - | "propsForVerticalLabels" - | "propsForHorizontalLabels" - | "count" - | "width" - | "height" - | "paddingTop" - | "paddingRight" - | "horizontalLabelRotation" - | "formatYLabel" - | "labels" - | "horizontalOffset" - | "stackedBar" - | "verticalLabelRotation" - | "formatXLabel" - | "verticalLabelsHeightPercentage" - | "backgroundColor" - | "backgroundGradientFrom" - | "backgroundGradientFromOpacity" - | "backgroundGradientTo" - | "backgroundGradientToOpacity" - | "fillShadowGradient" - | "fillShadowGradientOpacity" - | "useShadowColorFromDataset" - | "strokeWidth" - | "barPercentage" - | "barRadius" - | "propsForDots" - | "decimalPlaces" - | "style" - | "linejoinType" - | "scrollableDotFill" - | "scrollableDotStrokeColor" - | "scrollableDotStrokeWidth" - | "scrollableDotRadius" - | "scrollableInfoViewStyle" - | "scrollableInfoTextStyle" - | "scrollableInfoTextDecorator" - | "scrollableInfoOffset" - | "scrollableInfoSize" - >, - "width" | "height" | "paddingTop" | "paddingRight" - > & { - data: number[]; - }) => JSX.Element[]; - renderColors: ({ - data, - flatColor - }: Pick & { - flatColor: boolean; - }) => JSX.Element[]; - renderValuesOnTopOfBars: ({ - data, - width, - height, - paddingTop, - paddingRight - }: Pick< - Pick< - AbstractChartConfig, - | "propsForBackgroundLines" - | "propsForLabels" - | "color" - | "labelColor" - | "propsForVerticalLabels" - | "propsForHorizontalLabels" - | "count" - | "width" - | "height" - | "paddingTop" - | "paddingRight" - | "horizontalLabelRotation" - | "formatYLabel" - | "labels" - | "horizontalOffset" - | "stackedBar" - | "verticalLabelRotation" - | "formatXLabel" - | "verticalLabelsHeightPercentage" - | "backgroundColor" - | "backgroundGradientFrom" - | "backgroundGradientFromOpacity" - | "backgroundGradientTo" - | "backgroundGradientToOpacity" - | "fillShadowGradient" - | "fillShadowGradientOpacity" - | "useShadowColorFromDataset" - | "strokeWidth" - | "barPercentage" - | "barRadius" - | "propsForDots" - | "decimalPlaces" - | "style" - | "linejoinType" - | "scrollableDotFill" - | "scrollableDotStrokeColor" - | "scrollableDotStrokeWidth" - | "scrollableDotRadius" - | "scrollableInfoViewStyle" - | "scrollableInfoTextStyle" - | "scrollableInfoTextDecorator" - | "scrollableInfoOffset" - | "scrollableInfoSize" - >, - "width" | "height" | "paddingTop" | "paddingRight" - > & { - data: number[]; - }) => JSX.Element[]; - render(): JSX.Element; + 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 +//# 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 index ca956276..561cd407 100644 --- a/dist/BarChart.d.ts.map +++ b/dist/BarChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"BarChart.d.ts","sourceRoot":"","sources":["../src/BarChart.tsx"],"names":[],"mappings":"AACA,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;CACrB;AAED,aAAK,aAAa,GAAG,EAAE,CAAC;AAExB,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,gBAAgB,eAGd;IAEF,UAAU;cAYF,MAAM,EAAE;oCACc,OAAO;wBA8BnC;IAEF,aAAa;cAUL,MAAM,EAAE;wBAsBd;IAEF,YAAY;mBAIC,OAAO;wBA4BlB;IAEF,uBAAuB;cAUf,MAAM,EAAE;wBAwBd;IAEF,MAAM;CA0HP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"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 index df102c87..9c365c11 100644 --- a/dist/BarChart.js +++ b/dist/BarChart.js @@ -1,350 +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 (b.hasOwnProperty(p)) d[p] = b[p]; - }; - return extendStatics(d, b); +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) { - extendStatics(d, b); - function __() { - this.constructor = d; - } - d.prototype = - b === null - ? Object.create(b) - : ((__.prototype = b.prototype), new __()); + 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) { +})(); +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]; + 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 { 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_" + i + ")" - : "url(#fillShadowGradient)" - } - /> - ); - }); - }; - _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); - return data.map(function(x, i) { - var barHeight = _this.calcHeight(x, data, height); - var barWidth = 32 * _this.getBarPercentage(); - return ( - - {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 ( - +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 - }) - )} - + {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} + ? 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} + ? 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.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 - }) - )} + {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 - }) - )} + 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 - }) - )} + this.renderBarTops(__assign(__assign({}, config), { data: data.datasets[0].data, paddingTop: paddingTop, paddingRight: paddingRight }))} - - ); - }; - return BarChart; -})(AbstractChart); + ); + }; + return BarChart; +}(AbstractChart)); export default BarChart; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BarChart.js","sourceRoot":"","sources":["../src/BarChart.tsx"],"names":[],"mappings":"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","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\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(#fillShadowGradient)\"\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    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          y={((baseHeight - barHeight) / 4) * 3 + paddingTop - 1}\n          fill={this.props.chartConfig.color(0.6)}\n          fontSize=\"12\"\n          textAnchor=\"middle\"\n        >\n          {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={borderRadius}\n            ry={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"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BarChart.js","sourceRoot":"","sources":["../src/BarChart.tsx"],"names":[],"mappings":"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","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 index 2da7b806..2a9f7256 100644 --- a/dist/HelperTypes.d.ts +++ b/dist/HelperTypes.d.ts @@ -1,135 +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; + /** 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[]; + /** 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; - fillShadowGradient?: string; - fillShadowGradientOpacity?: 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; + 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; + width: number; + height: number; } -export declare type PartialBy = Omit & - Partial>; -//# sourceMappingURL=HelperTypes.d.ts.map +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 index 939631c5..9bccf45d 100644 --- a/dist/HelperTypes.d.ts.map +++ b/dist/HelperTypes.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"HelperTypes.d.ts","sourceRoot":"","sources":["../src/HelperTypes.ts"],"names":[],"mappings":"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"} \ No newline at end of file +{"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 index e7d2597d..01642b6a 100644 --- a/dist/HelperTypes.js +++ b/dist/HelperTypes.js @@ -1 +1,2 @@ -//# sourceMappingURL=data:application/json;base64,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 +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 index 109a8b26..847caf76 100644 --- a/dist/PieChart.d.ts +++ b/dist/PieChart.d.ts @@ -1,30 +1,31 @@ +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; + 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; } -declare type PieChartState = { - data: Array; - onLayout: boolean; - calculating: Array; +type PieChartState = { + data: Array; + onLayout: boolean; + calculating: Array; }; declare class PieChart extends AbstractChart { - componentDidUpdate(prevProps: any): void; - constructor(props: any); - render(): JSX.Element; + componentDidUpdate(prevProps: any): void; + constructor(props: any); + render(): React.JSX.Element; } export default PieChart; -//# sourceMappingURL=PieChart.d.ts.map +//# 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 index 13522b83..28bb6538 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../src/PieChart.tsx"],"names":[],"mappings":"AAGA,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,aAAK,aAAa,GAAG;IACnB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CA6UP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"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,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CA4UP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 7689a8f8..fac41fa2 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -1,447 +1,319 @@ -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 (b.hasOwnProperty(p)) d[p] = b[p]; - }; - return extendStatics(d, b); +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) { - extendStatics(d, b); - function __() { - this.constructor = d; - } - d.prototype = - b === null - ? Object.create(b) - : ((__.prototype = b.prototype), new __()); + 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) { +})(); +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]; + 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 __spreadArrays = - (this && this.__spreadArrays) || - function() { - for (var s = 0, i = 0, il = arguments.length; i < il; i++) - s += arguments[i].length; - for (var r = Array(s), k = 0, i = 0; i < il; i++) - for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) - r[k] = a[j]; - return r; - }; +}; +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"; -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 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, onLayout: true }, 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 && - // !this.props.editor && - compareDataArrays(this.props.data, prevProps.data) - ) { - this.setState( - __assign( - __assign({ calculating: calculating, onLayout: false }, this.props), - this.state - ) - ); - } else { - this.setState( - __assign( - { calculating: calculating, onLayout: true }, - this.props - // ...this.state - ) - ); - } +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, onLayout: true }, props), { labelData: _this.props.data }); + return _this; } - }; - 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; - //TODO: move setState out of onlayout since it runs in a for loop - var onLayout = function(e, index, fontSize, label) { - if (_this.state.onLayout) { - var width = e.nativeEvent.layout.width; - var target = - _this.props.width - _this.props.width * chartWidthPercentage - 84; - var calculating = _this.state.calculating; - if (width < target) { - calculating[index].calculating = false; - _this.setState(__assign({ calculating: calculating }, _this.state)); - } else { - if (label.slice(-3) === "...") { - label = label.slice(0, -3); - } - if (isNaN(fontSize)) { - if (!fontSize) { - fontSize = "12px"; + 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 && + // !this.props.editor && + compareDataArrays(this.props.data, prevProps.data)) { + this.setState(__assign(__assign({ calculating: calculating, onLayout: false }, this.props), this.state)); + } + else { + this.setState(__assign({ calculating: calculating, onLayout: true }, this.props + // ...this.state + )); } - target = target - fontSize.split("p")[0] * 2; - } else { - target = target - fontSize * 2; - } - var numberOfCharacters = label.length; - var ratio = target / width; - var targetCharacters = Math.floor(ratio * numberOfCharacters); - label = label.slice(0, targetCharacters) + "..."; - calculating[index].label.name = label; - if (label === "...") { - calculating[index].calculating = false; - } - _this.setState(__assign({ calculating: calculating }, _this.state)); } - } }; - 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 ( - - - {value + " " + name} - - - ); - } else { - return ( - - - {value.whole + "% " + name} + 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; + //TODO: move setState out of onlayout since it runs in a for loop + var onLayout = function (e, index, fontSize, label) { + if (_this.state.onLayout) { + var width = e.nativeEvent.layout.width; + var target = _this.props.width - _this.props.width * chartWidthPercentage - 84; + var calculating = _this.state.calculating; + if (width < target) { + calculating[index].calculating = false; + _this.setState(__assign({ calculating: calculating }, _this.state)); + } + else { + if (label.slice(-3) === "...") { + label = label.slice(0, -3); + } + if (isNaN(fontSize)) { + if (!fontSize) { + fontSize = "12px"; + } + target = target - fontSize.split("p")[0] * 2; + } + else { + target = target - fontSize * 2; + } + var numberOfCharacters = label.length; + var ratio = target / width; + var targetCharacters = Math.floor(ratio * numberOfCharacters); + label = "".concat(label.slice(0, targetCharacters), "..."); + calculating[index].label.name = label; + if (label === "...") { + calculating[index].calculating = false; + } + _this.setState(__assign({ calculating: calculating }, _this.state)); + } + } + }; + 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); } - } - }); - 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; + else { + radius = this.props.width * (chartWidthPercentage / 2); + } + if (chartWidthPercentage === 1) { + chartWidthPercentage = 0.5; } - }); - var hamiltonDiff = 100 - wholeTotal_1; - var sortedCurves = __spreadArrays(chart.curves).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; - } + 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]; + } }); - }; - for (var i = 0; i < hamiltonDiff; i++) { - _loop_1(i); - } - } - var chartCurvesSorted = __spreadArrays(chart.curves).filter(function(item) { - return item.item.otherSlice !== true; - }); - var otherSlice = __spreadArrays(chart.curves).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 value; - if (absolute) { - if (_this.props.showLabelPrefix) { - value = c.item[_this.props.accessor]; - } else { - value = ""; + 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); + } } - } else { - //calculate percentage using Hamilton's method - if (total === 0) { - value = 0 + "%"; - } else { - var item = c.item.values; - var percentage = item.whole; - // if (uppedIndices.includes(item.index)) { - // percentage += 1; - // } - if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) { - value = "<1%"; - } else { - value = percentage + "%"; - } + 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; + }); } - } - var textColor = _this.state.calculating[i] - ? c.item.legendFontColor - : "transparent"; - return ( - - + - {hasLegend ? ( - - ) : null} - {hasLegend ? ( - - {value + " " + c.item.name} - - ) : null} - - ); - }); - return ( - - + onClick={c.item.action}/> + {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 - ) - )} + {this.renderDefs(__assign({ width: this.props.height, height: this.props.height }, this.props.chartConfig))} - - + + {slices} {calculations} - - ); - }; - return PieChart; -})(AbstractChart); + ); + }; + 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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          // if (uppedIndices.includes(item.index)) {\n          //   percentage += 1;\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      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={8}\n              ry={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={borderRadius}\n            ry={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            // @ts-expect-error\n            width={this.props.width}\n          >\n            {slices}\n          </G>\n        </Svg>\n        {calculations}\n      </View>\n    );\n  }\n}\n\nexport default PieChart;\n"]} +//# 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\";\n// import TextWidthFinder from \"./TextWidthFinder\";\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  onLayout: boolean;\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        // !this.props.editor &&\n        compareDataArrays(this.props.data, prevProps.data)\n      ) {\n        this.setState({\n          calculating,\n          onLayout: false,\n          ...this.props,\n          ...this.state\n        });\n      } else {\n        this.setState({\n          calculating,\n          onLayout: true,\n          ...this.props\n          // ...this.state\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      onLayout: true,\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    //TODO: move setState out of onlayout since it runs in a for loop\n    const onLayout = (e, index, fontSize, label) => {\n      if (this.state.onLayout) {\n        let width = e.nativeEvent.layout.width;\n        let target =\n          this.props.width - this.props.width * chartWidthPercentage - 84;\n        let calculating = this.state.calculating;\n\n        if (width < target) {\n          calculating[index].calculating = false;\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        } else {\n          if (label.slice(-3) === \"...\") {\n            label = label.slice(0, -3);\n          }\n          if (isNaN(fontSize)) {\n            if (!fontSize) {\n              fontSize = \"12px\";\n            }\n            target = target - fontSize.split(\"p\")[0] * 2;\n          } else {\n            target = target - fontSize * 2;\n          }\n          const numberOfCharacters = label.length;\n          const ratio = target / width;\n          const targetCharacters = Math.floor(ratio * numberOfCharacters);\n          label = `${label.slice(0, targetCharacters)}...`;\n          calculating[index].label.name = label;\n          if (label === \"...\") {\n            calculating[index].calculating = false;\n          }\n          this.setState({\n            calculating,\n            ...this.state\n          });\n        }\n      }\n    };\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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              onLayout={e => onLayout(e, index, legendFontSize, name)}\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          // if (uppedIndices.includes(item.index)) {\n          //   percentage += 1;\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      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 index 9812d50f..8d2e151f 100644 --- a/dist/ProgressChart.d.ts +++ b/dist/ProgressChart.d.ts @@ -1,40 +1,33 @@ +import React from "react"; import { ViewStyle } from "react-native"; -import AbstractChart, { - AbstractChartConfig, - AbstractChartProps -} from "./AbstractChart"; -export declare type ProgressChartData = - | Array - | { - labels?: Array; - colors?: Array; - data: Array; - }; +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; + data: ProgressChartData; + width: number; + height: number; + center?: Array; + absolute?: boolean; + hasLegend?: boolean; + style?: Partial; + chartConfig?: AbstractChartConfig; + hideLegend?: boolean; + strokeWidth?: number; + radius?: number; + withCustomBarColorFromData?: boolean; } -declare type ProgressChartState = {}; -declare class ProgressChart extends AbstractChart< - ProgressChartProps, - ProgressChartState -> { - static defaultProps: { - style: {}; - strokeWidth: number; - radius: number; - }; - render(): JSX.Element; +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 +//# 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 index da25c3a6..ca4d9140 100644 --- a/dist/ProgressChart.d.ts.map +++ b/dist/ProgressChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"ProgressChart.d.ts","sourceRoot":"","sources":["../src/ProgressChart.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,SAAS,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,aAAa,EAAE,EACpB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AAEzB,oBAAY,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,aAAK,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 +{"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 index fc85228d..c8a245e8 100644 --- a/dist/ProgressChart.js +++ b/dist/ProgressChart.js @@ -1,228 +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 (b.hasOwnProperty(p)) d[p] = b[p]; - }; - return extendStatics(d, b); +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) { - extendStatics(d, b); - function __() { - this.constructor = d; - } - d.prototype = - b === null - ? Object.create(b) - : ((__.prototype = b.prototype), new __()); + 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) { +})(); +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]; + 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 ProgressChart = /** @class */ (function (_super) { + __extends(ProgressChart, _super); + function ProgressChart() { + return _super !== null && _super.apply(this, arguments) || this; } - 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; + 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 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 ( - - ); - })} + }); + }); + 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 ( - + {pies.map(function (_, i) { + return ( {withLabel(i) - ? data.labels[i] + " " + Math.round(100 * data.data[i]) + "%" - : Math.round(100 * data.data[i]) + "%"} - - ); - })} + ? "".concat(data.labels[i], " ").concat(Math.round(100 * data.data[i]), "%") + : "".concat(Math.round(100 * data.data[i]), "%")} + ); + })} - - ); - return ( - + ); + return ( - {this.renderDefs( - __assign( - { width: this.props.height, height: this.props.height }, - this.props.chartConfig - ) - )} - - + {this.renderDefs(__assign({ width: this.props.height, height: this.props.height }, this.props.chartConfig))} + + - {pieBackgrounds.map(function(pie, i) { - return ( - - ); - })} + {pieBackgrounds.map(function (pie, i) { + return (); + })} - {pies.map(function(pie, i) { - return ( - - ); - })} + : _this.props.chartConfig.color((i / pies.length) * 0.5 + 0.5, i)}/>); + })} {legend} - - ); - }; - ProgressChart.defaultProps = { style: {}, strokeWidth: 16, radius: 32 }; - return ProgressChart; -})(AbstractChart); + ); + }; + 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={borderRadius}\n            ry={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"]} +//# 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 index be7a5f3a..5658de57 100644 --- a/dist/StackedBarChart.d.ts +++ b/dist/StackedBarChart.d.ts @@ -1,139 +1,66 @@ +import React from "react"; import { ViewStyle } from "react-native"; -import AbstractChart, { - AbstractChartConfig, - AbstractChartProps -} from "./AbstractChart"; +import AbstractChart, { AbstractChartConfig, AbstractChartProps } from "./AbstractChart"; export interface StackedBarChartData { - labels: string[]; - legend: string[]; - data: number[][]; - barColors: string[]; + 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; + /** + * 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; } -declare type StackedBarChartState = {}; -declare class StackedBarChart extends AbstractChart< - StackedBarChartProps, - StackedBarChartState -> { - getBarPercentage: () => number; - getBarRadius: (ret: string | any[], x: string | any[]) => number; - renderBars: ({ - data, - width, - height, - paddingTop, - paddingRight, - border, - colors, - stackedBar, - verticalLabelsHeightPercentage - }: Pick< - Pick< - AbstractChartConfig, - | "propsForBackgroundLines" - | "propsForLabels" - | "color" - | "labelColor" - | "propsForVerticalLabels" - | "propsForHorizontalLabels" - | "count" - | "width" - | "height" - | "paddingTop" - | "paddingRight" - | "horizontalLabelRotation" - | "formatYLabel" - | "labels" - | "horizontalOffset" - | "stackedBar" - | "verticalLabelRotation" - | "formatXLabel" - | "verticalLabelsHeightPercentage" - | "backgroundColor" - | "backgroundGradientFrom" - | "backgroundGradientFromOpacity" - | "backgroundGradientTo" - | "backgroundGradientToOpacity" - | "fillShadowGradient" - | "fillShadowGradientOpacity" - | "useShadowColorFromDataset" - | "strokeWidth" - | "barPercentage" - | "barRadius" - | "propsForDots" - | "decimalPlaces" - | "style" - | "linejoinType" - | "scrollableDotFill" - | "scrollableDotStrokeColor" - | "scrollableDotStrokeWidth" - | "scrollableDotRadius" - | "scrollableInfoViewStyle" - | "scrollableInfoTextStyle" - | "scrollableInfoTextDecorator" - | "scrollableInfoOffset" - | "scrollableInfoSize" - >, - | "width" - | "height" - | "paddingTop" - | "paddingRight" - | "stackedBar" - | "verticalLabelsHeightPercentage" - > & { - border: number; - colors: string[]; - data: number[][]; - }) => any[][]; - renderLegend: ({ - legend, - colors, - width, - height - }: Pick & { - legend: string[]; - colors: string[]; - }) => JSX.Element[]; - render(): JSX.Element; +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 +//# 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 index e119d9a7..c8044860 100644 --- a/dist/StackedBarChart.d.ts.map +++ b/dist/StackedBarChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"StackedBarChart.d.ts","sourceRoot":"","sources":["../src/StackedBarChart.tsx"],"names":[],"mappings":"AACA,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,aAAK,oBAAoB,GAAG,EAAE,CAAC;AAE/B,cAAM,eAAgB,SAAQ,aAAa,CACzC,oBAAoB,EACpB,oBAAoB,CACrB;IACC,gBAAgB,eAGd;IAEF,YAAY,QAAS,MAAM,GAAG,GAAG,EAAE,KAAK,MAAM,GAAG,GAAG,EAAE,YAIpD;IAEF,UAAU;gBAmBA,MAAM;gBACN,MAAM,EAAE;cACV,MAAM,EAAE,EAAE;kBAsDb;IAEL,YAAY;gBAMF,MAAM,EAAE;gBACR,MAAM,EAAE;wBAuBb;IAEL,MAAM;CAsHP;AAED,eAAe,eAAe,CAAC"} \ No newline at end of file +{"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 index 69f162fc..2722a1b3 100644 --- a/dist/StackedBarChart.js +++ b/dist/StackedBarChart.js @@ -1,288 +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 (b.hasOwnProperty(p)) d[p] = b[p]; - }; - return extendStatics(d, b); +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) { - extendStatics(d, b); - function __() { - this.constructor = d; - } - d.prototype = - b === null - ? Object.create(b) - : ((__.prototype = b.prototype), new __()); + 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) { +})(); +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]; + 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; +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; + } } - 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; + if (percentile) { + border = 100; } - 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 ( - + 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.renderDefs(__assign(__assign({}, config), this.props.chartConfig))} + - {this.renderHorizontalLines( - __assign(__assign({}, config), { - count: segments, - paddingTop: paddingTop, - verticalLabelsHeightPercentage: verticalLabelsHeightPercentage - }) - )} + {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} + ? 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.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 - }) - )} + {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 - }) - )} + this.renderLegend(__assign(__assign({}, config), { legend: data.legend, colors: this.props.data.barColors }))} - - ); - }; - return StackedBarChart; -})(AbstractChart); + ); + }; + 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={borderRadius}\n            ry={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"]} +//# 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 index c506b7b4..a965f0b7 100644 --- a/dist/TextWidthFinder.d.ts +++ b/dist/TextWidthFinder.d.ts @@ -1 +1 @@ -//# sourceMappingURL=TextWidthFinder.d.ts.map +//# sourceMappingURL=TextWidthFinder.d.ts.map \ No newline at end of file diff --git a/dist/TextWidthFinder.js b/dist/TextWidthFinder.js index eb925002..bd441034 100644 --- a/dist/TextWidthFinder.js +++ b/dist/TextWidthFinder.js @@ -16,4 +16,4 @@ // // ); // } -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVGV4dFdpZHRoRmluZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL1RleHRXaWR0aEZpbmRlci50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0RBQW9EO0FBQ3BELHdEQUF3RDtBQUV4RCwwREFBMEQ7QUFDMUQsNkRBQTZEO0FBRTdELHNCQUFzQjtBQUN0Qiw0QkFBNEI7QUFDNUIsdUJBQXVCO0FBRXZCLDRCQUE0QjtBQUM1QixzQkFBc0I7QUFDdEIsMkJBQTJCO0FBQzNCLDhCQUE4QjtBQUM5QixPQUFPO0FBQ1AsYUFBYTtBQUNiLDBGQUEwRjtBQUMxRiwrQkFBK0I7QUFDL0IsY0FBYztBQUNkLE9BQU87QUFDUCxJQUFJIiwic291cmNlc0NvbnRlbnQiOlsiLy8gaW1wb3J0IFJlYWN0LCB7dXNlRWZmZWN0LCB1c2VTdGF0ZX0gZnJvbSBcInJlYWN0XCI7XG4vLyBpbXBvcnQgeyBWaWV3LCBWaWV3U3R5bGUsIFRleHQgfSBmcm9tIFwicmVhY3QtbmF0aXZlXCI7XG5cbi8vIGV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIFRleHRXaWR0aEZpbmRlciggeyBjb250ZW50IH0pIHtcbi8vICAgY29uc3QgW2Rpc3BsYXlWYWx1ZSwgc2V0RGlzcGxheVZhbHVlXSA9IHVzZVN0YXRlKCdmbGV4JylcblxuLy8gICB1c2VFZmZlY3QoKCkgPT4ge1xuLy8gICAgIGNvbnNvbGUubG9nKCdlZmZlY3QnKVxuLy8gICB9LCBbZGlzcGxheVZhbHVlXSlcblxuLy8gICBjb25zdCBvbkxheW91dCA9IGUgPT4ge1xuLy8gICAgIGNvbnNvbGUubG9nKGUpO1xuLy8gICAgIGNvbnNvbGUubG9nKGNvbnRlbnQpXG4vLyAgICAgc2V0RGlzcGxheVZhbHVlKCdub25lJylcbi8vICAgfTtcbi8vICAgcmV0dXJuIChcbi8vICAgICA8VmlldyBvbkxheW91dD17b25MYXlvdXR9IHN0eWxlPXt7YWxpZ25TZWxmOiAnZmxleC1zdGFydCcsIGRpc3BsYXk6IGRpc3BsYXlWYWx1ZX19PlxuLy8gICAgICAgPFRleHQ+e2NvbnRlbnR9PC9UZXh0PlxuLy8gICAgIDwvVmlldz5cbi8vICAgKTtcbi8vIH1cbiJdfQ== +//# 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 index 2ade2726..92ad0ef6 100644 --- a/dist/Utils.d.ts +++ b/dist/Utils.d.ts @@ -1,8 +1,2 @@ -export declare function mapValue( - x: number, - in_min: number, - in_max: number, - out_min: number, - out_max: number -): number; -//# sourceMappingURL=Utils.d.ts.map +export declare function mapValue(x: number, in_min: number, in_max: number, out_min: number, out_max: number): number; +//# sourceMappingURL=Utils.d.ts.map \ No newline at end of file diff --git a/dist/Utils.js b/dist/Utils.js index 580bd212..3b26f2f6 100644 --- a/dist/Utils.js +++ b/dist/Utils.js @@ -1,4 +1,4 @@ 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; + return ((x - in_min) * (out_max - out_min)) / (in_max - in_min) + out_min; } -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvVXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxVQUFVLFFBQVEsQ0FDdEIsQ0FBUyxFQUNULE1BQWMsRUFDZCxNQUFjLEVBQ2QsT0FBZSxFQUNmLE9BQWU7SUFFZixPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDLENBQUMsR0FBRyxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUMsR0FBRyxPQUFPLENBQUM7QUFDNUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBtYXBWYWx1ZShcbiAgeDogbnVtYmVyLFxuICBpbl9taW46IG51bWJlcixcbiAgaW5fbWF4OiBudW1iZXIsXG4gIG91dF9taW46IG51bWJlcixcbiAgb3V0X21heDogbnVtYmVyXG4pIHtcbiAgcmV0dXJuICgoeCAtIGluX21pbikgKiAob3V0X21heCAtIG91dF9taW4pKSAvIChpbl9tYXggLSBpbl9taW4pICsgb3V0X21pbjtcbn1cbiJdfQ== +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvVXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxVQUFVLFFBQVEsQ0FDdEIsQ0FBUyxFQUNULE1BQWMsRUFDZCxNQUFjLEVBQ2QsT0FBZSxFQUNmLE9BQWU7SUFFZixPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDLENBQUMsR0FBRyxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUMsR0FBRyxPQUFPLENBQUM7QUFDNUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBtYXBWYWx1ZShcbiAgeDogbnVtYmVyLFxuICBpbl9taW46IG51bWJlcixcbiAgaW5fbWF4OiBudW1iZXIsXG4gIG91dF9taW46IG51bWJlcixcbiAgb3V0X21heDogbnVtYmVyXG4pIHtcbiAgcmV0dXJuICgoeCAtIGluX21pbikgKiAob3V0X21heCAtIG91dF9taW4pKSAvIChpbl9tYXggLSBpbl9taW4pICsgb3V0X21pbjtcbn1cbiJdfQ== \ No newline at end of file diff --git a/dist/contribution-graph/ContributionGraph.d.ts b/dist/contribution-graph/ContributionGraph.d.ts index 6daa1101..b8c191a8 100644 --- a/dist/contribution-graph/ContributionGraph.d.ts +++ b/dist/contribution-graph/ContributionGraph.d.ts @@ -1,70 +1,62 @@ +import React from "react"; import { RectProps } from "react-native-svg"; import AbstractChart from "../AbstractChart"; import { ContributionGraphProps, ContributionGraphState } from "."; -export declare type ContributionChartValue = { - value: number; - title: string; - tooltipDataAttrs: TooltipDataAttrs; - date: Date; +export type ContributionChartValue = { + value: number; + title: string; + tooltipDataAttrs: TooltipDataAttrs; + date: Date; }; -export declare type TooltipDataAttrs = ( - value: ContributionChartValue -) => Partial | Partial; -declare class ContributionGraph extends AbstractChart< - ContributionGraphProps, - ContributionGraphState -> { - 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): JSX.Element; - handleDayPress(index: number): void; - renderWeek(weekIndex: number): JSX.Element; - renderAllWeeks(): JSX.Element[]; - renderMonthLabels(): JSX.Element[]; - 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(): JSX.Element; +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 +//# 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 index 0cdd6bab..37e69238 100644 --- a/dist/contribution-graph/ContributionGraph.d.ts.map +++ b/dist/contribution-graph/ContributionGraph.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"ContributionGraph.d.ts","sourceRoot":"","sources":["../../src/contribution-graph/ContributionGraph.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAW,SAAS,EAAa,MAAM,kBAAkB,CAAC;AAEjE,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAY7C,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,GAAG,CAAC;AAMnE,oBAAY,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,oBAAY,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 +{"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 index 9f12635d..69610274 100644 --- a/dist/contribution-graph/ContributionGraph.js +++ b/dist/contribution-graph/ContributionGraph.js @@ -1,400 +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 (b.hasOwnProperty(p)) d[p] = b[p]; - }; - return extendStatics(d, b); - }; - return function(d, b) { - 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) { +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]; + 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"; +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) +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 memo; - }, {}), - minValue: minValue, - maxValue: maxValue - }; - }; - ContributionGraph.prototype.getValueForIndex = function(index) { - if (this.state.valueCache[index]) { - return this.state.valueCache[index].value; + return _this; } - 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.minValue, - this.state.maxValue, - 0.15 + 0.05, // + 0.05 to make smaller values a bit more visible - 1 - ); - return this.props.chartConfig.color(opacity); + 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; } - } - } - 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 this.getWeekWidth() + MONTH_LABEL_GUTTER_SIZE + ", 0"; - }; - ContributionGraph.prototype.getTransformForAllWeeks = function() { - if (this.props.horizontal) { - return "0, " + (this.getMonthLabelSize() - 100); - } - return null; - }; - ContributionGraph.prototype.getViewBox = function() { - if (this.props.horizontal) { - return this.getWidth() + " " + this.getHeight(); - } - return this.getHeight() + " " + 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 ? ( - + 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.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.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); + ); + }; + 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.minValue,\n            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={borderRadius}\n            ry={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"]} +//# 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 index 3e55a4fe..e2264678 100644 --- a/dist/contribution-graph/DateHelpers.d.ts +++ b/dist/contribution-graph/DateHelpers.d.ts @@ -1,4 +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 +//# sourceMappingURL=DateHelpers.d.ts.map \ No newline at end of file diff --git a/dist/contribution-graph/DateHelpers.js b/dist/contribution-graph/DateHelpers.js index bad97a3d..da306162 100644 --- a/dist/contribution-graph/DateHelpers.js +++ b/dist/contribution-graph/DateHelpers.js @@ -1,14 +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; + 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()); + 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); + return obj instanceof Date ? obj : new Date(obj); } -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGF0ZUhlbHBlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJpYnV0aW9uLWdyYXBoL0RhdGVIZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHdFQUF3RTtBQUN4RSxNQUFNLFVBQVUsU0FBUyxDQUFDLElBQVUsRUFBRSxPQUFlO0lBQ25ELElBQU0sT0FBTyxHQUFHLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQy9CLE9BQU8sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxHQUFHLE9BQU8sQ0FBQyxDQUFDO0lBQzdDLE9BQU8sT0FBTyxDQUFDO0FBQ2pCLENBQUM7QUFFRCxNQUFNLFVBQVUsdUJBQXVCLENBQUMsSUFBVTtJQUNoRCxPQUFPLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsRUFBRSxJQUFJLENBQUMsUUFBUSxFQUFFLEVBQUUsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7QUFDdkUsQ0FBQztBQUVELDJFQUEyRTtBQUMzRSxNQUFNLFVBQVUsYUFBYSxDQUFDLEdBQTJCO0lBQ3ZELE9BQU8sR0FBRyxZQUFZLElBQUksQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNuRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gcmV0dXJucyBhIG5ldyBkYXRlIHNoaWZ0ZWQgYSBjZXJ0YWluIG51bWJlciBvZiBkYXlzIChjYW4gYmUgbmVnYXRpdmUpXG5leHBvcnQgZnVuY3Rpb24gc2hpZnREYXRlKGRhdGU6IERhdGUsIG51bURheXM6IG51bWJlcikge1xuICBjb25zdCBuZXdEYXRlID0gbmV3IERhdGUoZGF0ZSk7XG4gIG5ld0RhdGUuc2V0RGF0ZShuZXdEYXRlLmdldERhdGUoKSArIG51bURheXMpO1xuICByZXR1cm4gbmV3RGF0ZTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldEJlZ2lubmluZ1RpbWVGb3JEYXRlKGRhdGU6IERhdGUpIHtcbiAgcmV0dXJuIG5ldyBEYXRlKGRhdGUuZ2V0RnVsbFllYXIoKSwgZGF0ZS5nZXRNb250aCgpLCBkYXRlLmdldERhdGUoKSk7XG59XG5cbi8vIG9iaiBjYW4gYmUgYSBwYXJzZWFibGUgc3RyaW5nLCBhIG1pbGxpc2Vjb25kIHRpbWVzdGFtcCwgb3IgYSBEYXRlIG9iamVjdFxuZXhwb3J0IGZ1bmN0aW9uIGNvbnZlcnRUb0RhdGUob2JqOiBzdHJpbmcgfCBudW1iZXIgfCBEYXRlKSB7XG4gIHJldHVybiBvYmogaW5zdGFuY2VvZiBEYXRlID8gb2JqIDogbmV3IERhdGUob2JqKTtcbn1cbiJdfQ== +//# 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 index 2f86932f..8b779037 100644 --- a/dist/contribution-graph/constants.d.ts +++ b/dist/contribution-graph/constants.d.ts @@ -1,17 +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; + 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 +//# sourceMappingURL=constants.d.ts.map \ No newline at end of file diff --git a/dist/contribution-graph/constants.js b/dist/contribution-graph/constants.js index 38a2e98f..7bc386b2 100644 --- a/dist/contribution-graph/constants.js +++ b/dist/contribution-graph/constants.js @@ -1,17 +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" + 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 +//# 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 index a9f8650b..79669fdb 100644 --- a/dist/contribution-graph/index.d.ts +++ b/dist/contribution-graph/index.d.ts @@ -1,38 +1,32 @@ import { ViewStyle } from "react-native"; import { AbstractChartProps } from "../AbstractChart"; -import ContributionGraph, { - ContributionChartValue, - TooltipDataAttrs -} from "./ContributionGraph"; +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?: ({ - count: number, - date: Date - }: { - count: any; - date: any; - }) => void; - classForValue?: (value: string) => string; - style?: Partial; - titleForValue?: (value: ContributionChartValue) => string; - tooltipDataAttrs: TooltipDataAttrs; + 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 declare type ContributionGraphState = { - maxValue: number; - minValue: number; - valueCache: object; +export type ContributionGraphState = { + maxValue: number; + minValue: number; + valueCache: object; }; export default ContributionGraph; -//# sourceMappingURL=index.d.ts.map +//# 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 index 94b6293d..6859f099 100644 --- a/dist/contribution-graph/index.d.ts.map +++ b/dist/contribution-graph/index.d.ts.map @@ -1 +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,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE;;;KAAA,KAAK,IAAI,CAAC;IACrD,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,oBAAY,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 +{"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 index 4a3c3002..faaf1fe8 100644 --- a/dist/contribution-graph/index.js +++ b/dist/contribution-graph/index.js @@ -1,3 +1,3 @@ import ContributionGraph from "./ContributionGraph"; export default ContributionGraph; -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJpYnV0aW9uLWdyYXBoL2luZGV4LnRzeCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLGlCQUdOLE1BQU0scUJBQXFCLENBQUM7QUE0QjdCLGVBQWUsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBWaWV3U3R5bGUgfSBmcm9tIFwicmVhY3QtbmF0aXZlXCI7XG5cbmltcG9ydCB7IEFic3RyYWN0Q2hhcnRQcm9wcyB9IGZyb20gXCIuLi9BYnN0cmFjdENoYXJ0XCI7XG5pbXBvcnQgQ29udHJpYnV0aW9uR3JhcGgsIHtcbiAgQ29udHJpYnV0aW9uQ2hhcnRWYWx1ZSxcbiAgVG9vbHRpcERhdGFBdHRyc1xufSBmcm9tIFwiLi9Db250cmlidXRpb25HcmFwaFwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIENvbnRyaWJ1dGlvbkdyYXBoUHJvcHMgZXh0ZW5kcyBBYnN0cmFjdENoYXJ0UHJvcHMge1xuICB2YWx1ZXM6IEFycmF5PGFueT47XG4gIGVuZERhdGU6IERhdGU7XG4gIG51bURheXM6IG51bWJlcjtcbiAgd2lkdGg6IG51bWJlcjtcbiAgaGVpZ2h0OiBudW1iZXI7XG4gIGd1dHRlclNpemU/OiBudW1iZXI7XG4gIHNxdWFyZVNpemU/OiBudW1iZXI7XG4gIGhvcml6b250YWw/OiBib29sZWFuO1xuICBzaG93TW9udGhMYWJlbHM/OiBib29sZWFuO1xuICBzaG93T3V0T2ZSYW5nZURheXM/OiBib29sZWFuO1xuICBhY2Nlc3Nvcj86IHN0cmluZztcbiAgZ2V0TW9udGhMYWJlbD86IChtb250aEluZGV4OiBudW1iZXIpID0+IHN0cmluZztcbiAgb25EYXlQcmVzcz86ICh7IGNvdW50OiBudW1iZXIsIGRhdGU6IERhdGUgfSkgPT4gdm9pZDtcbiAgY2xhc3NGb3JWYWx1ZT86ICh2YWx1ZTogc3RyaW5nKSA9PiBzdHJpbmc7XG4gIHN0eWxlPzogUGFydGlhbDxWaWV3U3R5bGU+O1xuICB0aXRsZUZvclZhbHVlPzogKHZhbHVlOiBDb250cmlidXRpb25DaGFydFZhbHVlKSA9PiBzdHJpbmc7XG4gIHRvb2x0aXBEYXRhQXR0cnM6IFRvb2x0aXBEYXRhQXR0cnM7XG59XG5cbmV4cG9ydCB0eXBlIENvbnRyaWJ1dGlvbkdyYXBoU3RhdGUgPSB7XG4gIG1heFZhbHVlOiBudW1iZXI7XG4gIG1pblZhbHVlOiBudW1iZXI7XG4gIHZhbHVlQ2FjaGU6IG9iamVjdDtcbn07XG5cbmV4cG9ydCBkZWZhdWx0IENvbnRyaWJ1dGlvbkdyYXBoO1xuIl19 +//# 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 index 7581680e..e36bf34e 100644 --- a/dist/index.d.ts +++ b/dist/index.d.ts @@ -5,13 +5,5 @@ 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 +export { AbstractChart, BarChart, LineChart, PieChart, ProgressChart, ContributionGraph, StackedBarChart }; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/dist/index.js b/dist/index.js index ff143602..07b1fbbb 100644 --- a/dist/index.js +++ b/dist/index.js @@ -5,13 +5,5 @@ 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= +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 index 14d0a857..50726f2d 100644 --- a/dist/line-chart/LegendItem.d.ts +++ b/dist/line-chart/LegendItem.d.ts @@ -1,11 +1,14 @@ -import { Color, TextProps } from "react-native-svg"; -export declare type LegendItemProps = { - baseLegendItemX: number; - index: number; - legendOffset: number; - legendText: string; - iconColor: Color; - labelProps: TextProps; +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) => JSX.Element; -//# sourceMappingURL=LegendItem.d.ts.map +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 index 0c993140..b33194db 100644 --- a/dist/line-chart/LegendItem.d.ts.map +++ b/dist/line-chart/LegendItem.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"LegendItem.d.ts","sourceRoot":"","sources":["../../src/line-chart/LegendItem.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAMhE,oBAAY,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,UAAW,eAAe,gBAmChD,CAAC"} \ No newline at end of file +{"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 index 7a01cb37..c1040090 100644 --- a/dist/line-chart/LegendItem.js +++ b/dist/line-chart/LegendItem.js @@ -3,40 +3,21 @@ 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 +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 ( - <> - - + 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTGVnZW5kSXRlbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9saW5lLWNoYXJ0L0xlZ2VuZEl0ZW0udHN4Il0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxNQUFNLE9BQU8sQ0FBQztBQUMxQixPQUFPLEVBQVMsSUFBSSxFQUFFLElBQUksRUFBYSxNQUFNLGtCQUFrQixDQUFDO0FBRWhFLElBQU0sWUFBWSxHQUFHLEVBQUUsQ0FBQztBQUN4QixJQUFNLFlBQVksR0FBRyxDQUFDLENBQUM7QUFDdkIsSUFBTSxlQUFlLEdBQUcsQ0FBQyxDQUFDO0FBVzFCLE1BQU0sQ0FBQyxJQUFNLFVBQVUsR0FBRyxVQUFDLEtBQXNCO0lBQ3ZDLElBQUEsZUFBZSxHQUFZLEtBQUssZ0JBQWpCLEVBQUUsS0FBSyxHQUFLLEtBQUssTUFBVixDQUFXO0lBQ3pDO3NEQUNrRDtJQUNsRCxJQUFNLG1CQUFtQixHQUFHLEtBQUssQ0FBQyxZQUFZLEdBQUcsQ0FBQyxHQUFHLFlBQVksR0FBRyxDQUFDLENBQUM7SUFDdEUsaUZBQWlGO0lBQ2pGLElBQU0saUJBQWlCLEdBQUcsS0FBSyxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUM7SUFDcEQsa0RBQWtEO0lBQ2xELElBQU0sZ0JBQWdCLEdBQUcsQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLE1BQU0sR0FBRyxlQUFlLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDekUsSUFBTSxnQkFBZ0IsR0FBRyxLQUFLLEdBQUcsQ0FBQyxDQUFDO0lBRW5DLE9BQU8sQ0FDTCxFQUNFO01BQUEsQ0FBQyxJQUFJLENBQ0gsS0FBSyxDQUFDLENBQUMsWUFBWSxDQUFDLENBQ3BCLE1BQU0sQ0FBQyxDQUFDLFlBQVksQ0FBQyxDQUNyQixJQUFJLENBQUMsQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQ3RCLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUNOLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUNOLENBQUMsQ0FBQyxDQUNBLGVBQWUsR0FBRyxnQkFBZ0IsR0FBRyxDQUFDLFlBQVksR0FBRyxnQkFBZ0IsQ0FBQyxDQUN2RSxDQUNELENBQUMsQ0FBQyxDQUFDLG1CQUFtQixDQUFDLEVBRXpCO01BQUEsQ0FBQyxJQUFJLENBQ0gsQ0FBQyxDQUFDLENBQ0EsZUFBZSxHQUFHLGdCQUFnQixHQUFHLENBQUMsWUFBWSxHQUFHLGdCQUFnQixDQUFDLENBQ3ZFLENBQ0QsQ0FBQyxDQUFDLENBQUMsaUJBQWlCLENBQUMsQ0FDckIsSUFBSSxLQUFLLENBQUMsVUFBVSxDQUFDLENBRXJCO1FBQUEsQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUNuQjtNQUFBLEVBQUUsSUFBSSxDQUNSO0lBQUEsR0FBRyxDQUNKLENBQUM7QUFDSixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgUmVhY3QgZnJvbSBcInJlYWN0XCI7XG5pbXBvcnQgeyBDb2xvciwgUmVjdCwgVGV4dCwgVGV4dFByb3BzIH0gZnJvbSBcInJlYWN0LW5hdGl2ZS1zdmdcIjtcblxuY29uc3QgQ0lSQ0xFX1dJRFRIID0gMTY7XG5jb25zdCBQQURESU5HX0xFRlQgPSA0O1xuY29uc3QgQ0hBUkFDVEVSX1dJRFRIID0gNjtcblxuZXhwb3J0IHR5cGUgTGVnZW5kSXRlbVByb3BzID0ge1xuICBiYXNlTGVnZW5kSXRlbVg6IG51bWJlcjtcbiAgaW5kZXg6IG51bWJlcjtcbiAgbGVnZW5kT2Zmc2V0OiBudW1iZXI7XG4gIGxlZ2VuZFRleHQ6IHN0cmluZztcbiAgaWNvbkNvbG9yOiBDb2xvcjtcbiAgbGFiZWxQcm9wczogVGV4dFByb3BzO1xufTtcblxuZXhwb3J0IGNvbnN0IExlZ2VuZEl0ZW0gPSAocHJvcHM6IExlZ2VuZEl0ZW1Qcm9wcykgPT4ge1xuICBjb25zdCB7IGJhc2VMZWdlbmRJdGVtWCwgaW5kZXggfSA9IHByb3BzO1xuICAvKiBoYWxmIHRoZSBoZWlnaHQgb2YgdGhlIGxlZ2VuZCBSZWN0LCBtaW51cyBoYWxmIHRoZSBoZWlnaHQgb2YgdGhlIGNpcmNsZSB0byBhbGlnbiB0aGVcbiAgICAgY2lyY2xlIGZyb20gaXRzIGNlbnRlciwgcmF0aGVyIHRoYW4gaXRzIHRvcC4gKi9cbiAgY29uc3QgY2VudGVyQWxpZ25lZENpcmNsZSA9IHByb3BzLmxlZ2VuZE9mZnNldCAvIDIgLSBDSVJDTEVfV0lEVEggLyAyO1xuICAvLyA2NSUgb2YgdGhlIGxlZ2VuZCBjb250YWluZXIgaGVpZ2h0IGNlbnRlcnMgdGhlIHRleHQgaW4gcmVsYXRpb24gdG8gdGhlIGNpcmNsZXNcbiAgY29uc3QgY2VudGVyQWxpZ25lZFRleHQgPSBwcm9wcy5sZWdlbmRPZmZzZXQgKiAwLjY1O1xuICAvLyB0byBjZW50ZXIgdGhlIGxlZ2VuZEl0ZW0gb24gdGhlIGJhc2VMZWdlbmRJdGVtWFxuICBjb25zdCB0ZXh0TGVuZ3RoT2Zmc2V0ID0gKHByb3BzLmxlZ2VuZFRleHQubGVuZ3RoICogQ0hBUkFDVEVSX1dJRFRIKSAvIDI7XG4gIGNvbnN0IGxlZ2VuZEl0ZW1OdW1iZXIgPSBpbmRleCArIDE7XG5cbiAgcmV0dXJuIChcbiAgICA8PlxuICAgICAgPFJlY3RcbiAgICAgICAgd2lkdGg9e0NJUkNMRV9XSURUSH1cbiAgICAgICAgaGVpZ2h0PXtDSVJDTEVfV0lEVEh9XG4gICAgICAgIGZpbGw9e3Byb3BzLmljb25Db2xvcn1cbiAgICAgICAgcng9ezh9XG4gICAgICAgIHJ5PXs4fVxuICAgICAgICB4PXtcbiAgICAgICAgICBiYXNlTGVnZW5kSXRlbVggKiBsZWdlbmRJdGVtTnVtYmVyIC0gKENJUkNMRV9XSURUSCArIHRleHRMZW5ndGhPZmZzZXQpXG4gICAgICAgIH1cbiAgICAgICAgeT17Y2VudGVyQWxpZ25lZENpcmNsZX1cbiAgICAgIC8+XG4gICAgICA8VGV4dFxuICAgICAgICB4PXtcbiAgICAgICAgICBiYXNlTGVnZW5kSXRlbVggKiBsZWdlbmRJdGVtTnVtYmVyICsgKFBBRERJTkdfTEVGVCAtIHRleHRMZW5ndGhPZmZzZXQpXG4gICAgICAgIH1cbiAgICAgICAgeT17Y2VudGVyQWxpZ25lZFRleHR9XG4gICAgICAgIHsuLi5wcm9wcy5sYWJlbFByb3BzfVxuICAgICAgPlxuICAgICAgICB7cHJvcHMubGVnZW5kVGV4dH1cbiAgICAgIDwvVGV4dD5cbiAgICA8Lz5cbiAgKTtcbn07XG4iXX0= +//# 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 index 806eb47e..34366eff 100644 --- a/dist/line-chart/LineChart.d.ts +++ b/dist/line-chart/LineChart.d.ts @@ -1,302 +1,223 @@ import React from "react"; import { Animated, TextInput, ViewStyle } from "react-native"; -import AbstractChart, { - AbstractChartConfig, - AbstractChartProps -} from "../AbstractChart"; +import AbstractChart, { AbstractChartConfig, AbstractChartProps } from "../AbstractChart"; import { ChartData, Dataset } from "../HelperTypes"; export interface LineChartData extends ChartData { - legend?: string[]; + 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; + /** + * 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; } -declare type LineChartState = { - scrollableDotHorizontalOffset: Animated.Value; +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< - AbstractChartConfig, - "data" | "width" | "height" | "paddingTop" | "paddingRight" - > & { - 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< - AbstractChartConfig, - "data" | "width" | "height" | "paddingTop" | "paddingRight" - > & { - useColorFromDataset: AbstractChartConfig["useShadowColorFromDataset"]; - }) => JSX.Element[]; - renderLine: ({ - width, - height, - paddingRight, - paddingTop, - data, - linejoinType - }: Pick< - AbstractChartConfig, - "data" | "width" | "height" | "paddingRight" | "paddingTop" | "linejoinType" - >) => any[]; - getBezierLinePoints: ( - dataset: Dataset, - { - width, - height, - paddingRight, - paddingTop, - data - }: Pick< - AbstractChartConfig, - "width" | "height" | "paddingRight" | "paddingTop" | "data" - > - ) => string; - renderBezierLine: ({ - data, - width, - height, - paddingRight, - paddingTop - }: Pick< - AbstractChartConfig, - "data" | "width" | "height" | "paddingRight" | "paddingTop" - >) => JSX.Element[]; - renderBezierShadow: ({ - width, - height, - paddingRight, - paddingTop, - data, - useColorFromDataset - }: Pick< - AbstractChartConfig, - "data" | "width" | "height" | "paddingTop" | "paddingRight" - > & { - useColorFromDataset: AbstractChartConfig["useShadowColorFromDataset"]; - }) => JSX.Element[]; - renderLegend: (width: any, legendOffset: any) => JSX.Element[]; - render(): JSX.Element; + 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 +//# 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 index 19cc1b5a..b8ffca0e 100644 --- a/dist/line-chart/LineChart.d.ts.map +++ b/dist/line-chart/LineChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"LineChart.d.ts","sourceRoot":"","sources":["../../src/line-chart/LineChart.tsx"],"names":[],"mappings":"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"} \ No newline at end of file +{"version":3,"file":"LineChart.d.ts","sourceRoot":"","sources":["../../src/line-chart/LineChart.tsx"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/dist/line-chart/LineChart.js b/dist/line-chart/LineChart.js index c37bd76c..54beeff8 100644 --- a/dist/line-chart/LineChart.js +++ b/dist/line-chart/LineChart.js @@ -1,837 +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 (b.hasOwnProperty(p)) d[p] = b[p]; - }; - return extendStatics(d, b); +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) { - extendStatics(d, b); - function __() { - this.constructor = d; - } - d.prototype = - b === null - ? Object.create(b) - : ((__.prototype = b.prototype), new __()); + 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) { +})(); +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]; + 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 __spreadArrays = - (this && this.__spreadArrays) || - function() { - for (var s = 0, i = 0, il = arguments.length; i < il; i++) - s += arguments[i].length; - for (var r = Array(s), k = 0, i = 0; i < il; i++) - for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) - r[k] = a[j]; - return r; - }; +}; +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 { 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 ? __spreadArrays(acc, item.data) : 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; - 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)) / dataset.data.length; - var cy = - ((baseHeight - _this.calcHeight(x, datas, height)) / 4) * 3 + - paddingTop; - var onPress = function() { - if (!onDataPointClick || hidePointsAtIndex.includes(i)) { - return; +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); } - onDataPointClick({ - index: i, - value: x, - dataset: dataset, - x: cx, - y: cy, - getColor: function(opacity) { - return _this.getColor(dataset, opacity); - } + 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 })); + }); }); - }; - 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 "" + 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) - ) - }); + 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); } - } 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) - ) - }); + 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 + }); } - } - } - 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([ - - ); + }); + }; + _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 }); - }} - style={scrollableInfoTextStyle} - ref={_this.label} - /> - , - - ]); - }); - 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 ( - ); + }); + 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"; } - strokeWidth={0} - /> - ); - }); - }; - _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 lastPoint; - data.forEach(function(dataset, index) { - var points = dataset.data.map(function(d, i) { - if (d === null) return lastPoint; - var x = - (i * (width - paddingRight)) / dataset.data.length + paddingRight; - var y = - ((baseHeight - _this.calcHeight(d, datas, height)) / 4) * 3 + - paddingTop; - lastPoint = x + "," + y; - return x + "," + y; - }); - output.push( - - ); - }); - return output; - }; - _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 x = function(i) { - return Math.floor( - paddingRight + (i * (width - paddingRight)) / dataset.data.length - ); - }; - 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" + x(0) + "," + 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 " + - cp_x1 + - ", " + - y(i) + - ", " + - x_mid + - ", " + - y_mid + - (" Q " + - cp_x2 + - ", " + - y(i + 1) + - ", " + - x(i + 1) + - ", " + - 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 d = - _this.getBezierLinePoints(dataset, { + 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, - paddingRight: paddingRight, - paddingTop: paddingTop, - data: data - }) + - (" L" + - (paddingRight + - ((width - paddingRight) / dataset.data.length) * - (dataset.data.length - 1)) + - "," + - ((height / 4) * 3 + paddingTop) + - " L" + - paddingRight + - "," + - ((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 ( - - - + 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.renderLegend(config.width, legendOffset)} - {this.renderDefs( - __assign(__assign(__assign({}, config), chartConfig), { - data: data.datasets - }) - )} + {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)} + ? 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 - }) - )} + 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)} + ? 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.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 - }) - )} + {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 - }) - )} + 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 - }) - )} + 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 - }) - )} + 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 - }) - )} + decorator(__assign(__assign({}, config), { data: data.datasets, paddingTop: paddingTop, paddingRight: paddingRight }))} - {withScrollableDot && ( - - )} - - ); - }; - return LineChart; -})(AbstractChart); + {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\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 =\n          paddingRight + (i * (width - paddingRight)) / dataset.data.length;\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(#fillShadowGradient${\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\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 =\n          (i * (width - paddingRight)) / dataset.data.length + 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  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\n    const x = (i: number) =>\n      Math.floor(\n        paddingRight + (i * (width - paddingRight)) / dataset.data.length\n      );\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 d =\n        this.getBezierLinePoints(dataset, {\n          width,\n          height,\n          paddingRight,\n          paddingTop,\n          data\n        }) +\n        ` L${paddingRight +\n          ((width - paddingRight) / dataset.data.length) *\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(#fillShadowGradient${\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={borderRadius}\n            ry={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            ])}\n            horizontal\n            bounces={false}\n          />\n        )}\n      </View>\n    );\n  }\n}\n\nexport default LineChart;\n"]} +//# 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 index 749e0edf..48a943e3 100644 --- a/dist/line-chart/index.d.ts +++ b/dist/line-chart/index.d.ts @@ -1,3 +1,3 @@ import LineChart from "./LineChart"; export default LineChart; -//# sourceMappingURL=index.d.ts.map +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/dist/line-chart/index.js b/dist/line-chart/index.js index 0509935a..eb05d08f 100644 --- a/dist/line-chart/index.js +++ b/dist/line-chart/index.js @@ -1,3 +1,3 @@ import LineChart from "./LineChart"; export default LineChart; -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbGluZS1jaGFydC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLFNBQVMsTUFBTSxhQUFhLENBQUM7QUFFcEMsZUFBZSxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgTGluZUNoYXJ0IGZyb20gXCIuL0xpbmVDaGFydFwiO1xuXG5leHBvcnQgZGVmYXVsdCBMaW5lQ2hhcnQ7XG4iXX0= +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbGluZS1jaGFydC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLFNBQVMsTUFBTSxhQUFhLENBQUM7QUFFcEMsZUFBZSxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgTGluZUNoYXJ0IGZyb20gXCIuL0xpbmVDaGFydFwiO1xuXG5leHBvcnQgZGVmYXVsdCBMaW5lQ2hhcnQ7XG4iXX0= \ No newline at end of file diff --git a/package.json b/package.json index 9d3571a7..352be36b 100644 --- a/package.json +++ b/package.json @@ -2,29 +2,29 @@ "name": "@adalo/react-native-chart-kit", "version": "6.11.0", "devDependencies": { - "@types/react-native": "^0.62.13", - "babel-eslint": "10.x", - "babel-plugin-module-resolver": "^3.1.1", + "@types/react-native": "^0.73.0", + "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": "0.77.2", + "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": "^14.1.0", + "react-test-renderer": "18.2.0", + "typescript": "^5.3.3" }, "_main": "./node_modules/expo/AppEntry.js", "main": "./dist/index.js", @@ -47,12 +47,12 @@ "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": ">= 14.1.0" }, "dependencies": { - "lodash": "^4.17.13", + "lodash": "^4.17.21", "paths-js": "^0.4.10", "point-in-polygon": "^1.0.1" }, @@ -68,6 +68,6 @@ "url": "https://github.com/AdaloHQ/react-native-chart-kit" }, "resolutions": { - "@types/react": "16.14.8" + "@types/react": "^18.2.0" } } diff --git a/src/BarChart.tsx b/src/BarChart.tsx index 9af3a8b7..ec2d9e2a 100644 --- a/src/BarChart.tsx +++ b/src/BarChart.tsx @@ -271,8 +271,8 @@ class BarChart extends AbstractChart { diff --git a/src/PieChart.tsx b/src/PieChart.tsx index d0db56ca..15fb2222 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -358,8 +358,8 @@ class PieChart extends AbstractChart { width={16} height={16} fill={c.item.color} - rx={8} - ry={8} + rx={Number(8)} + ry={Number(8)} x={ this.props.width / (100 / (chartWidthPercentage * 100) + 0.5) - 24 @@ -421,8 +421,8 @@ class PieChart extends AbstractChart { { Number(this.props.paddingLeft ? this.props.paddingLeft : 0) } y={this.props.height / 2} - // @ts-expect-error width={this.props.width} > {slices} 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/contribution-graph/ContributionGraph.tsx b/src/contribution-graph/ContributionGraph.tsx index 62f7d742..430cdecc 100644 --- a/src/contribution-graph/ContributionGraph.tsx +++ b/src/contribution-graph/ContributionGraph.tsx @@ -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 895e911a..5de2c988 100644 --- a/src/line-chart/LineChart.tsx +++ b/src/line-chart/LineChart.tsx @@ -854,8 +854,8 @@ class LineChart extends AbstractChart { From 36305da8961bf0f938905e1c23e586e7348fdb70 Mon Sep 17 00:00:00 2001 From: Alex Kalashnik Date: Tue, 8 Apr 2025 14:24:11 +0300 Subject: [PATCH 76/86] Add resolutions --- package.json | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/package.json b/package.json index 352be36b..a58a18e2 100644 --- a/package.json +++ b/package.json @@ -68,6 +68,8 @@ "url": "https://github.com/AdaloHQ/react-native-chart-kit" }, "resolutions": { - "@types/react": "^18.2.0" + "@types/react": "^18.2.0", + "react": "18.2.0", + "react-dom": "18.2.0" } } From 918c24fbc1f3531f9856cc65543356db4df610e9 Mon Sep 17 00:00:00 2001 From: Alex Kalashnik Date: Tue, 8 Apr 2025 15:20:13 +0300 Subject: [PATCH 77/86] Add resolutions --- dist/AbstractChart.d.ts | 6 ++++++ dist/AbstractChart.d.ts.map | 2 +- package.json | 8 +++----- 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/dist/AbstractChart.d.ts b/dist/AbstractChart.d.ts index 7d6eb3e9..f56a03b7 100644 --- a/dist/AbstractChart.d.ts +++ b/dist/AbstractChart.d.ts @@ -58,6 +58,7 @@ declare class AbstractChart void; accessibilityLabel?: string; accessible?: boolean; @@ -150,6 +152,7 @@ declare class AbstractChart void; accessibilityLabel?: string; accessible?: boolean; @@ -242,6 +246,7 @@ declare class AbstractChart void; accessibilityLabel?: string; accessible?: boolean; diff --git a/dist/AbstractChart.d.ts.map b/dist/AbstractChart.d.ts.map index a9b702cd..7bed16ce 100644 --- a/dist/AbstractChart.d.ts.map +++ b/dist/AbstractChart.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"AbstractChart.d.ts","sourceRoot":"","sources":["../src/AbstractChart.tsx"],"names":[],"mappings":"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"} \ No newline at end of file +{"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/package.json b/package.json index a58a18e2..eac4e6dc 100644 --- a/package.json +++ b/package.json @@ -22,9 +22,9 @@ "react-native": "0.77.2", "react-native-flash-message": "^0.4.0", "react-native-scrollable-tab-view": "^1.0.0", - "react-native-svg": "^14.1.0", + "react-native-svg": "^15.11.2", "react-test-renderer": "18.2.0", - "typescript": "^5.3.3" + "typescript": "^5.8.3" }, "_main": "./node_modules/expo/AppEntry.js", "main": "./dist/index.js", @@ -68,8 +68,6 @@ "url": "https://github.com/AdaloHQ/react-native-chart-kit" }, "resolutions": { - "@types/react": "^18.2.0", - "react": "18.2.0", - "react-dom": "18.2.0" + "@types/react": "^18.2.0" } } From b875380cb09e4bf8455658332ce24fc4559c1d65 Mon Sep 17 00:00:00 2001 From: Alex Kalashnik Date: Thu, 24 Apr 2025 16:00:03 +0300 Subject: [PATCH 78/86] Change logs --- package.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/package.json b/package.json index eac4e6dc..4167fa2d 100644 --- a/package.json +++ b/package.json @@ -2,7 +2,7 @@ "name": "@adalo/react-native-chart-kit", "version": "6.11.0", "devDependencies": { - "@types/react-native": "^0.73.0", + "@types/react-native": "0.72", "babel-eslint": "^10.1.0", "babel-plugin-module-resolver": "^5.0.0", "babel-polyfill": "^6.26.0", @@ -19,7 +19,7 @@ "prettier": "^3.2.5", "pretty-quick": "^4.0.0", "react": "18.2.0", - "react-native": "0.77.2", + "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": "^15.11.2", @@ -49,7 +49,7 @@ "peerDependencies": { "react": ">= 18.2.0", "react-native": ">= 0.77.2", - "react-native-svg": ">= 14.1.0" + "react-native-svg": ">= 15.11.2" }, "dependencies": { "lodash": "^4.17.21", From 25bca701733db3719b0d2e508cc65a87d5b28388 Mon Sep 17 00:00:00 2001 From: Alex Kalashnik Date: Thu, 24 Apr 2025 17:22:09 +0300 Subject: [PATCH 79/86] Temp add logs --- src/PieChart.tsx | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 15fb2222..0316847e 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -343,6 +343,9 @@ class PieChart extends AbstractChart { ? c.item.legendFontColor : "transparent"; + console.log("c.item: ", c.item) + console.log("this.state: ", this.state) + return ( Date: Fri, 25 Apr 2025 12:35:12 +0300 Subject: [PATCH 80/86] Add manually resolution for pie chart --- src/PieChart.tsx | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 0316847e..6bed8e81 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -343,8 +343,13 @@ class PieChart extends AbstractChart { ? c.item.legendFontColor : "transparent"; + if (typeof c?.item?.color === "string" && c.item.color.includes('hsl')) { + c.item.color = c.item.color.replace('%', '') + } + console.log("c.item: ", c.item) console.log("this.state: ", this.state) + console.log("backgroundColor: ", backgroundColor) return ( From 108a03604bb8530ab41eaf0254c835a492748f14 Mon Sep 17 00:00:00 2001 From: Alex Kalashnik Date: Fri, 25 Apr 2025 12:42:48 +0300 Subject: [PATCH 81/86] Map hsl color to rgb --- src/PieChart.tsx | 3 ++- src/Utils.ts | 32 ++++++++++++++++++++++++++++++++ 2 files changed, 34 insertions(+), 1 deletion(-) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index 6bed8e81..c5f44acc 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -5,6 +5,7 @@ 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"; // import TextWidthFinder from "./TextWidthFinder"; export interface PieChartProps extends AbstractChartProps { @@ -344,7 +345,7 @@ class PieChart extends AbstractChart { : "transparent"; if (typeof c?.item?.color === "string" && c.item.color.includes('hsl')) { - c.item.color = c.item.color.replace('%', '') + c.item.color = hslToRgba(c.item.color) } console.log("c.item: ", c.item) diff --git a/src/Utils.ts b/src/Utils.ts index 00816a48..1cc23da9 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+),\s*(\d+)%,\s*(\d+)%(?:,\s*([\d.]+)\s*)?\)/i); + + if (!matches) { + return '#000000'; + } + + const h = parseInt(matches[1]); + const s = parseInt(matches[2]) / 100; + const l = parseInt(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})`; +} From 668c20ef524f19b4906c11e49cd860270451ba6c Mon Sep 17 00:00:00 2001 From: Alex Kalashnik Date: Fri, 25 Apr 2025 12:43:42 +0300 Subject: [PATCH 82/86] Update build --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 10 +++++++++- dist/Utils.d.ts | 1 + dist/Utils.d.ts.map | 2 +- dist/Utils.js | 33 ++++++++++++++++++++++++++++++++- 5 files changed, 44 insertions(+), 4 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 28bb6538..0a7a3681 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +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,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CA4UP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"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;AAIpE,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,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CAoVP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index fac41fa2..3cd4b262 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -39,6 +39,7 @@ 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 @@ -247,6 +248,7 @@ var PieChart = /** @class */ (function (_super) { chartCurvesSorted.push(otherSlice); } var slices = chartCurvesSorted.map(function (c, i) { + var _a; var value; if (absolute) { if (_this.props.showLabelPrefix) { @@ -278,6 +280,12 @@ var PieChart = /** @class */ (function (_super) { 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); + } + console.log("c.item: ", c.item); + console.log("this.state: ", _this.state); + console.log("backgroundColor: ", backgroundColor); return ( Date: Fri, 25 Apr 2025 12:46:46 +0300 Subject: [PATCH 83/86] add logs --- src/PieChart.tsx | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/PieChart.tsx b/src/PieChart.tsx index c5f44acc..c629e5c5 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -344,6 +344,8 @@ class PieChart extends AbstractChart { ? c.item.legendFontColor : "transparent"; + console.log("c.item before: ", c.item) + if (typeof c?.item?.color === "string" && c.item.color.includes('hsl')) { c.item.color = hslToRgba(c.item.color) } From 89d99e93aa6930ce65016298ce2f734ee724499d Mon Sep 17 00:00:00 2001 From: Alex Kalashnik Date: Fri, 25 Apr 2025 12:58:38 +0300 Subject: [PATCH 84/86] Upgrade component and remove logs --- dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 5 +---- dist/Utils.js | 10 +++++----- src/PieChart.tsx | 6 ------ src/Utils.ts | 8 ++++---- 5 files changed, 11 insertions(+), 20 deletions(-) diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 0a7a3681..1bd97cfd 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +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;AAIpE,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,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CAoVP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"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;AAIpE,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,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CAgVP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file diff --git a/dist/PieChart.js b/dist/PieChart.js index 3cd4b262..654ea03a 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -283,9 +283,6 @@ var PieChart = /** @class */ (function (_super) { 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); } - console.log("c.item: ", c.item); - console.log("this.state: ", _this.state); - console.log("backgroundColor: ", backgroundColor); return ( { ? c.item.legendFontColor : "transparent"; - console.log("c.item before: ", c.item) - if (typeof c?.item?.color === "string" && c.item.color.includes('hsl')) { c.item.color = hslToRgba(c.item.color) } - console.log("c.item: ", c.item) - console.log("this.state: ", this.state) - console.log("backgroundColor: ", backgroundColor) - return ( Date: Wed, 16 Jul 2025 15:45:42 +0300 Subject: [PATCH 85/86] Fix review comments --- .gitignore | 1 + src/PieChart.tsx | 7 +------ src/TextWidthFinder.tsx | 21 --------------------- 3 files changed, 2 insertions(+), 27 deletions(-) delete mode 100644 src/TextWidthFinder.tsx diff --git a/.gitignore b/.gitignore index 5e88d0dd..4ff81036 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,4 @@ package-lock.json .idea .vscode yarn.lock +dist diff --git a/src/PieChart.tsx b/src/PieChart.tsx index c975258c..7c065b37 100644 --- a/src/PieChart.tsx +++ b/src/PieChart.tsx @@ -6,7 +6,6 @@ import { G, Path, Rect, Svg, Text } from "react-native-svg"; import AbstractChart, { AbstractChartProps } from "./AbstractChart"; import { hslToRgba } from "./Utils"; -// import TextWidthFinder from "./TextWidthFinder"; export interface PieChartProps extends AbstractChartProps { data: Array; @@ -75,7 +74,6 @@ class PieChart extends AbstractChart { this.state.calculating.filter(i => i.calculating === true).length === 0 && this.props.width === prevProps.width && - // !this.props.editor && compareDataArrays(this.props.data, prevProps.data) ) { this.setState({ @@ -89,7 +87,6 @@ class PieChart extends AbstractChart { calculating, onLayout: true, ...this.props - // ...this.state }); } } @@ -329,9 +326,7 @@ class PieChart extends AbstractChart { } else { const item = c.item.values; let percentage = item.whole; - // if (uppedIndices.includes(item.index)) { - // percentage += 1; - // } + if (avoidFalseZero && item.whole === 0 && item.decimal !== 0) { value = "<1%"; } else { diff --git a/src/TextWidthFinder.tsx b/src/TextWidthFinder.tsx deleted file mode 100644 index 60ee3e5b..00000000 --- a/src/TextWidthFinder.tsx +++ /dev/null @@ -1,21 +0,0 @@ -// 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} -// -// ); -// } From 95832dfe4ab67c69b95090a86e9a9c03ee2102a1 Mon Sep 17 00:00:00 2001 From: Alex Kalashnik Date: Wed, 22 Oct 2025 13:30:31 +0300 Subject: [PATCH 86/86] Remove onLayout from PieChart --- dist/PieChart.d.ts | 1 - dist/PieChart.d.ts.map | 2 +- dist/PieChart.js | 53 +++++------------------------------------- src/PieChart.tsx | 48 -------------------------------------- 4 files changed, 7 insertions(+), 97 deletions(-) diff --git a/dist/PieChart.d.ts b/dist/PieChart.d.ts index 847caf76..ddaf92b6 100644 --- a/dist/PieChart.d.ts +++ b/dist/PieChart.d.ts @@ -19,7 +19,6 @@ export interface PieChartProps extends AbstractChartProps { } type PieChartState = { data: Array; - onLayout: boolean; calculating: Array; }; declare class PieChart extends AbstractChart { diff --git a/dist/PieChart.d.ts.map b/dist/PieChart.d.ts.map index 1bd97cfd..0a7e5385 100644 --- a/dist/PieChart.d.ts.map +++ b/dist/PieChart.d.ts.map @@ -1 +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;AAIpE,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,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC;AA8BF,cAAM,QAAS,SAAQ,aAAa,CAAC,aAAa,EAAE,aAAa,CAAC;IAChE,kBAAkB,CAAC,SAAS,KAAA;gBAmChB,KAAK,KAAA;IAcjB,MAAM;CAgVP;AAED,eAAe,QAAQ,CAAC"} \ No newline at end of file +{"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 index 654ea03a..f3f25591 100644 --- a/dist/PieChart.js +++ b/dist/PieChart.js @@ -65,7 +65,7 @@ var PieChart = /** @class */ (function (_super) { 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, onLayout: true }, props), { labelData: _this.props.data }); + _this.state = __assign(__assign({ calculating: calculating }, props), { labelData: _this.props.data }); return _this; } PieChart.prototype.componentDidUpdate = function (prevProps) { @@ -80,55 +80,17 @@ var PieChart = /** @class */ (function (_super) { if (this.state.calculating.filter(function (i) { return i.calculating === true; }).length === 0 && this.props.width === prevProps.width && - // !this.props.editor && compareDataArrays(this.props.data, prevProps.data)) { - this.setState(__assign(__assign({ calculating: calculating, onLayout: false }, this.props), this.state)); + this.setState(__assign(__assign({ calculating: calculating }, this.props), this.state)); } else { - this.setState(__assign({ calculating: calculating, onLayout: true }, this.props - // ...this.state - )); + 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; - //TODO: move setState out of onlayout since it runs in a for loop - var onLayout = function (e, index, fontSize, label) { - if (_this.state.onLayout) { - var width = e.nativeEvent.layout.width; - var target = _this.props.width - _this.props.width * chartWidthPercentage - 84; - var calculating = _this.state.calculating; - if (width < target) { - calculating[index].calculating = false; - _this.setState(__assign({ calculating: calculating }, _this.state)); - } - else { - if (label.slice(-3) === "...") { - label = label.slice(0, -3); - } - if (isNaN(fontSize)) { - if (!fontSize) { - fontSize = "12px"; - } - target = target - fontSize.split("p")[0] * 2; - } - else { - target = target - fontSize * 2; - } - var numberOfCharacters = label.length; - var ratio = target / width; - var targetCharacters = Math.floor(ratio * numberOfCharacters); - label = "".concat(label.slice(0, targetCharacters), "..."); - calculating[index].label.name = label; - if (label === "...") { - calculating[index].calculating = false; - } - _this.setState(__assign({ calculating: calculating }, _this.state)); - } - } - }; 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) { @@ -139,7 +101,7 @@ var PieChart = /** @class */ (function (_super) { value = ""; } if (!isObject(value)) { - return ( + return ( ); } else { - return ( + return ( ; - onLayout: boolean; calculating: Array; }; @@ -78,14 +77,12 @@ class PieChart extends AbstractChart { ) { this.setState({ calculating, - onLayout: false, ...this.props, ...this.state }); } else { this.setState({ calculating, - onLayout: true, ...this.props }); } @@ -100,7 +97,6 @@ class PieChart extends AbstractChart { } this.state = { calculating, - onLayout: true, ...props, labelData: this.props.data }; @@ -115,48 +111,6 @@ class PieChart extends AbstractChart { avoidFalseZero = false } = this.props; - //TODO: move setState out of onlayout since it runs in a for loop - const onLayout = (e, index, fontSize, label) => { - if (this.state.onLayout) { - let width = e.nativeEvent.layout.width; - let target = - this.props.width - this.props.width * chartWidthPercentage - 84; - let calculating = this.state.calculating; - - if (width < target) { - calculating[index].calculating = false; - this.setState({ - calculating, - ...this.state - }); - } else { - if (label.slice(-3) === "...") { - label = label.slice(0, -3); - } - if (isNaN(fontSize)) { - if (!fontSize) { - fontSize = "12px"; - } - target = target - fontSize.split("p")[0] * 2; - } else { - target = target - fontSize * 2; - } - const numberOfCharacters = label.length; - const ratio = target / width; - const targetCharacters = Math.floor(ratio * numberOfCharacters); - label = `${label.slice(0, targetCharacters)}...`; - calculating[index].label.name = label; - if (label === "...") { - calculating[index].calculating = false; - } - this.setState({ - calculating, - ...this.state - }); - } - } - }; - const calculations = this.state.calculating.map((item, index) => { let { name, @@ -177,7 +131,6 @@ class PieChart extends AbstractChart { onLayout(e, index, legendFontSize, name)} > { onLayout(e, index, legendFontSize, name)} >