gifted-charts-core 0.0.25 → 0.0.26

package/src/PieChart/index.js

@@ -0,0 +1,119 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { useEffect, useState } from 'react';
+import { getTextSizeForPieLabels } from '../utils';
+export var usePieChart = function (props) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+    var radius = (_a = props.radius) !== null && _a !== void 0 ? _a : 120;
+    var extraRadiusForFocused = (_b = props.extraRadiusForFocused) !== null && _b !== void 0 ? _b : (((_c = props.focusOnPress) !== null && _c !== void 0 ? _c : props.sectionAutoFocus) ? radius / 10 : 0);
+    var pi = props.semiCircle ? Math.PI / 2 : Math.PI;
+    var _u = __read(useState(-1), 2), selectedIndex = _u[0], setSelectedIndex = _u[1]; // at the start, nothing is selected
+    // because we're going to use a useEffect, we need startAngle and total to be state variables
+    var _v = __read(useState((_d = props.initialAngle) !== null && _d !== void 0 ? _d : (props.semiCircle ? -pi : 0)), 2), startAngle = _v[0], setStartAngle = _v[1];
+    var _w = __read(useState(0), 2), total = _w[0], setTotal = _w[1];
+    useEffect(function () {
+        var _a;
+        // Update the total, this could be use to replace the forEach : const newTotal = props.data.reduce((acc, item) => acc + item.value, 0);
+        var newTotal = 0;
+        props.data.forEach(function (item) {
+            newTotal += item.value;
+        });
+        setTotal(newTotal);
+        // Update selectedIndex based on focused item
+        var newSelectedIndex = props.data.findIndex(function (item) { return item.focused === true; });
+        setSelectedIndex(newSelectedIndex);
+        // Calculate the new start angle
+        var newStartAngle = (_a = props.initialAngle) !== null && _a !== void 0 ? _a : (props.semiCircle ? -pi : 0);
+        if (newSelectedIndex !== -1) {
+            // it was !== 0 here before, which would not work, it's either !==-1 or >=0
+            // This could be used to replace the for loop that was used before
+            var sumBeforeSelectedIndex = props.data
+                .slice(0, newSelectedIndex)
+                .reduce(function (acc, item) { return acc + item.value; }, 0);
+            setStartAngle(newStartAngle + (2 * pi * sumBeforeSelectedIndex) / (newTotal || 1));
+        }
+        else {
+            setStartAngle(newStartAngle);
+        }
+    }, [props.data, props.initialAngle, props.semiCircle]);
+    useEffect(function () {
+        var _a;
+        if (selectedIndex !== -1) {
+            var newStartAngle = (_a = props.initialAngle) !== null && _a !== void 0 ? _a : (props.semiCircle ? -pi : 0);
+            var start = 0;
+            for (var i = 0; i < selectedIndex; i++) {
+                start += props.data[i].value;
+            }
+            if (total) {
+                setStartAngle(newStartAngle + (2 * pi * start) / (total || 1));
+            }
+        }
+    }, [selectedIndex]);
+    var data = props.data, donut = props.donut, isThreeD = props.isThreeD, semiCircle = props.semiCircle, _x = props.inwardExtraLengthForFocused, inwardExtraLengthForFocused = _x === void 0 ? 0 : _x;
+    var canvasWidth = radius * 2;
+    var canvasHeight = isThreeD ? radius * 2.3 : radius * 2;
+    var strokeWidth = (_e = props.strokeWidth) !== null && _e !== void 0 ? _e : 0;
+    var innerRadius = (_f = props.innerRadius) !== null && _f !== void 0 ? _f : radius / 2.5;
+    var innerCircleColor = (_h = (_g = props.innerCircleColor) !== null && _g !== void 0 ? _g : props.backgroundColor) !== null && _h !== void 0 ? _h : 'white';
+    var innerCircleBorderWidth = (_j = props.innerCircleBorderWidth) !== null && _j !== void 0 ? _j : (props.innerCircleBorderColor ? strokeWidth || 2 : 0);
+    var innerCircleBorderColor = (_k = props.innerCircleBorderColor) !== null && _k !== void 0 ? _k : 'lightgray';
+    var shiftInnerCenterX = (_l = props.shiftInnerCenterX) !== null && _l !== void 0 ? _l : 0;
+    var shiftInnerCenterY = (_m = props.shiftInnerCenterY) !== null && _m !== void 0 ? _m : 0;
+    var tiltAngle = (_o = props.tiltAngle) !== null && _o !== void 0 ? _o : '55deg';
+    var isDataShifted = false;
+    data.forEach(function (item) {
+        if (item.shiftX || item.shiftY) {
+            isDataShifted = true;
+        }
+    });
+    var textSize = getTextSizeForPieLabels((_p = props.textSize) !== null && _p !== void 0 ? _p : 0, radius);
+    var paddingHorizontal = ((_q = props.paddingHorizontal) !== null && _q !== void 0 ? _q : props.labelsPosition === 'onBorder')
+        ? ((_r = props.textBackgroundRadius) !== null && _r !== void 0 ? _r : textSize) * 2 + 6
+        : 0;
+    var paddingVertical = ((_s = props.paddingVertical) !== null && _s !== void 0 ? _s : props.labelsPosition === 'onBorder')
+        ? ((_t = props.textBackgroundRadius) !== null && _t !== void 0 ? _t : textSize) * 2 + 6
+        : 0;
+    return {
+        radius: radius,
+        extraRadiusForFocused: extraRadiusForFocused,
+        pi: pi,
+        selectedIndex: selectedIndex,
+        setSelectedIndex: setSelectedIndex,
+        startAngle: startAngle,
+        setStartAngle: setStartAngle,
+        total: total,
+        setTotal: setTotal,
+        data: data,
+        donut: donut,
+        isThreeD: isThreeD,
+        semiCircle: semiCircle,
+        inwardExtraLengthForFocused: inwardExtraLengthForFocused,
+        canvasWidth: canvasWidth,
+        canvasHeight: canvasHeight,
+        strokeWidth: strokeWidth,
+        innerRadius: innerRadius,
+        innerCircleColor: innerCircleColor,
+        innerCircleBorderWidth: innerCircleBorderWidth,
+        innerCircleBorderColor: innerCircleBorderColor,
+        shiftInnerCenterX: shiftInnerCenterX,
+        shiftInnerCenterY: shiftInnerCenterY,
+        tiltAngle: tiltAngle,
+        isDataShifted: isDataShifted,
+        paddingHorizontal: paddingHorizontal,
+        paddingVertical: paddingVertical
+    };
+};

package/src/PieChart/main.d.ts

@@ -0,0 +1,49 @@
+import { type PieChartMainProps, type pieDataItem } from './types';
+export declare const getPieChartMainProps: (props: PieChartMainProps) => {
+    isThreeD: boolean | undefined;
+    isBiggerPie: boolean | undefined;
+    propData: pieDataItem[];
+    data: pieDataItem[];
+    itemHasInnerComponent: boolean;
+    showInnerComponent: boolean;
+    radius: number;
+    canvasWidth: number;
+    canvasHeight: number;
+    shadowWidth: number;
+    backgroundColor: string;
+    shadowColor: string;
+    semiCircle: boolean;
+    pi: number;
+    initialAngle: number;
+    shadow: boolean;
+    donut: boolean;
+    strokeWidth: number;
+    strokeColor: string;
+    innerRadius: number;
+    showText: boolean;
+    textColor: string;
+    textSize: number;
+    tiltAngle: string;
+    labelsPosition: "onBorder" | "outward" | "inward" | "mid";
+    showTextBackground: boolean;
+    textBackgroundColor: string;
+    showValuesAsLabels: boolean;
+    showGradient: boolean;
+    gradientCenterColor: string;
+    toggleFocusOnPress: boolean;
+    minShiftX: number;
+    maxShiftX: number;
+    minShiftY: number;
+    maxShiftY: number;
+    total: number;
+    horizAdjustment: number;
+    vertAdjustment: number;
+    cx: number;
+    cy: number;
+    pData: number[];
+    mData: number[];
+    acc: number;
+    paddingHorizontal: number;
+    paddingVertical: number;
+    extraRadiusForFocused: number;
+};

package/src/PieChart/main.js

@@ -0,0 +1,185 @@
+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 __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+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 { getTextSizeForPieLabels } from '../utils';
+export var getPieChartMainProps = function (props) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+    var isThreeD = props.isThreeD, isBiggerPie = props.isBiggerPie, paddingHorizontal = props.paddingHorizontal, paddingVertical = props.paddingVertical, extraRadiusForFocused = props.extraRadiusForFocused;
+    var propData = props.data;
+    var data = [];
+    var itemHasInnerComponent = false;
+    if (propData) {
+        for (var i = 0; i < propData.length; i++) {
+            if (propData[i].pieInnerComponent)
+                itemHasInnerComponent = true;
+            if (propData[i].value !== 0) {
+                data.push(propData[i]);
+            }
+            else {
+                data.push(__assign(__assign({}, propData[i]), { value: props.data.map(function (item) { return item.value; }).reduce(function (v, a) { return v + a; }) /
+                        160000 }));
+            }
+        }
+    }
+    var showInnerComponent = !!props.pieInnerComponent || itemHasInnerComponent;
+    var radius = (_a = props.radius) !== null && _a !== void 0 ? _a : 120;
+    var canvasWidth = radius * 2;
+    var canvasHeight = isThreeD ? radius * 2.3 : radius * 2;
+    var shadowWidth = (_b = props.shadowWidth) !== null && _b !== void 0 ? _b : radius / 5;
+    var backgroundColor = (_c = props.backgroundColor) !== null && _c !== void 0 ? _c : 'transparent';
+    var shadowColor = (_d = props.shadowColor) !== null && _d !== void 0 ? _d : 'lightgray';
+    var semiCircle = (_e = props.semiCircle) !== null && _e !== void 0 ? _e : false;
+    var pi = Math.PI;
+    var initialAngle = (_f = props.initialAngle) !== null && _f !== void 0 ? _f : (semiCircle ? pi / -2 : 0);
+    var shadow = (_g = props.shadow) !== null && _g !== void 0 ? _g : false;
+    var donut = (_h = props.donut) !== null && _h !== void 0 ? _h : false;
+    var strokeWidth = (_j = props.strokeWidth) !== null && _j !== void 0 ? _j : 0;
+    var strokeColor = (_k = props.strokeColor) !== null && _k !== void 0 ? _k : (strokeWidth ? 'gray' : 'transparent');
+    var innerRadius = (_l = props.innerRadius) !== null && _l !== void 0 ? _l : radius / 2.5;
+    var showText = (_m = props.showText) !== null && _m !== void 0 ? _m : false;
+    var textColor = (_o = props.textColor) !== null && _o !== void 0 ? _o : '';
+    var textSize = getTextSizeForPieLabels((_p = props.textSize) !== null && _p !== void 0 ? _p : 0, radius);
+    var tiltAngle = (_q = props.tiltAngle) !== null && _q !== void 0 ? _q : '55deg';
+    if (tiltAngle &&
+        !isNaN(Number(tiltAngle)) &&
+        !(tiltAngle + '').endsWith('deg')) {
+        tiltAngle += 'deg';
+    }
+    // const tilt = props.tilt ? Math.min(props.tilt, 1) : props.isThreeD ? 0.5 : 1;
+    var labelsPosition = props.labelsPosition
+        ? props.labelsPosition
+        : donut || props.centerLabelComponent
+            ? 'outward'
+            : 'mid';
+    var showTextBackground = (_r = props.showTextBackground) !== null && _r !== void 0 ? _r : false;
+    var textBackgroundColor = (_s = props.textBackgroundColor) !== null && _s !== void 0 ? _s : 'white';
+    var showValuesAsLabels = (_t = props.showValuesAsLabels) !== null && _t !== void 0 ? _t : false;
+    var showGradient = (_u = props.showGradient) !== null && _u !== void 0 ? _u : false;
+    var gradientCenterColor = (_v = props.gradientCenterColor) !== null && _v !== void 0 ? _v : 'white';
+    var toggleFocusOnPress = (_w = props.toggleFocusOnPress) !== null && _w !== void 0 ? _w : true;
+    var minShiftX = 0;
+    var maxShiftX = 0;
+    var minShiftY = 0;
+    var maxShiftY = 0;
+    var total = 0;
+    data.forEach(function (item) {
+        if (item.shiftX || item.shiftY) {
+            if (minShiftX > item.shiftX) {
+                minShiftX = item.shiftX;
+            }
+            if (minShiftY > item.shiftY) {
+                minShiftY = item.shiftY;
+            }
+            if (maxShiftX < item.shiftX) {
+                maxShiftX = item.shiftX;
+            }
+            if (maxShiftY < item.shiftY) {
+                maxShiftY = item.shiftY;
+            }
+        }
+    });
+    var horizAdjustment = maxShiftX - minShiftX;
+    var vertAdjustment = maxShiftY - minShiftY;
+    if (semiCircle) {
+        pi = Math.PI / 2;
+    }
+    var cx = radius;
+    var cy = radius;
+    total =
+        data && data.length > 0
+            ? data.map(function (item) { return item.value; }).reduce(function (v, a) { return v + a; })
+            : 0;
+    var acc = 0;
+    var pData = data.map(function (item) {
+        acc += item.value / total;
+        return acc;
+    });
+    acc = 0;
+    var mData = data.map(function (item) {
+        var pAcc = acc;
+        acc += item.value / total;
+        return pAcc + (acc - pAcc) / 2;
+    });
+    pData = __spreadArray([0], __read(pData), false);
+    return {
+        isThreeD: isThreeD,
+        isBiggerPie: isBiggerPie,
+        propData: propData,
+        data: data,
+        itemHasInnerComponent: itemHasInnerComponent,
+        showInnerComponent: showInnerComponent,
+        radius: radius,
+        canvasWidth: canvasWidth,
+        canvasHeight: canvasHeight,
+        shadowWidth: shadowWidth,
+        backgroundColor: backgroundColor,
+        shadowColor: shadowColor,
+        semiCircle: semiCircle,
+        pi: pi,
+        initialAngle: initialAngle,
+        shadow: shadow,
+        donut: donut,
+        strokeWidth: strokeWidth,
+        strokeColor: strokeColor,
+        innerRadius: innerRadius,
+        showText: showText,
+        textColor: textColor,
+        textSize: textSize,
+        tiltAngle: tiltAngle,
+        labelsPosition: labelsPosition,
+        showTextBackground: showTextBackground,
+        textBackgroundColor: textBackgroundColor,
+        showValuesAsLabels: showValuesAsLabels,
+        showGradient: showGradient,
+        gradientCenterColor: gradientCenterColor,
+        toggleFocusOnPress: toggleFocusOnPress,
+        minShiftX: minShiftX,
+        maxShiftX: maxShiftX,
+        minShiftY: minShiftY,
+        maxShiftY: maxShiftY,
+        total: total,
+        horizAdjustment: horizAdjustment,
+        vertAdjustment: vertAdjustment,
+        cx: cx,
+        cy: cy,
+        pData: pData,
+        mData: mData,
+        acc: acc,
+        paddingHorizontal: paddingHorizontal,
+        paddingVertical: paddingVertical,
+        extraRadiusForFocused: extraRadiusForFocused
+    };
+};

package/src/PieChart/types.d.ts

@@ -0,0 +1,85 @@
+import { type ColorValue } from 'react-native';
+import { type FontStyle } from 'react-native-svg';
+export interface PieChartPropsType {
+    radius?: number;
+    isThreeD?: boolean;
+    donut?: boolean;
+    innerRadius?: number;
+    shadow?: boolean;
+    innerCircleColor?: ColorValue;
+    innerCircleBorderWidth?: number;
+    innerCircleBorderColor?: ColorValue;
+    shiftInnerCenterX?: number;
+    shiftInnerCenterY?: number;
+    shadowColor?: string;
+    shadowWidth?: number;
+    strokeWidth?: number;
+    strokeColor?: string;
+    backgroundColor?: string;
+    data: pieDataItem[];
+    semiCircle?: boolean;
+    showText?: boolean;
+    textColor?: string;
+    textSize?: number;
+    fontStyle?: FontStyle;
+    fontWeight?: string;
+    font?: string;
+    showTextBackground?: boolean;
+    textBackgroundColor?: string;
+    textBackgroundRadius?: number;
+    showValuesAsLabels?: boolean;
+    centerLabelComponent?: Function;
+    tiltAngle?: string;
+    initialAngle?: number;
+    labelsPosition?: 'onBorder' | 'outward' | 'inward' | 'mid';
+    showGradient?: boolean;
+    gradientCenterColor?: string;
+    onPress?: Function;
+    focusOnPress?: boolean;
+    toggleFocusOnPress?: boolean;
+    selectedIndex?: number;
+    setSelectedIndex?: Function;
+    sectionAutoFocus?: boolean;
+    onLabelPress?: Function;
+    extraRadiusForFocused?: number;
+    inwardExtraLengthForFocused?: number;
+    pieInnerComponent?: (item?: pieDataItem, index?: number) => any;
+    pieInnerComponentHeight?: number;
+    pieInnerComponentWidth?: number;
+    paddingHorizontal?: number;
+    paddingVertical?: number;
+}
+export interface pieDataItem {
+    value: number;
+    shiftX?: number;
+    shiftY?: number;
+    color?: string;
+    gradientCenterColor?: string;
+    text?: string;
+    textColor?: string;
+    textSize?: number;
+    fontStyle?: FontStyle;
+    fontWeight?: string;
+    font?: string;
+    textBackgroundColor?: string;
+    textBackgroundRadius?: number;
+    shiftTextX?: number;
+    shiftTextY?: number;
+    shiftTextBackgroundX?: number;
+    shiftTextBackgroundY?: number;
+    labelPosition?: 'onBorder' | 'outward' | 'inward' | 'mid';
+    onPress?: Function;
+    onLabelPress?: Function;
+    strokeWidth?: number;
+    strokeColor?: string;
+    focused?: boolean;
+    peripheral?: boolean;
+    pieInnerComponent?: (item?: pieDataItem, index?: number) => any;
+}
+export interface PieChartMainProps extends PieChartPropsType {
+    setSelectedIndex: Function;
+    isBiggerPie?: boolean;
+    paddingHorizontal: number;
+    paddingVertical: number;
+    extraRadiusForFocused: number;
+}

package/src/PieChart/types.js

@@ -0,0 +1 @@
+export {};

package/src/PopulationPyramid/index.d.ts

@@ -0,0 +1,137 @@
+import { Framework } from '../utils/types';
+import { type extendedPopulationPyramidPropsType } from './types';
+export declare const usePopulationPyramid: (props: extendedPopulationPyramidPropsType) => {
+    height: number;
+    width: number;
+    verticalMarginBetweenBars: number;
+    barsMapToYAxisSections: boolean;
+    data: import("./types").popnPyramidDataItem[] | (import("./types").popnPyramidDataItem[] & import("./types").popnPyramidDataItemReactJS[]);
+    hideRules: boolean;
+    hideYAxisText: boolean;
+    yAxisColor: import("react-native").ColorValue;
+    yAxisThickness: number;
+    xAxisColor: import("react-native").ColorValue;
+    xAxisThickness: number;
+    xAxisType: string | import("../utils/types").RuleTypes;
+    xAxisNoOfSections: number;
+    showXAxisIndices: boolean;
+    xAxisIndicesWidth: number;
+    xAxisIndicesHeight: number;
+    xAxisIndicesColor: import("react-native").ColorValue;
+    xAxisIndicesShiftY: number;
+    showXAxisLabelTexts: boolean;
+    xAxisLabelFontSize: number;
+    xAxisLabelFontStyle: import("react-native-svg").FontStyle;
+    xAxisLabelFontWeight: import("react-native-svg").FontWeight;
+    xAxisLabelFontFamily: string;
+    xAxisLabelColor: import("react-native").ColorValue;
+    xAxisLabelShiftX: number;
+    xAxisLabelShiftY: number;
+    xAxisLabelPrefix: string;
+    xAxisLabelSuffix: string;
+    formatXAxisLabels: ((label: string) => string) | undefined;
+    showVerticalLines: boolean;
+    verticalLinesColor: import("react-native").ColorValue;
+    verticalLinesThickness: number;
+    verticalLinesType: string | import("../utils/types").RuleTypes;
+    verticalLinesStrokeDashArray: string | number[];
+    showYAxisIndices: boolean;
+    yAxisIndicesWidth: number;
+    yAxisIndicesHeight: number;
+    yAxisIndicesColor: import("react-native").ColorValue;
+    yAxisLabelFontSize: number;
+    yAxisLabelFontStyle: import("react-native-svg").FontStyle;
+    yAxisLabelFontWeight: import("react-native-svg").FontWeight;
+    yAxisLabelFontFamily: string;
+    yAxisLabelColor: import("react-native").ColorValue;
+    yAxisLabelTextMarginRight: number;
+    yAxisLabelTexts: string[];
+    showValuesAsBarLabels: boolean;
+    rulesThickness: number;
+    rulesColor: import("react-native").ColorValue;
+    rulesType: string | import("../utils/types").RuleTypes;
+    dashWidth: number;
+    dashGap: number;
+    leftBarLabelWidth: number;
+    leftBarLabelFontSize: number;
+    leftBarLabelColor: import("react-native").ColorValue;
+    leftBarLabelFontStyle: import("react-native-svg").FontStyle;
+    leftBarLabelFontWeight: import("react-native-svg").FontWeight;
+    leftBarLabelFontFamily: string;
+    leftBarLabelPrefix: string;
+    leftBarLabelSuffix: string;
+    rightBarLabelWidth: number;
+    rightBarLabelFontSize: number;
+    rightBarLabelColor: import("react-native").ColorValue;
+    rightBarLabelFontStyle: import("react-native-svg").FontStyle;
+    rightBarLabelFontWeight: import("react-native-svg").FontWeight;
+    rightBarLabelFontFamily: string;
+    rightBarLabelPrefix: string;
+    rightBarLabelSuffix: string;
+    formatBarLabels: ((label: string) => string) | undefined;
+    showMidAxis: boolean;
+    midAxisLabelWidth: number;
+    midAxisLabelFontSize: number;
+    midAxisLabelColor: import("react-native").ColorValue;
+    midAxisLabelFontStyle: import("react-native-svg").FontStyle;
+    midAxisLabelFontWeight: import("react-native-svg").FontWeight;
+    midAxisLabelFontFamily: string;
+    leftBarColor: import("react-native").ColorValue;
+    rightBarColor: import("react-native").ColorValue;
+    leftBarBorderColor: import("react-native").ColorValue;
+    rightBarBorderColor: import("react-native").ColorValue;
+    leftBarBorderWidth: number;
+    rightBarBorderWidth: number;
+    leftBarBorderRadius: number;
+    rightBarBorderRadius: number;
+    allCornersRounded: boolean;
+    showSurplus: boolean;
+    showSurplusLeft: boolean;
+    showSurplusRight: boolean;
+    leftSurplusColor: import("react-native").ColorValue;
+    leftSurplusBorderColor: import("react-native").ColorValue;
+    rightSurplusColor: import("react-native").ColorValue;
+    rightSurplusBorderColor: import("react-native").ColorValue;
+    leftSurplusBorderWidth: number;
+    rightSurplusBorderWidth: number;
+    yAxisLabelWidth: number;
+    noOfSections: number;
+    containerHeight: number;
+    stepHeight: number;
+    xAxisLabelsHeight: number;
+    containerHeightWithXaxisLabels: number;
+    mid: number;
+    leftMax: number;
+    rightMax: number;
+    max: number;
+    xAxisRoundToDigits: number;
+    midAxisAndLabelWidth: number;
+    barWidthFactor: number;
+    leftXAfterMid: number;
+    rightXAfterMid: number;
+    yAxisLineProps: {
+        framework?: Framework.reactNative | undefined;
+    } & import("./types").RulesProps;
+    midAxisLineCommonProps: {
+        framework?: Framework.reactNative | undefined;
+    } & import("./types").RulesProps;
+    xAxisLabelY: number;
+    xAxisIndicesCommonProps: {
+        y1: number;
+        y2: number;
+        stroke: import("react-native").ColorValue;
+        strokeWidth: number;
+    };
+    verticalLinesCommonProps: {
+        framework?: Framework.reactNative | undefined;
+    } & import("./types").RulesProps;
+    xAxisLabelsCommonProps: {
+        y: number;
+        stroke: import("react-native").ColorValue;
+        fontSize: number;
+        fontStyle: import("react-native-svg").FontStyle;
+        fontWeight: import("react-native-svg").FontWeight;
+        fontFamily: string;
+    };
+    getXLabel: (index: number) => string;
+};