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

package/ios/ReactNativeCharts/utils/BridgeUtils.swift

@@ -0,0 +1,333 @@
+//
+// Created by xudong wu on 23/02/2017.
+// Copyright (c) wuxudong. All rights reserved.
+//
+
+import Foundation
+import SwiftyJSON
+import DGCharts
+
+class BridgeUtils {
+    static func toIOSAlpha(_ alpha: NSNumber) -> CGFloat {
+        return CGFloat(Double(truncating: alpha) / 255.0);
+    }
+
+    static func parseColors(_ array: [JSON]) -> [NSUIColor] {
+        return array.map {
+            return RCTConvert.uiColor($0.intValue);
+        }
+    }
+
+    static func toJson(_ dict: NSDictionary) -> JSON {
+        let json = try! JSONSerialization.data(withJSONObject: dict);
+
+        return JSON.init(parseJSON: NSString(data: json, encoding: String.Encoding.utf8.rawValue)! as String);
+    }
+
+    static func parseLineChartMode(_ mode: String) -> LineChartDataSet.Mode {
+        let iosEnumString = androidEnumToIOSEnum(mode)
+
+        switch iosEnumString {
+        case "linear":
+            return .linear
+        case "stepped":
+            return .stepped
+        case "cubicBezier":
+            return .cubicBezier
+        case "horizontalBezier":
+            return .horizontalBezier
+        default:
+            return .linear
+        }
+    }
+
+    static func parseLegendHorizontalAlignment(_ horizontalAlignment: String) -> Legend.HorizontalAlignment {
+        let iosEnumString = androidEnumToIOSEnum(horizontalAlignment)
+
+        switch iosEnumString {
+        case "right":
+            return .right
+        case "center":
+            return .center
+        default:
+            return .left
+        }
+    }
+
+    static func parseLegendVerticalAlignment(_ verticalAlignment: String) -> Legend.VerticalAlignment {
+        let iosEnumString = androidEnumToIOSEnum(verticalAlignment)
+
+        switch iosEnumString {
+        case "top":
+            return .top
+        case "center":
+            return .center
+        default:
+            return .bottom
+        }
+    }
+
+    static func parseLegendOrientation(_ orientation: String) -> Legend.Orientation {
+        let iosEnumString = androidEnumToIOSEnum(orientation)
+
+        switch iosEnumString {
+        case "vertical":
+            return .vertical
+        default:
+            return .horizontal
+        }
+    }
+
+    static func parseLegendDirection(_ direction: String) -> Legend.Direction {
+        let iosEnumString = androidEnumToIOSEnum(direction)
+
+        switch iosEnumString {
+        case "rightToLeft":
+            return .rightToLeft
+        default:
+            return .leftToRight
+        }
+    }
+
+
+
+    static func parseYAxisLabelPosition(_ position: String) -> YAxis.LabelPosition {
+        let iosEnumString = androidEnumToIOSEnum(position)
+
+        switch iosEnumString {
+        case "outsideChart":
+            return .outsideChart
+        case "insideChart":
+            return .insideChart
+        default:
+            return .outsideChart
+        }
+    }
+
+    static func parseXAxisLabelPosition(_ position: String) -> XAxis.LabelPosition {
+        let iosEnumString = androidEnumToIOSEnum(position)
+
+        switch iosEnumString {
+        case "top":
+            return .top
+        case "bottom":
+            return .bottom
+        case "bothSided":
+            return .bothSided
+        case "topInside":
+            return .topInside
+        case "bottomInside":
+            return .bottomInside
+        default:
+            return .top
+        }
+    }
+
+    static func parseLegendForm(_ form: String) -> Legend.Form {
+
+        let iosEnumString = androidEnumToIOSEnum(form)
+
+        switch iosEnumString {
+        case "none":
+            return .none
+        case "empty":
+            return .empty
+        case "`default`":
+            return .`default`
+        case "square":
+            return .square
+        case "circle":
+            return .circle
+        case "line":
+            return .line
+        default:
+            return .square
+        }
+    }
+
+    static func parseScatterShape(_ shape: String) -> ScatterChartDataSet.Shape {
+        let iosEnumString = androidEnumToIOSEnum(shape)
+
+        switch iosEnumString {
+        case "square":
+            return .square
+        case "circle":
+            return .circle
+        case "triangle":
+            return .triangle
+        case "cross":
+            return .cross
+        case "x":
+            return .x
+        case "chevronUp":
+            return .chevronUp
+        case "chevronDown":
+            return .chevronDown
+        default:
+            return  .square
+        }
+    }
+
+    static func parseEasingOption(_ option: String) -> ChartEasingOption {
+        let iosEnumString = String(option.first!).lowercased() + String(option.dropFirst())
+
+        switch iosEnumString {
+        case "linear":
+            return .linear
+        case "easeInQuad":
+            return .easeInQuad
+        case "easeOutQuad":
+            return .easeOutQuad
+        case "easeInOutQuad":
+            return .easeInOutQuad
+        case "easeInCubic":
+            return .easeInCubic
+        case "easeOutCubic":
+            return .easeOutCubic
+        case "easeInOutCubic":
+            return .easeInOutCubic
+        case "easeInQuart":
+            return .easeInQuart
+        case "easeOutQuart":
+            return .easeOutQuart
+        case "easeInOutQuart":
+            return .easeInOutQuart
+        case "easeInQuint":
+            return .easeInQuint
+        case "easeOutQuint":
+            return .easeOutQuint
+        case "easeInOutQuint":
+            return .easeInOutQuint
+        case "easeInSine":
+            return .easeInSine
+        case "easeOutSine":
+            return .easeOutSine
+        case "easeInOutSine":
+            return .easeInOutSine
+        case "easeInExpo":
+            return .easeInExpo
+        case "easeOutExpo":
+            return .easeOutExpo
+        case "easeInOutExpo":
+            return .easeInOutExpo
+        case "easeInCirc":
+            return .easeInCirc
+        case "easeOutCirc":
+            return .easeOutCirc
+        case "easeInOutCirc":
+            return .easeInOutCirc
+        case "easeInElastic":
+            return .easeInElastic
+        case "easeOutElastic":
+            return .easeOutElastic
+        case "easeInOutElastic":
+            return .easeInOutElastic
+        case "easeInBack":
+            return .easeInBack
+        case "easeOutBack":
+            return .easeOutBack
+        case "easeInOutBack":
+            return .easeInOutBack
+        case "easeInBounce":
+            return .easeInBounce
+        case "easeOutBounce":
+            return .easeOutBounce
+        case "easeInOutBounce":
+            return .easeInOutBounce
+        default:
+            return .linear
+        }
+    }
+
+    static func parseAxisDependency(_ option: String) -> YAxis.AxisDependency {
+        let iosEnumString = androidEnumToIOSEnum(option)
+
+        switch iosEnumString {
+        case "left":
+            return .left
+
+        case "right":
+            return .right
+
+        default:
+            return .left
+        }
+    }
+
+    static func parsePieChartDataSetValuePosition(_ option: String) -> PieChartDataSet.ValuePosition {
+        let iosEnumString = androidEnumToIOSEnum(option)
+
+        switch iosEnumString {
+        case "insideSlice":
+            return .insideSlice
+
+        case "outsideSlice":
+            return .outsideSlice
+
+        default:
+            return .insideSlice
+        }
+    }
+
+    static func androidEnumToIOSEnum(_ desc: String) -> String {
+        let components = desc.components(separatedBy: "_")
+
+        if components.count > 1 {
+            return components.enumerated().reduce("") {
+                accumulate, current in
+                return current.offset == 0 ? current.element.lowercased() :
+                    accumulate + current.element.lowercased().capitalized;
+            }
+        } else {
+            return desc.lowercased();
+        }
+    }
+
+    // unfortunately, this function can only work with pure swift enum without @objc
+    // check http://stackoverflow.com/questions/42513337/why-does-an-objc-enum-have-a-different-description-than-a-pure-swift-enum
+    static func parseIntEnumFromString<T:RawRepresentable>(_ enumType: T.Type, desc: String) -> T? where T.RawValue == Int {
+        let iosEnumString = androidEnumToIOSEnum(desc);
+
+        var i = 0
+        while let item = enumType.init(rawValue: i) {
+            if String(describing: item) == iosEnumString {
+                return item
+            }
+            i += 1
+        }
+        return nil;
+    }
+
+    static func parseLimitlineLabelPosition(_ position: String) -> ChartLimitLine.LabelPosition {
+        let iosEnumString = androidEnumToIOSEnum(position)
+        //      NSLog("this label position %@", iosEnumString)
+        switch iosEnumString {
+        case "rightBottom":
+            return .rightBottom
+        case "leftBottom":
+            return .leftBottom
+        case "rightTop":
+            return .rightTop
+        case "leftTop":
+            return .leftTop
+        default:
+            return .rightTop
+        }
+    }
+
+    static func parseDrawOrder(_ drawOrder: String) -> CombinedChartView.DrawOrder{
+        let iosEnumString = androidEnumToIOSEnum(drawOrder)
+        switch iosEnumString {
+        case "bar":
+            return .bar
+        case "bubble":
+            return .bubble
+        case "candle":
+            return .candle
+        case "scatter":
+            return .scatter
+        default:
+            return .line
+        }
+    }
+}

package/ios/ReactNativeCharts/utils/ChartDataSetConfigUtils.swift

@@ -0,0 +1,147 @@
+//
+//  ChartDataSetConfigUtils.swift
+//  reactNativeCharts
+//
+//  Created by xudong wu on 23/02/2017.
+//  Copyright wuxudong
+//
+
+import UIKit
+import DGCharts
+import SwiftyJSON
+
+
+class ChartDataSetConfigUtils: NSObject {
+    static func commonConfig(_ dataSet: ChartDataSet, config: JSON) {
+        if let font = FontUtils.getFont(config) {
+            dataSet.valueFont = font
+        }
+
+        // Setting main color
+        if config["color"].int != nil {
+            dataSet.setColor(RCTConvert.uiColor(config["color"].intValue))
+        }
+
+        if config["colors"].array != nil {
+            dataSet.colors = BridgeUtils.parseColors(config["colors"].arrayValue)
+        }
+
+        if config["drawValues"].bool != nil {
+            dataSet.drawValuesEnabled = config["drawValues"].boolValue;
+        }
+
+        if config["highlightEnabled"].bool != nil {
+            dataSet.highlightEnabled = config["highlightEnabled"].boolValue;
+        }
+
+        if config["valueTextSize"].float != nil {
+            dataSet.valueFont = dataSet.valueFont.withSize(CGFloat(config["valueTextSize"].floatValue))
+        }
+
+        if config["valueTextColor"].int != nil {
+            dataSet.valueTextColor = RCTConvert.uiColor(config["valueTextColor"].intValue)
+        }
+
+        if config["visible"].bool != nil {
+            dataSet.visible = config["visible"].boolValue
+        }
+
+        let valueFormatter = config["valueFormatter"];
+        if valueFormatter.string != nil {
+            if "largeValue" == valueFormatter.stringValue {
+                dataSet.valueFormatter = LargeValueFormatter();
+            } else if "percent" == valueFormatter.stringValue {
+                let percentFormatter = NumberFormatter()
+                percentFormatter.numberStyle = .percent
+
+                dataSet.valueFormatter = DefaultValueFormatter(formatter: percentFormatter);
+            } else if "date" == valueFormatter.stringValue {
+                let valueFormatterPattern = config["valueFormatterPattern"].stringValue;
+                let since = config["since"].double != nil ? config["since"].doubleValue : 0
+                let timeUnit = config["timeUnit"].string != nil ? config["timeUnit"].stringValue : "MILLISECONDS"
+                let locale = config["locale"].string;
+                dataSet.valueFormatter = CustomChartDateFormatter(pattern: valueFormatterPattern, since: since, timeUnit: timeUnit, locale: locale);
+            } else if "labelByXValue" == valueFormatter.stringValue {
+                let valueFormatterLabels = config["valueFormatterLabels"].arrayValue;
+
+                var labelsByXValue = [Double : String]();
+                for entry in valueFormatterLabels {
+                    labelsByXValue.updateValue(entry["label"].stringValue, forKey: entry["x"].doubleValue);
+                }
+
+                dataSet.valueFormatter = LabelByXValueFormatter(labelsByXValue);
+            } else {
+                let customFormatter = NumberFormatter()
+                customFormatter.positiveFormat = valueFormatter.stringValue
+                customFormatter.negativeFormat = valueFormatter.stringValue
+
+                dataSet.valueFormatter = DefaultValueFormatter(formatter: customFormatter);
+            }
+        } else if valueFormatter.array != nil {
+            dataSet.valueFormatter = IndexValueFormatter(values: valueFormatter.arrayValue.map({ $0.stringValue }))
+        }
+
+        if config["axisDependency"].string != nil {
+            dataSet.axisDependency = BridgeUtils.parseAxisDependency(config["axisDependency"].stringValue)
+        }
+    }
+
+    static func commonBarLineScatterCandleBubbleConfig(_ dataSet: BarLineScatterCandleBubbleChartDataSet, config: JSON) {
+        if config["highlightColor"].int != nil {
+            dataSet.highlightColor = RCTConvert.uiColor(config["highlightColor"].intValue);
+        }
+    }
+
+
+    static func commonLineScatterCandleRadarConfig(_ dataSet: LineScatterCandleRadarChartDataSet, config: JSON) {
+        if config["drawHighlightIndicators"].bool != nil {
+            dataSet.setDrawHighlightIndicators(config["drawHighlightIndicators"].boolValue);
+        }
+
+        if config["drawVerticalHighlightIndicator"].bool != nil {
+            dataSet.drawVerticalHighlightIndicatorEnabled = config["drawVerticalHighlightIndicator"].boolValue;
+        }
+
+        if config["drawHorizontalHighlightIndicator"].bool != nil {
+            dataSet.drawHorizontalHighlightIndicatorEnabled = config["drawHorizontalHighlightIndicator"].boolValue;
+        }
+
+        if config["highlightLineWidth"].float != nil {
+            dataSet.highlightLineWidth = CGFloat(config["highlightLineWidth"].floatValue);
+        }
+    }
+
+    static func commonLineRadarConfig( _ dataSet:LineRadarChartDataSet,  config:JSON) {
+        if let fillGradient = config["fillGradient"].dictionary {
+            let colors = fillGradient["colors"]?.array!.map { RCTConvert.uiColor($0.int)!.cgColor }
+            let locations = fillGradient["positions"]?.array!.map { CGFloat($0.float!) }
+
+            let gradient = CGGradient.init(colorsSpace: CGColorSpaceCreateDeviceRGB(), colors: colors! as CFArray, locations: locations)
+
+            var angle = 90.0
+            if fillGradient["angle"] != nil {
+                angle = fillGradient["angle"]!.doubleValue
+            }
+
+            if (gradient != nil) {
+              dataSet.fill = LinearGradientFill(gradient: gradient!, angle: CGFloat(angle));
+            }
+        } else if config["fillColor"].int != nil {
+            dataSet.fillColor = RCTConvert.uiColor(config["fillColor"].intValue);
+        }
+
+        if config["fillAlpha"].number != nil {
+            dataSet.fillAlpha = BridgeUtils.toIOSAlpha(config["fillAlpha"].numberValue);
+        }
+
+        if config["drawFilled"].bool != nil {
+            dataSet.drawFilledEnabled = config["drawFilled"].boolValue;
+        }
+
+        if config["lineWidth"].float != nil {
+            dataSet.lineWidth = CGFloat(config["lineWidth"].floatValue);
+        }
+    }
+
+
+}

package/ios/ReactNativeCharts/utils/EntryToDictionaryUtils.swift

@@ -0,0 +1,66 @@
+//
+//  EntryToDictionaryUtils.swift
+//
+//
+//  Created by xudong wu on 08/03/2017.
+//  Copyright © 2017 Facebook. All rights reserved.
+//
+
+import UIKit
+import DGCharts
+import SwiftyJSON
+
+class EntryToDictionaryUtils: NSObject {
+  static func entryToDictionary(_ entry: ChartDataEntry) -> [AnyHashable: Any]{
+    var dict = [AnyHashable: Any]()
+
+    if entry.data != nil {
+        dict["data"] = (entry.data as! JSON).dictionaryObject!
+    }
+
+    if entry is BarChartDataEntry {
+        let barEntry = entry as! BarChartDataEntry;
+
+        dict["x"] = barEntry.x
+
+        if barEntry.yValues != nil {
+            dict["yValues"] = barEntry.yValues
+        } else {
+            dict["y"] = barEntry.y
+        }
+    } else if entry is BubbleChartDataEntry {
+
+        let bubbleEntry = entry as! BubbleChartDataEntry;
+
+        dict["x"] = bubbleEntry.x
+        dict["y"] = bubbleEntry.y
+
+        dict["size"] = bubbleEntry.size
+    } else if entry is CandleChartDataEntry {
+        let candleEntry = entry as! CandleChartDataEntry;
+
+        dict["x"] = candleEntry.x
+        dict["open"] = candleEntry.open
+        dict["close"] = candleEntry.close
+        dict["low"] = candleEntry.low
+        dict["high"] = candleEntry.high
+    } else if entry is PieChartDataEntry {
+        let pieEntry = entry as! PieChartDataEntry;
+
+        dict["value"] = pieEntry.value
+
+        if pieEntry.label != nil {
+            dict["label"] = pieEntry.label!
+        }
+    } else if entry is RadarChartDataEntry {
+        let radarEntry = entry as! RadarChartDataEntry;
+
+        dict["value"] = radarEntry.value
+    } else {
+        dict["x"] = entry.x
+        dict["y"] = entry.y
+    }
+
+    return dict
+  }
+}

package/ios/ReactNativeCharts/utils/FontUtils.swift

@@ -0,0 +1,29 @@
+//
+//  FontUtils.swift
+//  Example
+//
+//  Created by wuxudong on 2018/7/25.
+//  Copyright © 2018 Facebook. All rights reserved.
+//
+
+import Foundation
+import SwiftyJSON
+
+class FontUtils {
+  static func getFont(_ json: JSON) -> UIFont? {    
+    var font : UIFont?;
+    if json["fontFamily"].string != nil {
+      font = RCTFont.update(font ?? nil, withFamily: json["fontFamily"].string)
+    }
+    
+    if json["fontStyle"].string != nil {
+      font = RCTFont.update(font ?? nil, withStyle: json["fontStyle"].string)
+    }
+    
+    if json["fontWeight"].string != nil {
+      font = RCTFont.update(font ?? nil, withWeight: json["fontWeight"].string)
+    }
+    
+    return font
+  }
+}

package/ios/ReactNativeCharts/utils/HighlightUtils.swift

@@ -0,0 +1,41 @@
+//
+//  HighlightUtils.swift
+//
+//  Created by wuxudong on 2018/7/26.
+//  Copyright © 2018 wuxudong. All rights reserved.
+//
+
+import Foundation
+import DGCharts
+import SwiftyJSON
+
+class HighlightUtils {
+  static func getHighlights(_ config: NSArray) -> [Highlight] {
+    var highlights : [Highlight] = []
+    for object in config {
+      if let dict = object as? NSDictionary {
+        let json = BridgeUtils.toJson(dict)
+
+        if json["x"].double != nil {
+          let dataSetIndex = json["dataSetIndex"].int != nil ? json["dataSetIndex"].intValue : 0
+          let y = json["y"].double != nil ? json["y"].doubleValue : 0
+
+          var highlight : Highlight
+          if json["stackIndex"].int != nil {
+            highlight = Highlight(x: json["x"].doubleValue, dataSetIndex: dataSetIndex, stackIndex: json["stackIndex"].intValue)
+          } else {
+            highlight = Highlight(x: json["x"].doubleValue, y: y, dataSetIndex: dataSetIndex)
+          }
+
+          if json["dataIndex"].int != nil {
+            highlight.dataIndex = json["dataIndex"].intValue
+          }
+
+          highlights.append(highlight)
+        }
+      }
+    }
+
+    return highlights
+  }
+}