@urvish-procare/react-native-charts-wrapper 0.6.0

package/android/src/main/java/com/github/wuxudong/rncharts/charts/CombinedChartManager.java

@@ -0,0 +1,62 @@
+package com.github.wuxudong.rncharts.charts;
+
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.github.mikephil.charting.charts.CombinedChart;
+import com.github.mikephil.charting.data.Entry;
+import com.github.wuxudong.rncharts.data.CombinedDataExtract;
+import com.github.wuxudong.rncharts.data.DataExtract;
+import com.github.wuxudong.rncharts.listener.RNOnChartGestureListener;
+import com.github.wuxudong.rncharts.listener.RNOnChartValueSelectedListener;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CombinedChartManager extends BarLineChartBaseManager<CombinedChart, Entry> {
+
+    @Override
+    public String getName() {
+        return "RNCombinedChart";
+    }
+
+    @Override
+    protected CombinedChart createViewInstance(ThemedReactContext reactContext) {
+        CombinedChart combinedChart = new CombinedChart(reactContext);
+        combinedChart.setOnChartValueSelectedListener(new RNOnChartValueSelectedListener(combinedChart));
+        combinedChart.setOnChartGestureListener(new RNOnChartGestureListener(combinedChart));
+        return combinedChart;
+    }
+
+    @ReactProp(name = "drawOrder")
+    public void setDrawOrder(CombinedChart chart, ReadableArray array) {
+        List<CombinedChart.DrawOrder> orders = new ArrayList<>();
+
+        for (int i = 0; i < array.size(); i++) {
+            orders.add(CombinedChart.DrawOrder.valueOf(array.getString(i)));
+        }
+
+        chart.setDrawOrder(orders.toArray(new CombinedChart.DrawOrder[orders.size()]));
+    }
+
+    @ReactProp(name = "drawValueAboveBar")
+    public void setDrawValueAboveBar(CombinedChart chart, boolean enabled) {
+        chart.setDrawValueAboveBar(enabled);
+    }
+
+    @ReactProp(name = "drawBarShadow")
+    public void setDrawBarShadow(CombinedChart chart, boolean enabled) {
+        chart.setDrawBarShadow(enabled);
+    }
+
+    @ReactProp(name = "highlightFullBarEnabled")
+    public void setHighlightFullBarEnabled(CombinedChart chart, boolean enabled) {
+        chart.setHighlightFullBarEnabled(enabled);
+    }
+
+    @Override
+    DataExtract getDataExtract() {
+        return new CombinedDataExtract();
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/charts/ConfigurableMinimumLinePositionFillFormatter.java

@@ -0,0 +1,19 @@
+package com.github.wuxudong.rncharts.charts;
+
+import com.github.mikephil.charting.formatter.IFillFormatter;
+import com.github.mikephil.charting.interfaces.dataprovider.LineDataProvider;
+import com.github.mikephil.charting.interfaces.datasets.ILineDataSet;
+
+public class ConfigurableMinimumLinePositionFillFormatter implements IFillFormatter {
+    private final float min;
+
+    public ConfigurableMinimumLinePositionFillFormatter(float min) {
+
+        this.min = min;
+    }
+
+    @Override
+    public float getFillLinePosition(ILineDataSet dataSet, LineDataProvider dataProvider) {
+        return min;
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/charts/CustomFormatter.java

@@ -0,0 +1,25 @@
+package com.github.wuxudong.rncharts.charts;
+
+import com.github.mikephil.charting.components.AxisBase;
+import com.github.mikephil.charting.data.Entry;
+import com.github.mikephil.charting.formatter.IAxisValueFormatter;
+import com.github.mikephil.charting.formatter.IValueFormatter;
+import com.github.mikephil.charting.formatter.ValueFormatter;
+import com.github.mikephil.charting.utils.ViewPortHandler;
+
+import java.text.DecimalFormat;
+
+public class CustomFormatter extends ValueFormatter {
+
+    private DecimalFormat mFormat;
+
+    public CustomFormatter(String value) {
+        mFormat = new DecimalFormat(value);
+    }
+
+    @Override
+    public String getFormattedValue(float value) {
+        return mFormat.format(value);
+    }
+
+}

package/android/src/main/java/com/github/wuxudong/rncharts/charts/DateFormatter.java

@@ -0,0 +1,34 @@
+package com.github.wuxudong.rncharts.charts;
+
+import com.github.mikephil.charting.formatter.ValueFormatter;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.concurrent.TimeUnit;
+import java.util.Locale;
+
+/**
+ * Created by dougl on 05/09/2017.
+ */
+public class DateFormatter extends ValueFormatter {
+
+    private DateFormat mFormat;
+
+    private long since = 0;
+
+    private TimeUnit timeUnit;
+
+    public DateFormatter(String pattern, long since, TimeUnit timeUnit, Locale locale) {
+        mFormat = new SimpleDateFormat(pattern, locale);
+
+        this.since = since;
+
+        this.timeUnit = timeUnit;
+    }
+
+    @Override
+    public String getFormattedValue(float value) {
+        return mFormat.format(new Date(since + timeUnit.toMillis((long) value)));
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/charts/HorizontalBarChartManager.java

@@ -0,0 +1,23 @@
+package com.github.wuxudong.rncharts.charts;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.github.mikephil.charting.charts.BarChart;
+import com.github.mikephil.charting.charts.HorizontalBarChart;
+import com.github.wuxudong.rncharts.listener.RNOnChartGestureListener;
+import com.github.wuxudong.rncharts.listener.RNOnChartValueSelectedListener;
+
+public class HorizontalBarChartManager extends BarChartManager {
+
+    @Override
+    public String getName() {
+        return "RNHorizontalBarChart";
+    }
+
+    @Override
+    protected BarChart createViewInstance(ThemedReactContext reactContext) {
+        HorizontalBarChart horizontalBarChart = new HorizontalBarChart(reactContext);
+        horizontalBarChart.setOnChartValueSelectedListener(new RNOnChartValueSelectedListener(horizontalBarChart));
+        horizontalBarChart.setOnChartGestureListener(new RNOnChartGestureListener(horizontalBarChart));
+        return horizontalBarChart;
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/charts/IndexValueFormatter.java

@@ -0,0 +1,102 @@
+package com.github.wuxudong.rncharts.charts;
+
+import com.github.mikephil.charting.data.BarEntry;
+import com.github.mikephil.charting.data.BubbleEntry;
+import com.github.mikephil.charting.data.CandleEntry;
+import com.github.mikephil.charting.data.Entry;
+import com.github.mikephil.charting.data.PieEntry;
+import com.github.mikephil.charting.data.RadarEntry;
+import com.github.mikephil.charting.formatter.ValueFormatter;
+
+import java.util.Collection;
+
+/**
+ * This formatter is used for passing an array of x-axis labels, on whole x steps.
+ */
+public class IndexValueFormatter extends ValueFormatter {
+    private String[] mValues = new String[]{};
+    private int mValueCount = 0;
+
+    /**
+     * An empty constructor.
+     * Use `setValues` to set the axis labels.
+     */
+    public IndexValueFormatter() {
+    }
+
+    /**
+     * Constructor that specifies value labels.
+     *
+     * @param values The values string array
+     */
+    public IndexValueFormatter(String[] values) {
+        if (values != null)
+            setValues(values);
+    }
+
+    /**
+     * Constructor that specifies value labels.
+     *
+     * @param values The values string array
+     */
+    public IndexValueFormatter(Collection<String> values) {
+        if (values != null)
+            setValues(values.toArray(new String[values.size()]));
+    }
+
+    public String[] getValues() {
+        return mValues;
+    }
+
+    public void setValues(String[] values) {
+        if (values == null)
+            values = new String[]{};
+
+        this.mValues = values;
+        this.mValueCount = values.length;
+    }
+
+    @Override
+    public String getBarLabel(BarEntry barEntry) {
+        return getFormattedValue(barEntry);
+    }
+
+    @Override
+    public String getBarStackedLabel(float value, BarEntry stackedEntry) {
+        return getFormattedValue(stackedEntry);
+    }
+
+    @Override
+    public String getPointLabel(Entry entry) {
+        return getFormattedValue(entry);
+    }
+
+    @Override
+    public String getPieLabel(float value, PieEntry pieEntry) {
+        return getFormattedValue(pieEntry);
+    }
+
+    @Override
+    public String getRadarLabel(RadarEntry radarEntry) {
+        return getFormattedValue(radarEntry);
+    }
+
+    @Override
+    public String getBubbleLabel(BubbleEntry bubbleEntry) {
+        return getFormattedValue(bubbleEntry);
+    }
+
+    @Override
+    public String getCandleLabel(CandleEntry candleEntry) {
+        return getFormattedValue(candleEntry);
+    }
+
+    private String getFormattedValue(Entry entry) {
+        int index = Math.round(entry.getX());
+
+        if (index < 0 || index >= mValueCount || index != (int) entry.getX())
+            return "";
+
+        return mValues[index];
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/charts/LabelByXValueFormatter.java

@@ -0,0 +1,25 @@
+package com.github.wuxudong.rncharts.charts;
+
+import com.github.mikephil.charting.data.Entry;
+import com.github.mikephil.charting.formatter.ValueFormatter;
+
+import java.util.Map;
+
+public class LabelByXValueFormatter extends ValueFormatter {
+    private Map<Float, String> labelsByXValue;
+
+    public LabelByXValueFormatter(Map<Float, String> labelsByXValue) {
+        this.labelsByXValue = labelsByXValue;
+    }
+
+    @Override
+    public String getFormattedValue(float value) {
+        String label = this.labelsByXValue.get(Float.valueOf(value));
+        return (label != null) ? label : "";
+    }
+
+    @Override
+    public String getPointLabel(Entry entry) {
+        return this.getFormattedValue(entry.getX());
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/charts/LineChartManager.java

@@ -0,0 +1,31 @@
+package com.github.wuxudong.rncharts.charts;
+
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.github.mikephil.charting.charts.LineChart;
+import com.github.mikephil.charting.data.Entry;
+import com.github.wuxudong.rncharts.data.DataExtract;
+import com.github.wuxudong.rncharts.data.LineDataExtract;
+import com.github.wuxudong.rncharts.listener.RNOnChartValueSelectedListener;
+import com.github.wuxudong.rncharts.listener.RNOnChartGestureListener;
+
+public class LineChartManager extends BarLineChartBaseManager<LineChart, Entry> {
+
+    @Override
+    public String getName() {
+        return "RNLineChart";
+    }
+
+    @Override
+    protected LineChart createViewInstance(ThemedReactContext reactContext) {
+        LineChart lineChart =  new LineChart(reactContext);
+        lineChart.setOnChartValueSelectedListener(new RNOnChartValueSelectedListener(lineChart));
+        lineChart.setOnChartGestureListener(new RNOnChartGestureListener(lineChart));
+        return lineChart;
+    }
+
+    @Override
+    DataExtract getDataExtract() {
+        return new LineDataExtract();
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/charts/PieChartManager.java

@@ -0,0 +1,147 @@
+package com.github.wuxudong.rncharts.charts;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.github.mikephil.charting.charts.PieChart;
+import com.github.mikephil.charting.data.PieEntry;
+import com.github.wuxudong.rncharts.data.DataExtract;
+import com.github.wuxudong.rncharts.data.PieDataExtract;
+import com.github.wuxudong.rncharts.listener.RNOnChartGestureListener;
+import com.github.wuxudong.rncharts.listener.RNOnChartValueSelectedListener;
+import com.github.wuxudong.rncharts.utils.BridgeUtils;
+import com.github.wuxudong.rncharts.utils.TypefaceUtils;
+
+public class PieChartManager extends ChartBaseManager<PieChart, PieEntry> {
+
+    @Override
+    public String getName() {
+        return "RNPieChart";
+    }
+
+    @Override
+    protected PieChart createViewInstance(ThemedReactContext reactContext) {
+        PieChart pieChart =  new PieChart(reactContext);
+        pieChart.setOnChartValueSelectedListener(new RNOnChartValueSelectedListener(pieChart));
+        pieChart.setOnChartGestureListener(new RNOnChartGestureListener(pieChart));
+        return pieChart;
+    }
+
+    @Override
+    DataExtract getDataExtract() {
+        return new PieDataExtract();
+    }
+
+    @ReactProp(name = "extraOffsets")
+    public void setExtraOffsets(PieChart chart, ReadableMap propMap) {
+        double left = 0, top = 0, right = 0, bottom = 0;
+
+        if (BridgeUtils.validate(propMap, ReadableType.Number, "left")) {
+            left = propMap.getDouble("left");
+        }
+        if (BridgeUtils.validate(propMap, ReadableType.Number, "top")) {
+            top = propMap.getDouble("top");
+        }
+        if (BridgeUtils.validate(propMap, ReadableType.Number, "right")) {
+            right = propMap.getDouble("right");
+        }
+        if (BridgeUtils.validate(propMap, ReadableType.Number, "bottom")) {
+            bottom = propMap.getDouble("bottom");
+        }
+        chart.setExtraOffsets((float) left, (float) top, (float) right, (float) bottom);
+    }
+
+    @ReactProp(name = "drawEntryLabels")
+    public void setDrawEntryLabels(PieChart chart, boolean enabled) {
+        chart.setDrawEntryLabels(enabled);
+    }
+
+    @ReactProp(name = "usePercentValues")
+    public void setUsePercentValues(PieChart chart, boolean enabled) {
+        chart.setUsePercentValues(enabled);
+    }
+
+    @ReactProp(name = "centerText")
+    public void setCenterText(PieChart chart, String text) {
+        chart.setCenterText(text);
+    }
+
+    @ReactProp(name = "styledCenterText")
+    public void setStyledCenterText(PieChart chart, ReadableMap propMap) {
+        if (BridgeUtils.validate(propMap, ReadableType.String, "text")) {
+            chart.setCenterText(propMap.getString("text"));
+        } else {
+            chart.setCenterText("");
+        }
+
+        if (BridgeUtils.validate(propMap, ReadableType.Number, "color")) {
+            chart.setCenterTextColor(propMap.getInt("color"));
+        }
+
+        if (BridgeUtils.validate(propMap, ReadableType.Number, "size")) {
+            chart.setCenterTextSize((float) propMap.getDouble("size"));
+        }
+
+        if (BridgeUtils.validate(propMap, ReadableType.String, "fontFamily")) {
+            chart.setCenterTextTypeface(TypefaceUtils.getTypeface(chart, propMap));
+        }
+    }
+
+    @ReactProp(name = "centerTextRadiusPercent")
+    public void setCenterTextRadiusPercent(PieChart chart, float radiusPercent) {
+        chart.setCenterTextRadiusPercent(radiusPercent);
+    }
+
+    @ReactProp(name = "holeRadius")
+    public void setHoleRadius(PieChart chart, float percent) {
+        chart.setHoleRadius(percent);
+    }
+
+    @ReactProp(name = "holeColor")
+    public void setHoleColor(PieChart chart, Integer color) {
+        chart.setHoleColor(color);
+    }
+
+    @ReactProp(name = "transparentCircleRadius")
+    public void setTransparentCircleRadius(PieChart chart, float percent) {
+        chart.setTransparentCircleRadius(percent);
+    }
+
+    @ReactProp(name = "transparentCircleColor")
+    public void setTransparentCircleColor(PieChart chart, Integer color) {
+        chart.setTransparentCircleColor(color);
+    }
+
+    @ReactProp(name = "entryLabelColor")
+    public void setEntryLabelColor(PieChart chart, Integer color) {
+        chart.setEntryLabelColor(color);
+    }
+
+    @ReactProp(name = "entryLabelTextSize")
+    public void setEntryLabelTextSize(PieChart chart, float size) {
+        chart.setEntryLabelTextSize(size);
+    }
+
+    @ReactProp(name = "entryLabelFontFamily")
+    public void setEntryLabelFontFamily(PieChart chart, String fontFamily) {
+        chart.setEntryLabelTypeface(TypefaceUtils.getTypeface(chart, fontFamily));
+    }
+
+    @ReactProp(name = "maxAngle")
+    public void setMaxAngle(PieChart chart, float maxAngle) {
+        chart.setMaxAngle(maxAngle);
+    }
+
+    @ReactProp(name = "rotationEnabled")
+    public void setRotationEnabled(PieChart chart, boolean enabled) {
+        chart.setRotationEnabled(enabled);
+    }
+
+    @ReactProp(name = "rotationAngle")
+    public void setRotationAngle(PieChart chart, float angle) {
+        chart.setRotationAngle(angle);
+    }
+
+
+}

package/android/src/main/java/com/github/wuxudong/rncharts/charts/RadarChartManager.java

@@ -0,0 +1,118 @@
+package com.github.wuxudong.rncharts.charts;
+
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.charts.RadarChart;
+import com.github.mikephil.charting.components.YAxis;
+import com.github.mikephil.charting.data.RadarEntry;
+import com.github.wuxudong.rncharts.data.DataExtract;
+import com.github.wuxudong.rncharts.data.RadarDataExtract;
+import com.github.wuxudong.rncharts.listener.RNOnChartGestureListener;
+import com.github.wuxudong.rncharts.listener.RNOnChartValueSelectedListener;
+import com.github.wuxudong.rncharts.utils.BridgeUtils;
+
+public class RadarChartManager extends YAxisChartBase<RadarChart, RadarEntry> {
+
+    @Override
+    public String getName() {
+        return "RNRadarChart";
+    }
+
+    @Override
+    protected RadarChart createViewInstance(ThemedReactContext reactContext) {
+        RadarChart radarChart = new RadarChart(reactContext);
+        radarChart.setOnChartValueSelectedListener(new RNOnChartValueSelectedListener(radarChart));
+        radarChart.setOnChartGestureListener(new RNOnChartGestureListener(radarChart));
+        return radarChart;
+    }
+
+    @Override
+    DataExtract getDataExtract() {
+        return new RadarDataExtract();
+    }
+
+    @Override
+    public void setYAxis(Chart chart, ReadableMap propMap) {
+        RadarChart radarChart = (RadarChart) chart;
+        YAxis axis = radarChart.getYAxis();
+
+        setCommonAxisConfig(chart, axis, propMap);
+        setYAxisConfig(axis, propMap);
+    }
+
+    @ReactProp(name = "skipWebLineCount")
+    public void setSkipWebLineCount(RadarChart chart, int count) {
+        chart.setSkipWebLineCount(count);
+    }
+
+    @ReactProp(name = "webLineWidth")
+    public void setWebLineWidth(RadarChart chart, float width) {
+        chart.setWebLineWidth(width);
+    }
+
+    @ReactProp(name = "webLineWidthInner")
+    public void setWebLineWidthInner(RadarChart chart, float width) {
+        chart.setWebLineWidthInner(width);
+    }
+
+    @ReactProp(name = "webAlpha")
+    public void setWebAlpha(RadarChart chart, int alpha) {
+        chart.setWebAlpha(alpha);
+    }
+
+    @ReactProp(name = "webColor")
+    public void setWebColor(RadarChart chart, int color) {
+        chart.setWebColor(color);
+    }
+
+
+    @ReactProp(name = "webColorInner")
+    public void setWebColorInner(RadarChart chart, int color) {
+        chart.setWebColorInner(color);
+    }
+
+    @ReactProp(name = "drawWeb")
+    public void setDrawWeb(RadarChart chart, boolean enabled) {
+        chart.setDrawWeb(enabled);
+    }
+
+    @ReactProp(name = "minOffset")
+    public void setMinOffset(RadarChart chart, float minOffset) {
+        chart.setMinOffset(minOffset);
+    }
+
+    @ReactProp(name = "extraOffsets")
+    public void setExtraOffsets(RadarChart chart, ReadableMap propMap) {
+        double left = 0, top = 0, right = 0, bottom = 0;
+
+        if (BridgeUtils.validate(propMap, ReadableType.Number, "left")) {
+            left = propMap.getDouble("left");
+        }
+        if (BridgeUtils.validate(propMap, ReadableType.Number, "top")) {
+            top = propMap.getDouble("top");
+        }
+        if (BridgeUtils.validate(propMap, ReadableType.Number, "right")) {
+            right = propMap.getDouble("right");
+        }
+        if (BridgeUtils.validate(propMap, ReadableType.Number, "bottom")) {
+            bottom = propMap.getDouble("bottom");
+        }
+        chart.setExtraOffsets((float) left, (float) top, (float) right, (float) bottom);
+    }
+
+    @ReactProp(name = "rotationEnabled")
+    public void setRotationEnabled(RadarChart chart, boolean enabled) {
+        chart.setRotationEnabled(enabled);
+    }
+
+    @ReactProp(name = "rotationAngle")
+    public void setRotationAngle(RadarChart chart, float angle) {
+        chart.setRotationAngle(angle);
+    }
+
+
+}

package/android/src/main/java/com/github/wuxudong/rncharts/charts/ScatterChartManager.java

@@ -0,0 +1,32 @@
+package com.github.wuxudong.rncharts.charts;
+
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.github.mikephil.charting.charts.ScatterChart;
+import com.github.mikephil.charting.data.Entry;
+import com.github.wuxudong.rncharts.data.DataExtract;
+import com.github.wuxudong.rncharts.data.ScatterDataExtract;
+import com.github.wuxudong.rncharts.listener.RNOnChartGestureListener;
+import com.github.wuxudong.rncharts.listener.RNOnChartValueSelectedListener;
+
+public class ScatterChartManager extends BarLineChartBaseManager<ScatterChart, Entry> {
+
+    @Override
+    public String getName() {
+        return "RNScatterChart";
+    }
+
+    @Override
+    protected ScatterChart createViewInstance(ThemedReactContext reactContext) {
+        ScatterChart scatterChart = new ScatterChart(reactContext);
+        scatterChart.setOnChartValueSelectedListener(new RNOnChartValueSelectedListener(scatterChart));
+        scatterChart.setOnChartGestureListener(new RNOnChartGestureListener(scatterChart));
+        return scatterChart;
+    }
+
+
+    @Override
+    DataExtract getDataExtract() {
+        return new ScatterDataExtract();
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/charts/YAxisChartBase.java

@@ -0,0 +1,51 @@
+package com.github.wuxudong.rncharts.charts;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.components.YAxis;
+import com.github.mikephil.charting.data.Entry;
+import com.github.wuxudong.rncharts.utils.BridgeUtils;
+
+public abstract class YAxisChartBase<T extends Chart, U extends Entry> extends ChartBaseManager<T, U> {
+
+    /**
+     * yAxis config details: https://github.com/PhilJay/MPAndroidChart/wiki/YAxis
+     */
+    @ReactProp(name = "yAxis")
+    public abstract void setYAxis(Chart chart, ReadableMap propMap);
+
+    protected void setYAxisConfig(YAxis axis, ReadableMap propMap) {
+
+        if (BridgeUtils.validate(propMap, ReadableType.Boolean, "inverted")) {
+            axis.setInverted(propMap.getBoolean("inverted"));
+        }
+        if (BridgeUtils.validate(propMap, ReadableType.Number, "spaceTop")) {
+            axis.setSpaceTop((float) propMap.getDouble("spaceTop"));
+        }
+        if (BridgeUtils.validate(propMap, ReadableType.Number, "spaceBottom")) {
+            axis.setSpaceBottom((float) propMap.getDouble("spaceBottom"));
+        }
+        if (BridgeUtils.validate(propMap, ReadableType.String, "position")) {
+            axis.setPosition(YAxis.YAxisLabelPosition.valueOf(propMap.getString("position")));
+        }
+
+        // TODO docs says the remaining config needs to be applied before setting data. Test it
+        // zero line
+        if (BridgeUtils.validate(propMap, ReadableType.Map, "zeroLine")) {
+            ReadableMap zeroLineConfig = propMap.getMap("zeroLine");
+
+            if (BridgeUtils.validate(zeroLineConfig, ReadableType.Boolean, "enabled")) {
+                axis.setDrawZeroLine(zeroLineConfig.getBoolean("enabled"));
+            }
+            if (BridgeUtils.validate(zeroLineConfig, ReadableType.Number, "lineWidth")) {
+                axis.setZeroLineWidth((float) zeroLineConfig.getDouble("lineWidth"));
+            }
+            if (BridgeUtils.validate(zeroLineConfig, ReadableType.Number, "lineColor")) {
+                axis.setZeroLineColor(zeroLineConfig.getInt("lineColor"));
+            }
+        }
+    }
+
+}