Fixed infinite size compile error

I added ChartView/SwiftUICharts to my iphone project. It worked as
expected until I tried to archive the application for distribution.

In the archive step, compilation fails with a segmentation fault:
    1.	While running pass #48703 SILFunctionTransform "GenericSpecializer" on SILFunction "@$s13SwiftUICharts9ChartDataC6pointsACSayxG_tcSBRzlufcSd_Tg5".
     for 'init(points:)' (at /Users/kfowler/projects/ChartView/Sources/SwiftUICharts/Helpers.swift:134:12)
    0  swift                    0x0000000113b94a63 PrintStackTraceSignalHandler(void*) + 51
    1  swift                    0x0000000113b94236 SignalHandler(int) + 358
    2  libsystem_platform.dylib 0x00007fff6bd7d42d _sigtramp + 29
    3  libsystem_platform.dylib 0x0000000800000001 _sigtramp + 2485660657
    4  swift                    0x000000010ffd800c swift::ReabstractionInfo::prepareAndCheck(swift::ApplySite, swift::SILFunction*, swift::SubstitutionMap, swift::OptRemark::Emitter*) + 572
    5  swift                    0x000000011002abda swift::ReabstractionInfo::ReabstractionInfo(swift::ApplySite, swift::SILFunction*, swift::SubstitutionMap, swift::IsSerialized_t, bool, swift::OptRemark::Emitter*) + 122
    6  swift                    0x0000000110034c35 swift::trySpecializeApplyOfGeneric(swift::SILOptFunctionBuilder&, swift::ApplySite, llvm::SmallSetVector<swift::SILInstruction*, 8u>&, llvm::SmallVectorImpl<swift::SILFunction*>&, swift::OptRemark::Emitter&) + 1653
    7  swift                    0x000000010ff0d731 (anonymous namespace)::GenericSpecializer::run() + 2673
    8  swift                    0x000000010fe86f3e swift::SILPassManager::execute() + 4606
    9  swift                    0x000000010fae596b swift::CompilerInstance::performSILProcessing(swift::SILModule*, swift::UnifiedStatsReporter*) + 6379
    10 swift                    0x000000010f7ddec5 performCompile(swift::CompilerInstance&, swift::CompilerInvocation&, llvm::ArrayRef<char const*>, int&, swift::FrontendObserver*, swift::UnifiedStatsReporter*) + 33925
    11 swift                    0x000000010f7d2234 swift::performFrontend(llvm::ArrayRef<char const*>, char const*, void*, swift::FrontendObserver*) + 6820
    12 swift                    0x000000010f75f733 main + 1219
    13 libdyld.dylib            0x00007fff6bb847fd start + 1
error: Segmentation fault: 11 (in target 'SwiftUICharts' from project 'SwiftUICharts')

This change resolves the issue.

.swiftpm/xcode/xcuserdata/samuandris.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>SchemeUserState</key>
+	<dict>
+		<key>SwiftUICharts.xcscheme_^#shared#^_</key>
+		<dict>
+			<key>orderHint</key>
+			<integer>1</integer>
+		</dict>
+	</dict>
+</dict>
+</plist>

Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "SwiftUICharts",
     platforms: [
-        .iOS(.v13),
+        .iOS(.v13),.watchOS(.v6)
     ],
     products: [
         // Products define the executables and libraries produced by a package, and make them visible to other packages.

README.md

@@ -2,7 +2,7 @@
 
 Swift package for displaying charts effortlessly.
 
-![SwiftUI Charts](./showcase1.gif "SwiftUI Charts")
+![SwiftUI Charts](./Resources/showcase1.gif "SwiftUI Charts")
 
 It supports:
 * Line charts
@@ -11,9 +11,9 @@ It supports:
 
 ### Installation:
 
-It requires iOS 13 and xCode 11!
+It requires iOS 13 and Xcode 11!
 
-In xCode got to `File -> Swift Packages -> Add Package Dependency` and paste inthe repo's url: `https://github.com/AppPear/ChartView`
+In Xcode got to `File -> Swift Packages -> Add Package Dependency` and paste inthe repo's url: `https://github.com/AppPear/ChartView`
 
 ### Usage:
 
@@ -21,8 +21,23 @@ import the package in the file you would like to use it: `import SwiftUICharts`
 
 You can display a Chart by adding a chart view to your parent view: 
 
+### Demo
+
+Added an example project, with **iOS, watchOS** target: https://github.com/AppPear/ChartViewDemo
+
 ## Line charts
-![Line Charts](./showcase3.gif "Line Charts")
+
+**New full screen view called LineView!!!**
+
+![Line Charts](./Resources/fullscreen2.gif "Line Charts")
+
+```swift
+ LineView(data: [8,23,54,32,12,37,7,23,43], title: "Line chart", legend: "Full screen") // legend is optional, use optional .padding()
+```
+
+Adopts to dark mode automatically 
+
+![Line Charts](./Resources/showcase3.gif "Line Charts")
 
 **Line chart is interactive, so you can drag across to reveal the data points**
 
@@ -32,52 +47,117 @@ You can add a line chart with the following code:
  LineChartView(data: [8,23,54,32,12,37,7,23,43], title: "Title", legend: "Legendary") // legend is optional
 ```
 
+**Turn drop shadow off by adding to the Initialiser: `dropShadow: false`**
+
 
 ## Bar charts
-![Bar Charts](./showcase2.gif "Bar Charts")
+![Bar Charts](./Resources/showcase2.gif "Bar Charts")
 
+**[New feature] you can display labels also along values and points for each bar to descirbe your data better!**
 **Bar chart is interactive, so you can drag across to reveal the data points**
 
 You can add a bar chart with the following code: 
 
+Labels and points:
+
 ```swift
- BarChartView(data: [8,23,54,32,12,37,7,23,43], title: "Title", legend: "Legendary") // legend is optional
+ BarChartView(data: ChartData(values: [("2018 Q4",63150), ("2019 Q1",50900), ("2019 Q2",77550), ("2019 Q3",79600), ("2019 Q4",92550)]), title: "Sales", legend: "Quarterly") // legend is optional
+```
+Only points:
+
+```swift
+ BarChartView(data: ChartData(points: [8,23,54,32,12,37,7,23,43]), title: "Title", legend: "Legendary") // legend is optional
 ```
 
-You can add different formats: 
-* Small `Form.small`
-* Medium  `Form.medium`
-* Large `Form.large` 
+**ChartData** structure
+Stores values in data pairs (actually tuple): `(String,Double)`
+* you can have duplicate values
+* keeps the data order
+
+You can initialise ChartData multiple ways:
+* For integer values: `ChartData(points: [8,23,54,32,12,37,7,23,43])`
+* For floating point values: `ChartData(points: [2.34,3.14,4.56])`
+* For label,value pairs: `ChartData(values: [("2018 Q4",63150), ("2019 Q1",50900)])`
+
+
+You can add different formats: 
+* Small `ChartForm.small`
+* Medium  `ChartForm.medium`
+* Large `ChartForm.large` 
+
+```swift
+BarChartView(data: ChartData(points: [8,23,54,32,12,37,7,23,43]), title: "Title", form: ChartForm.small)
+```
+
+For floating point numbers, you can set a custom specifier: 
+
+```swift
+BarChartView(data: ChartData(points:[1.23,2.43,3.37]) ,title: "A", valueSpecifier: "%.2f")
+```
+For integers you can disable by passing: `valueSpecifier: "%.0f"`
+
+
+You can set your custom image in the upper right corner by passing in the initialiser: `cornerImage:Image(systemName: "waveform.path.ecg")` 
+
+
+ **Turn drop shadow off by adding to the Initialiser: `dropShadow: false`**
 
- ```swift
- BarChartView(data: [8,23,54,32,12,37,7,23,43], title: "Title", style: ChartStyle(formSize: Form.small))
- ```
- 
  ### You can customize styling of the chart with a ChartStyle object: 
 
 Customizable: 
 * background color
 * accent color
 * second gradient color
-* chart form size
 * text color
 * legend text color
 
 ```swift
- let chartStyle = ChartStyle(backgroundColor: Color.black, accentColor: Colors.OrangeStart, secondGradientColor: Colors.OrangeEnd, chartFormSize: Form.medium, textColor: Color.white, legendTextColor: Color.white )
+ let chartStyle = ChartStyle(backgroundColor: Color.black, accentColor: Colors.OrangeStart, secondGradientColor: Colors.OrangeEnd, chartFormSize: ChartForm.medium, textColor: Color.white, legendTextColor: Color.white )
  ...
  BarChartView(data: [8,23,54,32,12,37,7,23,43], title: "Title", style: chartStyle)
 ```
 
-![Custom Charts](./showcase5.png "Custom Charts")
+You can access built-in styles: 
+```swift
+ BarChartView(data: [8,23,54,32,12,37,7,23,43], title: "Title", style: Styles.barChartMidnightGreen)
+```
+#### All styles available as a preset: 
+* barChartStyleOrangeLight
+* barChartStyleOrangeDark
+* barChartStyleNeonBlueLight
+* barChartStyleNeonBlueDark
+* barChartMidnightGreenLight
+* barChartMidnightGreenDark
 
+![Midnightgreen](./Resources/midnightgreen.gif "Midnightgreen")
+
+![Custom Charts](./Resources/showcase5.png "Custom Charts")
+
+
+### You can customize the size of the chart with a ChartForm object: 
+
+**ChartForm**
+* `.small`
+* `.medium`
+* `.large`
+* `.detail`
+
+```swift
+BarChartView(data: [8,23,54,32,12,37,7,23,43], title: "Title", form: ChartForm.small)
+```
+
+### WatchOS support for Bar charts: 
+
+![Pie Charts](./Resources/watchos1.png "Pie Charts")
 
 ## Pie charts
-![Pie Charts](./showcase4.png "Pie Charts")
+![Pie Charts](./Resources/showcase4.png "Pie Charts")
 
-You can add a line chart with the following code: 
+You can add a pie chart with the following code: 
 
 ```swift
  PieChartView(data: [8,23,54,32], title: "Title", legend: "Legendary") // legend is optional
 ```
 
+**Turn drop shadow off by adding to the Initialiser: `dropShadow: false`**
+

Sources/SwiftUICharts/BarChart/BarChartRow.swift

@@ -9,10 +9,10 @@
 import SwiftUI
 
 public struct BarChartRow : View {
-    var data: [Int]
+    var data: [Double]
     var accentColor: Color
     var secondGradientAccentColor: Color?
-    var maxValue: Int {
+    var maxValue: Double {
         data.max() ?? 0
     }
     @Binding var touchLocation: CGFloat
@@ -20,14 +20,19 @@ public struct BarChartRow : View {
         GeometryReader { geometry in
             HStack(alignment: .bottom, spacing: (geometry.frame(in: .local).width-22)/CGFloat(self.data.count * 3)){
                 ForEach(0..<self.data.count) { i in
-                    BarChartCell(value: Double(self.data[i])/Double(self.maxValue), index: i, width: Float(geometry.frame(in: .local).width - 22), numberOfDataPoints: self.data.count, accentColor: self.accentColor, secondGradientAccentColor: self.secondGradientAccentColor, touchLocation: self.$touchLocation)
+                    BarChartCell(value: self.normalizedValue(index: i), index: i, width: Float(geometry.frame(in: .local).width - 22), numberOfDataPoints: self.data.count, accentColor: self.accentColor, secondGradientAccentColor: self.secondGradientAccentColor, touchLocation: self.$touchLocation)
                         .scaleEffect(self.touchLocation > CGFloat(i)/CGFloat(self.data.count) && self.touchLocation < CGFloat(i+1)/CGFloat(self.data.count) ? CGSize(width: 1.4, height: 1.1) : CGSize(width: 1, height: 1), anchor: .bottom)
+                        .animation(.spring())
                     
                 }
             }
             .padding([.top, .leading, .trailing], 10)
         }
     }
+    
+    func normalizedValue(index: Int) -> Double {
+        return Double(self.data[index])/Double(self.maxValue)
+    }
 }
 
 #if DEBUG

Sources/SwiftUICharts/BarChart/BarChartView.swift

@@ -9,78 +9,102 @@
 import SwiftUI
 
 public struct BarChartView : View {
-    public var data: [Int]
+    @Environment(\.colorScheme) var colorScheme: ColorScheme
+    private var data: ChartData
     public var title: String
     public var legend: String?
     public var style: ChartStyle
-    let selectionFeedbackGenerator = UISelectionFeedbackGenerator()
-    
+    public var darkModeStyle: ChartStyle
+    public var formSize:CGSize
+    public var dropShadow: Bool
+    public var cornerImage: Image
+    public var valueSpecifier:String
+
     @State private var touchLocation: CGFloat = -1.0
     @State private var showValue: Bool = false
-    @State private var currentValue: Int = 0 {
+    @State private var showLabelValue: Bool = false
+    @State private var currentValue: Double = 0 {
         didSet{
             if(oldValue != self.currentValue && self.showValue) {
-                selectionFeedbackGenerator.selectionChanged()
+                HapticFeedback.playSelection()
             }
         }
     }
     var isFullWidth:Bool {
-        return self.style.chartFormSize == Form.large
+        return self.formSize == ChartForm.large
     }
-    public init(data: [Int], title: String, legend: String? = nil, style: ChartStyle = Styles.barChartStyleOne ){
+    public init(data:ChartData, title: String, legend: String? = nil, style: ChartStyle = Styles.barChartStyleOrangeLight, form: CGSize? = ChartForm.medium, dropShadow: Bool? = true, cornerImage:Image? = Image(systemName: "waveform.path.ecg"), valueSpecifier: String? = "%.1f"){
         self.data = data
         self.title = title
         self.legend = legend
         self.style = style
+        self.darkModeStyle = style.darkModeStyle != nil ? style.darkModeStyle! : Styles.barChartStyleOrangeDark
+        self.formSize = form!
+        self.dropShadow = dropShadow!
+        self.cornerImage = cornerImage!
+        self.valueSpecifier = valueSpecifier!
     }
     
     public var body: some View {
         ZStack{
             Rectangle()
-                .fill(self.style.backgroundColor)
+                .fill(self.colorScheme == .dark ? self.darkModeStyle.backgroundColor : self.style.backgroundColor)
                 .cornerRadius(20)
-                .shadow(color: Color.gray, radius: 8 )
+                .shadow(color: Color.gray, radius: self.dropShadow ? 8 : 0)
             VStack(alignment: .leading){
                 HStack{
                     if(!showValue){
                         Text(self.title)
                             .font(.headline)
-                            .foregroundColor(self.style.textColor)
+                            .foregroundColor(self.colorScheme == .dark ? self.darkModeStyle.textColor : self.style.textColor)
                     }else{
-                        Text("\(self.currentValue)")
+                        Text("\(self.currentValue, specifier: self.valueSpecifier)")
                             .font(.headline)
-                            .foregroundColor(self.style.textColor)
+                            .foregroundColor(self.colorScheme == .dark ? self.darkModeStyle.textColor : self.style.textColor)
                     }
-                    if(self.style.chartFormSize == Form.large && self.legend != nil && !showValue) {
+                    if(self.formSize == ChartForm.large && self.legend != nil && !showValue) {
                         Text(self.legend!)
                             .font(.callout)
-                            .foregroundColor(self.style.accentColor)
+                            .foregroundColor(self.colorScheme == .dark ? self.darkModeStyle.accentColor : self.style.accentColor)
                             .transition(.opacity)
                             .animation(.easeOut)
                     }
                     Spacer()
-                    Image(systemName: "waveform.path.ecg")
+                    self.cornerImage
                         .imageScale(.large)
-                        .foregroundColor(self.style.legendTextColor)
+                        .foregroundColor(self.colorScheme == .dark ? self.darkModeStyle.legendTextColor : self.style.legendTextColor)
                 }.padding()
-                BarChartRow(data: data, accentColor: self.style.accentColor, secondGradientAccentColor: self.style.secondGradientColor, touchLocation: self.$touchLocation)
-                if self.legend != nil  && self.style.chartFormSize == Form.medium {
+                BarChartRow(data: data.points.map{$0.1},
+                            accentColor: self.colorScheme == .dark ? self.darkModeStyle.accentColor : self.style.accentColor,
+                            secondGradientAccentColor: self.colorScheme == .dark ? self.darkModeStyle.secondGradientColor : self.style.secondGradientColor,
+                            touchLocation: self.$touchLocation)
+                if self.legend != nil  && self.formSize == ChartForm.medium && !self.showLabelValue{
                     Text(self.legend!)
                         .font(.headline)
-                        .foregroundColor(self.style.legendTextColor)
+                        .foregroundColor(self.colorScheme == .dark ? self.darkModeStyle.legendTextColor : self.style.legendTextColor)
                         .padding()
+                }else if (self.data.valuesGiven && self.getCurrentValue() != nil) {
+                    LabelView(arrowOffset: self.getArrowOffset(touchLocation: self.touchLocation),
+                              title: .constant(self.getCurrentValue()!.0)).offset(x: self.getLabelViewOffset(touchLocation: self.touchLocation), y: -6)
                 }
                 
             }
-        }.frame(minWidth:self.style.chartFormSize.width, maxWidth: self.isFullWidth ? .infinity : self.style.chartFormSize.width, minHeight:self.style.chartFormSize.height, maxHeight:self.style.chartFormSize.height)
+        }.frame(minWidth:self.formSize.width,
+                maxWidth: self.isFullWidth ? .infinity : self.formSize.width,
+                minHeight:self.formSize.height,
+                maxHeight:self.formSize.height)
             .gesture(DragGesture()
                 .onChanged({ value in
-                    self.touchLocation = value.location.x/self.style.chartFormSize.width
+                    self.touchLocation = value.location.x/self.formSize.width
                     self.showValue = true
-                    self.currentValue = self.getCurrentValue()
+                    self.currentValue = self.getCurrentValue()?.1 ?? 0
+                    if(self.data.valuesGiven && self.formSize == ChartForm.medium) {
+                        self.showLabelValue = true
+                    }
                 })
                 .onEnded({ value in
                     self.showValue = false
+                    self.showLabelValue = false
                     self.touchLocation = -1
                 })
         )
@@ -88,17 +112,35 @@ public struct BarChartView : View {
         )
     }
     
-    func getCurrentValue()-> Int{
-        let index = max(0,min(self.data.count-1,Int(floor((self.touchLocation*self.style.chartFormSize.width)/(self.style.chartFormSize.width/CGFloat(self.data.count))))))
-        print(index)
-        return self.data[index]
+    func getArrowOffset(touchLocation:CGFloat) -> Binding<CGFloat> {
+        let realLoc = (self.touchLocation * self.formSize.width) - 50
+        if realLoc < 10 {
+            return .constant(realLoc - 10)
+        }else if realLoc > self.formSize.width-110 {
+            return .constant((self.formSize.width-110 - realLoc) * -1)
+        } else {
+            return .constant(0)
+        }
+    }
+    
+    func getLabelViewOffset(touchLocation:CGFloat) -> CGFloat {
+        return min(self.formSize.width-110,max(10,(self.touchLocation * self.formSize.width) - 50))
+    }
+    
+    func getCurrentValue() -> (String,Double)? {
+        guard self.data.points.count > 0 else { return nil}
+        let index = max(0,min(self.data.points.count-1,Int(floor((self.touchLocation*self.formSize.width)/(self.formSize.width/CGFloat(self.data.points.count))))))
+        return self.data.points[index]
     }
 }
 
 #if DEBUG
 struct ChartView_Previews : PreviewProvider {
     static var previews: some View {
-        BarChartView(data: [8,23,54,32,12,37,7,23,43], title: "Title", legend: "Legendary")
+        BarChartView(data: TestData.values ,
+                     title: "Model 3 sales",
+                     legend: "Quarterly",
+                     valueSpecifier: "%.0f")
     }
 }
 #endif

Sources/SwiftUICharts/BarChart/LabelView.swift

@@ -0,0 +1,46 @@
+//
+//  LabelView.swift
+//  BarChart
+//
+//  Created by Samu András on 2020. 01. 08..
+//  Copyright © 2020. Samu András. All rights reserved.
+//
+
+import SwiftUI
+
+struct LabelView: View {
+    @Binding var arrowOffset: CGFloat
+    @Binding var title:String
+    var body: some View {
+        VStack{
+            ArrowUp().fill(Color.white).frame(width: 20, height: 12, alignment: .center).shadow(color: Color.gray, radius: 8, x: 0, y: 0).offset(x: getArrowOffset(offset:self.arrowOffset), y: 12)
+            ZStack{
+                RoundedRectangle(cornerRadius: 8).frame(width: 100, height: 32, alignment: .center).foregroundColor(Color.white).shadow(radius: 8)
+                Text(self.title).font(.caption).bold()
+                ArrowUp().fill(Color.white).frame(width: 20, height: 12, alignment: .center).zIndex(999).offset(x: getArrowOffset(offset:self.arrowOffset), y: -20)
+
+            }
+        }
+    }
+    
+    func getArrowOffset(offset: CGFloat) -> CGFloat {
+        return max(-36,min(36, offset))
+    }
+}
+
+struct ArrowUp: Shape {
+    func path(in rect: CGRect) -> Path {
+        var path = Path()
+        path.move(to: CGPoint(x: 0, y: rect.height))
+        path.addLine(to: CGPoint(x: rect.width/2, y: 0))
+        path.addLine(to: CGPoint(x: rect.width, y: rect.height))
+        path.closeSubpath()
+        return path
+    }
+}
+
+struct LabelView_Previews: PreviewProvider {
+    static var previews: some View {
+        LabelView(arrowOffset: .constant(0), title: .constant("Tesla model 3"))
+    }
+}

Sources/SwiftUICharts/Helpers.swift

@@ -1,6 +1,6 @@
 //
 //  File.swift
-//  
+//
 //
 //  Created by András Samu on 2019. 07. 19..
 //
@@ -19,6 +19,7 @@ public struct Colors {
     public static let OrangeEnd:Color = Color(hexString: "#EC2301")
     public static let LegendText:Color = Color(hexString: "#A7A6A8")
     public static let LegendColor:Color = Color(hexString: "#E8E7EA")
+    public static let LegendDarkColor:Color = Color(hexString: "#545454")
     public static let IndicatorKnob:Color = Color(hexString: "#FF57A6")
     public static let GradientUpperBlue:Color = Color(hexString: "#C2E8FF")
     public static let GradinetUpperBlue1:Color = Color(hexString: "#A8E1FF")
@@ -27,8 +28,6 @@ public struct Colors {
     public static let GradientLowerBlue:Color = Color(hexString: "#F1F9FF")
     public static let DarkPurple:Color = Color(hexString: "#1B205E")
     public static let BorderBlue:Color = Color(hexString: "#4EBCFF")
-    
-    
 }
 
 public struct Styles {
@@ -36,63 +35,94 @@ public struct Styles {
         backgroundColor: Color.white,
         accentColor: Colors.OrangeStart,
         secondGradientColor: Colors.OrangeEnd,
-        chartFormSize: Form.medium,
         textColor: Color.black,
         legendTextColor: Color.gray)
     
-    public static let barChartStyleOne = ChartStyle(
+    public static let barChartStyleOrangeLight = ChartStyle(
         backgroundColor: Color.white,
         accentColor: Colors.OrangeStart,
         secondGradientColor: Colors.OrangeEnd,
-        chartFormSize: Form.medium,
         textColor: Color.black,
         legendTextColor: Color.gray)
     
-    public static let barChartStyleTwo = ChartStyle(
+    public static let barChartStyleOrangeDark = ChartStyle(
+        backgroundColor: Color.black,
+        accentColor: Colors.OrangeStart,
+        secondGradientColor: Colors.OrangeEnd,
+        textColor: Color.white,
+        legendTextColor: Color.gray)
+    
+    public static let barChartStyleNeonBlueLight = ChartStyle(
         backgroundColor: Color.white,
         accentColor: Colors.GradientNeonBlue,
         secondGradientColor: Colors.GradientPurple,
-        chartFormSize: Form.medium,
         textColor: Color.black,
         legendTextColor: Color.gray)
     
-    public static let barChartStyleThree = ChartStyle(
+    public static let barChartStyleNeonBlueDark = ChartStyle(
         backgroundColor: Color.black,
         accentColor: Colors.GradientNeonBlue,
         secondGradientColor: Colors.GradientPurple,
-        chartFormSize: Form.medium,
         textColor: Color.white,
         legendTextColor: Color.gray)
     
+    public static let barChartMidnightGreenDark = ChartStyle(
+        backgroundColor: Color(hexString: "#36534D"), //3B5147, 313D34
+        accentColor: Color(hexString: "#FFD603"),
+        secondGradientColor: Color(hexString: "#FFCA04"),
+        textColor: Color.white,
+        legendTextColor: Color(hexString: "#D2E5E1"))
+    
+    public static let barChartMidnightGreenLight = ChartStyle(
+        backgroundColor: Color.white,
+        accentColor: Color(hexString: "#84A094"), //84A094 , 698378
+        secondGradientColor: Color(hexString: "#50675D"),
+        textColor: Color.black,
+        legendTextColor:Color.gray)
+    
     public static let pieChartStyleOne = ChartStyle(
         backgroundColor: Color.white,
         accentColor: Colors.OrangeStart,
         secondGradientColor: Colors.OrangeEnd,
-        chartFormSize: Form.medium,
         textColor: Color.black,
         legendTextColor: Color.gray)
+    
+    public static let lineViewDarkMode = ChartStyle(
+        backgroundColor: Color.black,
+        accentColor: Colors.OrangeStart,
+        secondGradientColor: Colors.OrangeEnd,
+        textColor: Color.white,
+        legendTextColor: Color.white)
 }
 
-public struct Form {
+public struct ChartForm {
+    #if os(watchOS)
+    public static let small = CGSize(width:120, height:90)
+    public static let medium = CGSize(width:120, height:160)
+    public static let large = CGSize(width:180, height:90)
+    public static let detail = CGSize(width:180, height:160)
+    #else
     public static let small = CGSize(width:180, height:120)
     public static let medium = CGSize(width:180, height:240)
     public static let large = CGSize(width:360, height:120)
     public static let detail = CGSize(width:180, height:120)
+    #endif
+    
+    
 }
 
-public struct ChartStyle {
+public class ChartStyle {
     public var backgroundColor: Color
     public var accentColor: Color
     public var secondGradientColor: Color
-    public var chartFormSize: CGSize
     public var textColor: Color
     public var legendTextColor: Color
+    public weak var darkModeStyle: ChartStyle?
     
-    public init(backgroundColor: Color, accentColor: Color, secondGradientColor: Color, chartFormSize: CGSize, textColor: Color, legendTextColor: Color){
+    public init(backgroundColor: Color, accentColor: Color, secondGradientColor: Color, textColor: Color, legendTextColor: Color){
         self.backgroundColor = backgroundColor
         self.accentColor = accentColor
         self.secondGradientColor = secondGradientColor
-        self.chartFormSize = chartFormSize
         self.textColor = textColor
         self.legendTextColor = legendTextColor
     }
@@ -101,31 +131,57 @@ public struct ChartStyle {
         self.backgroundColor = Color.white
         self.accentColor = Colors.OrangeStart
         self.secondGradientColor = Colors.OrangeEnd
-        self.chartFormSize = formSize
         self.legendTextColor = Color.gray
         self.textColor = Color.black
     }
 }
 
-class ChartData: ObservableObject {
-    @Published var points: [Int] = [Int]()
-    @Published var currentPoint: Int? = nil
+public class ChartData: ObservableObject {
+    @Published var points: [(String,Double)]
+    var valuesGiven: Bool = false
     
-    init(points:[Int]) {
-        self.points = points
+    public init<N: BinaryFloatingPoint>(points:[N]) {
+        self.points = points.map{("", Double($0))}
+    }
+    public init<N: BinaryInteger>(values:[(String,N)]){
+        self.points = values.map{($0.0, Double($0.1))}
+        self.valuesGiven = true
+    }
+    public init<N: BinaryFloatingPoint>(values:[(String,N)]){
+        self.points = values.map{($0.0, Double($0.1))}
+        self.valuesGiven = true
+    }
+    public init<N: BinaryInteger>(numberValues:[(N,N)]){
+        self.points = numberValues.map{(String($0.0), Double($0.1))}
+        self.valuesGiven = true
+    }
+    public init<N: BinaryFloatingPoint & LosslessStringConvertible>(numberValues:[(N,N)]){
+        self.points = numberValues.map{(String($0.0), Double($0.1))}
+        self.valuesGiven = true
+    }
+    
+    public func onlyPoints() -> [Double] {
+        return self.points.map{ $0.1 }
     }
 }
 
-class TestData{
+public class TestData{
     static public var data:ChartData = ChartData(points: [37,72,51,22,39,47,66,85,50])
+    static public var values:ChartData = ChartData(values: [("2017 Q3",220),
+                                                            ("2017 Q4",1550),
+                                                            ("2018 Q1",8180),
+                                                            ("2018 Q2",18440),
+                                                            ("2018 Q3",55840),
+                                                            ("2018 Q4",63150), ("2019 Q1",50900), ("2019 Q2",77550), ("2019 Q3",79600), ("2019 Q4",92550)])
+    
 }
 
 extension Color {
     init(hexString: String) {
         let hex = hexString.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
-        var int = UInt32()
-        Scanner(string: hex).scanHexInt32(&int)
-        let r, g, b: UInt32
+        var int = UInt64()
+        Scanner(string: hex).scanHexInt64(&int)
+        let r, g, b: UInt64
         switch hex.count {
         case 3: // RGB (12-bit)
             (r, g, b) = ((int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
@@ -139,3 +195,18 @@ extension Color {
         self.init(red: Double(r) / 255, green: Double(g) / 255, blue: Double(b) / 255)
     }
 }
+
+class HapticFeedback {
+    #if os(watchOS)
+    //watchOS implementation
+    static func playSelection() -> Void {
+        WKInterfaceDevice.current().play(.click)
+    }
+    #else
+    //iOS implementation
+    let selectionFeedbackGenerator = UISelectionFeedbackGenerator()
+    static func playSelection() -> Void {
+        UISelectionFeedbackGenerator().selectionChanged()
+    }
+    #endif
+}

Sources/SwiftUICharts/LineChart/Legend.swift

@@ -12,23 +12,41 @@ struct Legend: View {
     @ObservedObject var data: ChartData
     @Binding var frame: CGRect
     @Binding var hideHorizontalLines: Bool
-    
+    @Environment(\.colorScheme) var colorScheme: ColorScheme
+    let padding:CGFloat = 3
+
     var stepWidth: CGFloat {
+        if data.points.count < 2 {
+            return 0
+        }
         return frame.size.width / CGFloat(data.points.count-1)
     }
     var stepHeight: CGFloat {
-        return frame.size.height / CGFloat(data.points.max()! + data.points.min()!)
+        let points = self.data.onlyPoints()
+        if let min = points.min(), let max = points.max(), min != max {
+            if (min < 0){
+                return (frame.size.height-padding) / CGFloat(max - min)
+            }else{
+                return (frame.size.height-padding) / CGFloat(max + min)
+            }
+        }
+        return 0
+    }
+    
+    var min: CGFloat {
+        let points = self.data.onlyPoints()
+        return CGFloat(points.min() ?? 0)
     }
     
     var body: some View {
         ZStack(alignment: .topLeading){
             ForEach((0...4), id: \.self) { height in
                 HStack(alignment: .center){
-                    Text("\(self.getYLegend()![height])").offset(x: 0, y: (self.frame.height-CGFloat(self.getYLegend()![height])*self.stepHeight)-(self.frame.height/2))
+                    Text("\(self.getYLegendSafe(height: height), specifier: "%.2f")").offset(x: 0, y: self.getYposition(height: height) )
                         .foregroundColor(Colors.LegendText)
                         .font(.caption)
-                     self.line(atHeight: CGFloat(self.getYLegend()![height]), width: self.frame.width)
-                        .stroke(Colors.LegendColor, style: StrokeStyle(lineWidth: 1.5, lineCap: .round, dash: [5,height == 0 ? 0 : 10]))
+                    self.line(atHeight: self.getYLegendSafe(height: height), width: self.frame.width)
+                        .stroke(self.colorScheme == .dark ? Colors.LegendDarkColor : Colors.LegendColor, style: StrokeStyle(lineWidth: 1.5, lineCap: .round, dash: [5,height == 0 ? 0 : 10]))
                         .opacity((self.hideHorizontalLines && height != 0) ? 0 : 1)
                         .rotationEffect(.degrees(180), anchor: .center)
                         .rotation3DEffect(.degrees(180), axis: (x: 0, y: 1, z: 0))
@@ -41,30 +59,41 @@ struct Legend: View {
         }
     }
     
+    func getYLegendSafe(height:Int)->CGFloat{
+        if let legend = getYLegend() {
+            return CGFloat(legend[height])
+        }
+        return 0
+    }
+    
+    func getYposition(height: Int)-> CGFloat {
+        if let legend = getYLegend() {
+            return (self.frame.height-((CGFloat(legend[height]) - min)*self.stepHeight))-(self.frame.height/2)
+        }
+        return 0
+       
+    }
+    
     func line(atHeight: CGFloat, width: CGFloat) -> Path {
         var hLine = Path()
-        hLine.move(to: CGPoint(x:5, y: atHeight*stepHeight))
-        hLine.addLine(to: CGPoint(x: width, y: atHeight*stepHeight))
+        hLine.move(to: CGPoint(x:5, y: (atHeight-min)*stepHeight))
+        hLine.addLine(to: CGPoint(x: width, y: (atHeight-min)*stepHeight))
         return hLine
     }
     
-    func getYLegend() -> [Int]? {
-        guard let max = data.points.max() else { return nil }
-        guard let min = data.points.min() else { return nil }
-        if(min > 0){
-            let upperBound = ((max/10)+1) * 10
-            let step = upperBound/4
-            return [step * 0,step * 1, step * 2, step * 3, step * 4]
-        }
-        
-        return nil
+    func getYLegend() -> [Double]? {
+        let points = self.data.onlyPoints()
+        guard let max = points.max() else { return nil }
+        guard let min = points.min() else { return nil }
+        let step = Double(max - min)/4
+        return [min+step * 0, min+step * 1, min+step * 2, min+step * 3, min+step * 4]
     }
 }
 
 struct Legend_Previews: PreviewProvider {
     static var previews: some View {
         GeometryReader{ geometry in
-            Legend(data: TestData.data, frame: .constant(geometry.frame(in: .local)), hideHorizontalLines: .constant(false))
+            Legend(data: ChartData(points: [0.2,0.4,1.4,4.5]), frame: .constant(geometry.frame(in: .local)), hideHorizontalLines: .constant(false))
         }.frame(width: 320, height: 200)
     }
 }

Sources/SwiftUICharts/LineChart/Line.swift

@@ -15,18 +15,31 @@ struct Line: View {
     @Binding var showIndicator: Bool
     @State private var showFull: Bool = false
     @State var showBackground: Bool = true
-    
+    let padding:CGFloat = 30
     var stepWidth: CGFloat {
+        if data.points.count < 2 {
+            return 0
+        }
         return frame.size.width / CGFloat(data.points.count-1)
     }
     var stepHeight: CGFloat {
-        return frame.size.height / CGFloat(data.points.max()! + data.points.min()!)
+        let points = self.data.onlyPoints()
+        if let min = points.min(), let max = points.max(), min != max {
+            if (min <= 0){
+                return (frame.size.height-padding) / CGFloat(points.max()! - points.min()!)
+            }else{
+                return (frame.size.height-padding) / CGFloat(points.max()! + points.min()!)
+            }
+        }
+        return 0
     }
     var path: Path {
-        return Path.quadCurvedPathWithPoints(points: data.points, step: CGPoint(x: stepWidth, y: stepHeight))
+        let points = self.data.onlyPoints()
+        return Path.quadCurvedPathWithPoints(points: points, step: CGPoint(x: stepWidth, y: stepHeight))
     }
     var closedPath: Path {
-        return Path.quadClosedCurvedPathWithPoints(points: data.points, step: CGPoint(x: stepWidth, y: stepHeight))
+        let points = self.data.onlyPoints()
+        return Path.quadClosedCurvedPathWithPoints(points: points, step: CGPoint(x: stepWidth, y: stepHeight))
     }
     
     var body: some View {
@@ -45,9 +58,13 @@ struct Line: View {
                 .rotationEffect(.degrees(180), anchor: .center)
                 .rotation3DEffect(.degrees(180), axis: (x: 0, y: 1, z: 0))
                 .animation(.easeOut(duration: 1.2))
-                .onAppear(){
-                    self.showFull.toggle()
-            }.drawingGroup()
+                .onAppear {
+                    self.showFull = true
+                }
+                .onDisappear {
+                    self.showFull = false
+                }
+            .drawingGroup()
             if(self.showIndicator) {
                 IndicatorPoint()
                     .position(self.getClosestPointOnPath(touchLocation: self.touchLocation))
@@ -58,8 +75,7 @@ struct Line: View {
     }
     
     func getClosestPointOnPath(touchLocation: CGPoint) -> CGPoint {
-        let percentage:CGFloat = min(max(touchLocation.x,0)/self.frame.width,1)
-        let closest = self.path.percentPoint(percentage)
+        let closest = self.path.point(to: touchLocation.x)
         return closest
     }
     
@@ -67,24 +83,24 @@ struct Line: View {
 
 extension CGPoint {
     static func getMidPoint(point1: CGPoint, point2: CGPoint) -> CGPoint {
-      return CGPoint(
-        x: point1.x + (point2.x - point1.x) / 2,
-        y: point1.y + (point2.y - point1.y) / 2
-      )
+        return CGPoint(
+            x: point1.x + (point2.x - point1.x) / 2,
+            y: point1.y + (point2.y - point1.y) / 2
+        )
     }
     
     func dist(to: CGPoint) -> CGFloat {
-      return sqrt((pow(self.x - to.x, 2) + pow(self.y - to.y, 2)))
+        return sqrt((pow(self.x - to.x, 2) + pow(self.y - to.y, 2)))
     }
     
     static func midPointForPoints(p1:CGPoint, p2:CGPoint) -> CGPoint {
         return CGPoint(x:(p1.x + p2.x) / 2,y: (p1.y + p2.y) / 2)
     }
-
+    
     static func controlPointForPoints(p1:CGPoint, p2:CGPoint) -> CGPoint {
         var controlPoint = CGPoint.midPointForPoints(p1:p1, p2:p2)
         let diffY = abs(p2.y - controlPoint.y)
-
+        
         if (p1.y < p2.y){
             controlPoint.y += diffY
         } else if (p1.y > p2.y) {
@@ -94,16 +110,17 @@ extension CGPoint {
     }
 }
 extension Path {
-    static func quadCurvedPathWithPoints(points:[Int], step:CGPoint) -> Path {
+    static func quadCurvedPathWithPoints(points:[Double], step:CGPoint) -> Path {
         var path = Path()
-        var p1 = CGPoint(x: 0, y: CGFloat(points[0])*step.y)
-        path.move(to: p1)
-        if(points.count < 2){
-            path.addLine(to: CGPoint(x: step.x, y: step.y*CGFloat(points[1])))
+        if (points.count < 2){
             return path
         }
+        guard var offset = points.min() else { return path }
+//        offset -= 3
+        var p1 = CGPoint(x: 0, y: CGFloat(points[0]-offset)*step.y)
+        path.move(to: p1)
         for pointIndex in 1..<points.count {
-            let p2 = CGPoint(x: step.x * CGFloat(pointIndex), y: step.y*CGFloat(points[pointIndex]))
+            let p2 = CGPoint(x: step.x * CGFloat(pointIndex), y: step.y*CGFloat(points[pointIndex]-offset))
             let midPoint = CGPoint.midPointForPoints(p1: p1, p2: p2)
             path.addQuadCurve(to: midPoint, control: CGPoint.controlPointForPoints(p1: midPoint, p2: p1))
             path.addQuadCurve(to: p2, control: CGPoint.controlPointForPoints(p1: midPoint, p2: p2))
@@ -112,17 +129,18 @@ extension Path {
         return path
     }
     
-    static func quadClosedCurvedPathWithPoints(points:[Int], step:CGPoint) -> Path {
+    static func quadClosedCurvedPathWithPoints(points:[Double], step:CGPoint) -> Path {
         var path = Path()
-        path.move(to: .zero)
-        var p1 = CGPoint(x: 0, y: CGFloat(points[0])*step.y)
-        path.addLine(to: p1)
-        if(points.count < 2){
-            path.addLine(to: CGPoint(x: step.x, y: step.y*CGFloat(points[1])))
+        if (points.count < 2){
             return path
         }
+        guard var offset = points.min() else { return path }
+//        offset -= 3
+        path.move(to: .zero)
+        var p1 = CGPoint(x: 0, y: CGFloat(points[0]-offset)*step.y)
+        path.addLine(to: p1)
         for pointIndex in 1..<points.count {
-            let p2 = CGPoint(x: step.x * CGFloat(pointIndex), y: step.y*CGFloat(points[pointIndex]))
+            let p2 = CGPoint(x: step.x * CGFloat(pointIndex), y: step.y*CGFloat(points[pointIndex]-offset))
             let midPoint = CGPoint.midPointForPoints(p1: p1, p2: p2)
             path.addQuadCurve(to: midPoint, control: CGPoint.controlPointForPoints(p1: midPoint, p2: p1))
             path.addQuadCurve(to: p2, control: CGPoint.controlPointForPoints(p1: midPoint, p2: p2))
@@ -132,28 +150,12 @@ extension Path {
         path.closeSubpath()
         return path
     }
-    
-    func percentPoint(_ percent: CGFloat) -> CGPoint {
-        // percent difference between points
-        let diff: CGFloat = 0.001
-        let comp: CGFloat = 1 - diff
-        
-        // handle limits
-        let pct = percent > 1 ? 0 : (percent < 0 ? 1 : percent)
-        
-        let f = pct > comp ? comp : pct
-        let t = pct > comp ? 1 : pct + diff
-        let tp = self.trimmedPath(from: f, to: t)
-        
-        return CGPoint(x: tp.boundingRect.midX, y: tp.boundingRect.midY)
-    }
-    
 }
 
 struct Line_Previews: PreviewProvider {
     static var previews: some View {
         GeometryReader{ geometry in
-            Line(data: TestData.data, frame: .constant(geometry.frame(in: .local)), touchLocation: .constant(CGPoint(x: 300, y: 12)), showIndicator: .constant(true))
+            Line(data: ChartData(points: [12,-230,10,54]), frame: .constant(geometry.frame(in: .local)), touchLocation: .constant(CGPoint(x: 100, y: 12)), showIndicator: .constant(true))
         }.frame(width: 320, height: 160)
     }
 }

Sources/SwiftUICharts/LineChart/LineChartView.swift

@@ -8,44 +8,76 @@
 
 import SwiftUI
 
-struct LineChartView: View {
-    let selectionFeedbackGenerator = UISelectionFeedbackGenerator()
+public struct LineChartView: View {
+    @Environment(\.colorScheme) var colorScheme: ColorScheme
     @ObservedObject var data:ChartData
     public var title: String
     public var legend: String?
     public var style: ChartStyle
+    public var darkModeStyle: ChartStyle
+
+    public var formSize:CGSize
+    public var dropShadow: Bool
+    public var valueSpecifier:String
+
     @State private var touchLocation:CGPoint = .zero
     @State private var showIndicatorDot: Bool = false
-    @State private var currentValue: Int = 2 {
+    @State private var currentValue: Double = 2 {
         didSet{
             if (oldValue != self.currentValue && showIndicatorDot) {
-                selectionFeedbackGenerator.selectionChanged()
+                HapticFeedback.playSelection()
             }
             
         }
     }
     let frame = CGSize(width: 180, height: 120)
+    private var rateValue: Int
     
-    public init(data: [Int], title: String, legend: String? = nil, style: ChartStyle = Styles.lineChartStyleOne ){
+    public init(data: [Double],
+                title: String,
+                legend: String? = nil,
+                style: ChartStyle = Styles.lineChartStyleOne,
+                form: CGSize? = ChartForm.medium,
+                rateValue: Int? = 14,
+                dropShadow: Bool? = true,
+                valueSpecifier: String? = "%.1f") {
+        
         self.data = ChartData(points: data)
         self.title = title
         self.legend = legend
         self.style = style
+        self.darkModeStyle = style.darkModeStyle != nil ? style.darkModeStyle! : Styles.lineViewDarkMode
+        self.formSize = form!
+        self.rateValue = rateValue!
+        self.dropShadow = dropShadow!
+        self.valueSpecifier = valueSpecifier!
     }
     
-    var body: some View {
+    public var body: some View {
         ZStack(alignment: .center){
-            RoundedRectangle(cornerRadius: 20).fill(self.style.backgroundColor).frame(width: frame.width, height: 240, alignment: .center).shadow(radius: 8)
+            RoundedRectangle(cornerRadius: 20)
+                .fill(self.colorScheme == .dark ? self.darkModeStyle.backgroundColor : self.style.backgroundColor)
+                .frame(width: frame.width, height: 240, alignment: .center)
+                .shadow(radius: self.dropShadow ? 8 : 0)
             VStack(alignment: .leading){
                 if(!self.showIndicatorDot){
                     VStack(alignment: .leading, spacing: 8){
-                        Text(self.title).font(.title).bold().foregroundColor(self.style.textColor)
+                        Text(self.title)
+                            .font(.title)
+                            .bold()
+                            .foregroundColor(self.colorScheme == .dark ? self.darkModeStyle.textColor : self.style.textColor)
                         if (self.legend != nil){
-                            Text(self.legend!).font(.callout).foregroundColor(self.style.legendTextColor)
+                            Text(self.legend!)
+                                .font(.callout)
+                                .foregroundColor(self.colorScheme == .dark ? self.darkModeStyle.legendTextColor :self.style.legendTextColor)
                         }
                         HStack {
-                            Image(systemName: "arrow.up")
-                            Text("14%")
+                            if (self.rateValue >= 0){
+                                Image(systemName: "arrow.up")
+                            }else{
+                                Image(systemName: "arrow.down")
+                            }
+                            Text("\(self.rateValue)%")
                         }
                     }
                     .transition(.opacity)
@@ -54,23 +86,23 @@ struct LineChartView: View {
                 }else{
                     HStack{
                         Spacer()
-                        Text("\(self.currentValue)")
+                        Text("\(self.currentValue, specifier: self.valueSpecifier)")
                             .font(.system(size: 41, weight: .bold, design: .default))
                             .offset(x: 0, y: 30)
                         Spacer()
                     }
                     .transition(.scale)
-                    .animation(.spring())
-                    
                 }
                 Spacer()
                 GeometryReader{ geometry in
-                    Line(data: self.data, frame: .constant(geometry.frame(in: .local)), touchLocation: self.$touchLocation, showIndicator: self.$showIndicatorDot)
+                    Line(data: self.data,
+                         frame: .constant(geometry.frame(in: .local)),
+                         touchLocation: self.$touchLocation, showIndicator: self.$showIndicatorDot)
                 }
-                .frame(width: frame.width, height: frame.height)
+                .frame(width: frame.width, height: frame.height + 30)
                 .clipShape(RoundedRectangle(cornerRadius: 20))
                 .offset(x: 0, y: 0)
-            }.frame(width: self.style.chartFormSize.width, height: self.style.chartFormSize.height)
+            }.frame(width: self.formSize.width, height: self.formSize.height)
         }
         .gesture(DragGesture()
         .onChanged({ value in
@@ -84,14 +116,15 @@ struct LineChartView: View {
         )
     }
     
-    func getClosestDataPoint(toPoint: CGPoint, width:CGFloat, height: CGFloat) -> CGPoint {
-        let stepWidth: CGFloat = width / CGFloat(data.points.count-1)
-        let stepHeight: CGFloat = height / CGFloat(data.points.max()! + data.points.min()!)
+    @discardableResult func getClosestDataPoint(toPoint: CGPoint, width:CGFloat, height: CGFloat) -> CGPoint {
+        let points = self.data.onlyPoints()
+        let stepWidth: CGFloat = width / CGFloat(points.count-1)
+        let stepHeight: CGFloat = height / CGFloat(points.max()! + points.min()!)
         
         let index:Int = Int(round((toPoint.x)/stepWidth))
-        if (index >= 0 && index < data.points.count){
-            self.currentValue = self.data.points[index]
-            return CGPoint(x: CGFloat(index)*stepWidth, y: CGFloat(self.data.points[index])*stepHeight)
+        if (index >= 0 && index < points.count){
+            self.currentValue = points[index]
+            return CGPoint(x: CGFloat(index)*stepWidth, y: CGFloat(points[index])*stepHeight)
         }
         return .zero
     }

Sources/SwiftUICharts/LineChart/LineView.swift

@@ -0,0 +1,153 @@
+//
+//  LineView.swift
+//  LineChart
+//
+//  Created by András Samu on 2019. 09. 02..
+//  Copyright © 2019. András Samu. All rights reserved.
+//
+
+import SwiftUI
+
+public struct LineView: View {
+    @ObservedObject var data: ChartData
+    public var title: String?
+    public var legend: String?
+    public var style: ChartStyle
+    public var darkModeStyle: ChartStyle
+    public var valueSpecifier:String
+
+    @Environment(\.colorScheme) var colorScheme: ColorScheme
+    @State private var showLegend = false
+    @State private var dragLocation:CGPoint = .zero
+    @State private var indicatorLocation:CGPoint = .zero
+    @State private var closestPoint: CGPoint = .zero
+    @State private var opacity:Double = 0
+    @State private var currentDataNumber: Double = 0
+    @State private var hideHorizontalLines: Bool = false
+    
+    public init(data: [Double],
+                title: String? = nil,
+                legend: String? = nil,
+                style: ChartStyle = Styles.lineChartStyleOne,
+                valueSpecifier: String? = "%.1f") {
+        
+        self.data = ChartData(points: data)
+        self.title = title
+        self.legend = legend
+        self.style = style
+        self.valueSpecifier = valueSpecifier!
+        self.darkModeStyle = style.darkModeStyle != nil ? style.darkModeStyle! : Styles.lineViewDarkMode
+    }
+    
+   public var body: some View {
+        GeometryReader{ geometry in
+            VStack(alignment: .leading, spacing: 8) {
+                Group{
+                    if (self.title != nil){
+                        Text(self.title!)
+                            .font(.title)
+                            .bold().foregroundColor(self.colorScheme == .dark ? self.darkModeStyle.textColor : self.style.textColor)
+                    }
+                    if (self.legend != nil){
+                        Text(self.legend!)
+                            .font(.callout)
+                            .foregroundColor(self.colorScheme == .dark ? self.darkModeStyle.legendTextColor : self.style.legendTextColor)
+                    }
+                }.offset(x: 0, y: 20)
+                ZStack{
+                    GeometryReader{ reader in
+                        Rectangle()
+                            .foregroundColor(self.colorScheme == .dark ? self.darkModeStyle.backgroundColor : self.style.backgroundColor)
+                        if(self.showLegend){
+                            Legend(data: self.data,
+                                   frame: .constant(reader.frame(in: .local)), hideHorizontalLines: self.$hideHorizontalLines)
+                                .transition(.opacity)
+                                .animation(Animation.easeOut(duration: 1).delay(1))
+                        }
+                        Line(data: self.data,
+                             frame: .constant(CGRect(x: 0, y: 0, width: reader.frame(in: .local).width - 30, height: reader.frame(in: .local).height)),
+                             touchLocation: self.$indicatorLocation,showIndicator: self.$hideHorizontalLines ,showBackground: false)
+                            .offset(x: 30, y: 0)
+                            .onAppear(){
+                                self.showLegend.toggle()
+                            }
+                    }
+                    .frame(width: geometry.frame(in: .local).size.width, height: 240)
+                    .offset(x: 0, y: 40 )
+                    MagnifierRect(currentNumber: self.$currentDataNumber, valueSpecifier: self.valueSpecifier)
+                        .opacity(self.opacity)
+                        .offset(x: self.dragLocation.x - geometry.frame(in: .local).size.width/2, y: 36)
+                }
+                .frame(width: geometry.frame(in: .local).size.width, height: 240)
+                .gesture(DragGesture()
+                    .onChanged({ value in
+                        self.dragLocation = value.location
+                        self.indicatorLocation = CGPoint(x: max(value.location.x-30,0), y: 32)
+                        self.opacity = 1
+                        self.closestPoint = self.getClosestDataPoint(toPoint: value.location, width: geometry.frame(in: .local).size.width-30, height: 240)
+                        self.hideHorizontalLines = true
+                    })
+                    .onEnded({ value in
+                        self.opacity = 0
+                        self.hideHorizontalLines = false
+                    })
+                )
+            }
+        }
+    }
+    
+    func getClosestDataPoint(toPoint: CGPoint, width:CGFloat, height: CGFloat) -> CGPoint {
+        let points = self.data.onlyPoints()
+        let stepWidth: CGFloat = width / CGFloat(points.count-1)
+        let stepHeight: CGFloat = height / CGFloat(points.max()! + points.min()!)
+
+        let index:Int = Int(floor((toPoint.x-15)/stepWidth))
+        if (index >= 0 && index < points.count){
+            self.currentDataNumber = points[index]
+            return CGPoint(x: CGFloat(index)*stepWidth, y: CGFloat(points[index])*stepHeight)
+        }
+        return .zero
+    }
+}
+
+struct LineView_Previews: PreviewProvider {
+    static var previews: some View {
+        LineView(data: [8,23,54,32,12,37,7,23,43], title: "Full chart", style: Styles.lineChartStyleOne)
+    }
+}
+
+struct IndicatorCircle: View {
+    var body: some View {
+       Circle()
+        .size(width: 12, height: 12)
+        .fill(Colors.BorderBlue)
+    }
+}
+
+struct MagnifierRect: View {
+    @Binding var currentNumber: Double
+    var valueSpecifier:String
+    @Environment(\.colorScheme) var colorScheme: ColorScheme
+    var body: some View {
+        ZStack{
+            Text("\(self.currentNumber, specifier: valueSpecifier)")
+                .font(.system(size: 18, weight: .bold))
+                .offset(x: 0, y:-110)
+                .foregroundColor(self.colorScheme == .dark ? Color.white : Color.black)
+            if (self.colorScheme == .dark ){
+                 RoundedRectangle(cornerRadius: 16)
+                    .stroke(Color.white, lineWidth: self.colorScheme == .dark ? 2 : 0)
+                    .frame(width: 60, height: 260)
+                    
+            }else{
+                 RoundedRectangle(cornerRadius: 16)
+                    .frame(width: 60, height: 280)
+                    .foregroundColor(Color.white)
+                    .shadow(color: Colors.LegendText, radius: 12, x: 0, y: 6 )
+                    .blendMode(.multiply)
+            }
+           
+
+        }
+    }
+}

Sources/SwiftUICharts/LineChart/Path+QuadCurve.swift

@@ -0,0 +1,251 @@
+//
+//  File.swift
+//  
+//
+//  Created by xspyhack on 2020/1/21.
+//
+
+import SwiftUI
+
+extension Path {
+    func trimmedPath(for percent: CGFloat) -> Path {
+        // percent difference between points
+        let boundsDistance: CGFloat = 0.001
+        let completion: CGFloat = 1 - boundsDistance
+
+        let pct = percent > 1 ? 0 : (percent < 0 ? 1 : percent)
+
+        let start = pct > completion ? completion : pct - boundsDistance
+        let end = pct > completion ? 1 : pct + boundsDistance
+        return trimmedPath(from: start, to: end)
+    }
+
+    func point(for percent: CGFloat) -> CGPoint {
+        let path = trimmedPath(for: percent)
+        return CGPoint(x: path.boundingRect.midX, y: path.boundingRect.midY)
+    }
+
+    func point(to maxX: CGFloat) -> CGPoint {
+        let total = length
+        let sub = length(to: maxX)
+        let percent = sub / total
+        return point(for: percent)
+    }
+
+    var length: CGFloat {
+        var ret: CGFloat = 0.0
+        var start: CGPoint?
+        var point = CGPoint.zero
+
+        forEach { ele in
+            switch ele {
+            case .move(let to):
+                if start == nil {
+                    start = to
+                }
+                point = to
+            case .line(let to):
+                ret += point.line(to: to)
+                point = to
+            case .quadCurve(let to, let control):
+                ret += point.quadCurve(to: to, control: control)
+                point = to
+            case .curve(let to, let control1, let control2):
+                ret += point.curve(to: to, control1: control1, control2: control2)
+                point = to
+            case .closeSubpath:
+                if let to = start {
+                    ret += point.line(to: to)
+                    point = to
+                }
+                start = nil
+            }
+        }
+        return ret
+    }
+
+    func length(to maxX: CGFloat) -> CGFloat {
+        var ret: CGFloat = 0.0
+        var start: CGPoint?
+        var point = CGPoint.zero
+        var finished = false
+
+        forEach { ele in
+            if finished {
+                return
+            }
+            switch ele {
+            case .move(let to):
+                if to.x > maxX {
+                    finished = true
+                    return
+                }
+                if start == nil {
+                    start = to
+                }
+                point = to
+            case .line(let to):
+                if to.x > maxX {
+                    finished = true
+                    ret += point.line(to: to, x: maxX)
+                    return
+                }
+                ret += point.line(to: to)
+                point = to
+            case .quadCurve(let to, let control):
+                if to.x > maxX {
+                    finished = true
+                    ret += point.quadCurve(to: to, control: control, x: maxX)
+                    return
+                }
+                ret += point.quadCurve(to: to, control: control)
+                point = to
+            case .curve(let to, let control1, let control2):
+                if to.x > maxX {
+                    finished = true
+                    ret += point.curve(to: to, control1: control1, control2: control2, x: maxX)
+                    return
+                }
+                ret += point.curve(to: to, control1: control1, control2: control2)
+                point = to
+            case .closeSubpath:
+                fatalError("Can't include closeSubpath")
+            }
+        }
+        return ret
+    }
+}
+
+extension CGPoint {
+    func point(to: CGPoint, x: CGFloat) -> CGPoint {
+        let a = (to.y - self.y) / (to.x - self.x)
+        let y = self.y + (x - self.x) * a
+        return CGPoint(x: x, y: y)
+    }
+
+    func line(to: CGPoint) -> CGFloat {
+        dist(to: to)
+    }
+
+    func line(to: CGPoint, x: CGFloat) -> CGFloat {
+        dist(to: point(to: to, x: x))
+    }
+
+    func quadCurve(to: CGPoint, control: CGPoint) -> CGFloat {
+        var dist: CGFloat = 0
+        let steps: CGFloat = 100
+
+        for i in 0..<Int(steps) {
+            let t0 = CGFloat(i) / steps
+            let t1 = CGFloat(i+1) / steps
+            let a = point(to: to, t: t0, control: control)
+            let b = point(to: to, t: t1, control: control)
+
+            dist += a.line(to: b)
+        }
+        return dist
+    }
+
+    func quadCurve(to: CGPoint, control: CGPoint, x: CGFloat) -> CGFloat {
+        var dist: CGFloat = 0
+        let steps: CGFloat = 100
+
+        for i in 0..<Int(steps) {
+            let t0 = CGFloat(i) / steps
+            let t1 = CGFloat(i+1) / steps
+            let a = point(to: to, t: t0, control: control)
+            let b = point(to: to, t: t1, control: control)
+
+            if a.x >= x {
+                return dist
+            } else if b.x > x {
+                dist += a.line(to: b, x: x)
+                return dist
+            } else if b.x == x {
+                dist += a.line(to: b)
+                return dist
+            }
+
+            dist += a.line(to: b)
+        }
+        return dist
+    }
+
+    func point(to: CGPoint, t: CGFloat, control: CGPoint) -> CGPoint {
+        let x = CGPoint.value(x: self.x, y: to.x, t: t, c: control.x)
+        let y = CGPoint.value(x: self.y, y: to.y, t: t, c: control.y)
+
+        return CGPoint(x: x, y: y)
+    }
+
+    func curve(to: CGPoint, control1: CGPoint, control2: CGPoint) -> CGFloat {
+        var dist: CGFloat = 0
+        let steps: CGFloat = 100
+
+        for i in 0..<Int(steps) {
+            let t0 = CGFloat(i) / steps
+            let t1 = CGFloat(i+1) / steps
+
+            let a = point(to: to, t: t0, control1: control1, control2: control2)
+            let b = point(to: to, t: t1, control1: control1, control2: control2)
+
+            dist += a.line(to: b)
+        }
+
+        return dist
+    }
+
+    func curve(to: CGPoint, control1: CGPoint, control2: CGPoint, x: CGFloat) -> CGFloat {
+        var dist: CGFloat = 0
+        let steps: CGFloat = 100
+
+        for i in 0..<Int(steps) {
+            let t0 = CGFloat(i) / steps
+            let t1 = CGFloat(i+1) / steps
+
+            let a = point(to: to, t: t0, control1: control1, control2: control2)
+            let b = point(to: to, t: t1, control1: control1, control2: control2)
+
+            if a.x >= x {
+                return dist
+            } else if b.x > x {
+                dist += a.line(to: b, x: x)
+                return dist
+            } else if b.x == x {
+                dist += a.line(to: b)
+                return dist
+            }
+
+            dist += a.line(to: b)
+        }
+
+        return dist
+    }
+
+    func point(to: CGPoint, t: CGFloat, control1: CGPoint, control2: CGPoint) -> CGPoint {
+        let x = CGPoint.value(x: self.x, y: to.x, t: t, c1: control1.x, c2: control2.x)
+        let y = CGPoint.value(x: self.y, y: to.y, t: t, c1: control1.y, c2: control2.x)
+
+        return CGPoint(x: x, y: y)
+    }
+
+    static func value(x: CGFloat, y: CGFloat, t: CGFloat, c: CGFloat) -> CGFloat {
+        var value: CGFloat = 0.0
+        // (1-t)^2 * p0 + 2 * (1-t) * t * c1 + t^2 * p1
+        value += pow(1-t, 2) * x
+        value += 2 * (1-t) * t * c
+        value += pow(t, 2) * y
+        return value
+    }
+
+    static func value(x: CGFloat, y: CGFloat, t: CGFloat, c1: CGFloat, c2: CGFloat) -> CGFloat {
+        var value: CGFloat = 0.0
+        // (1-t)^3 * p0 + 3 * (1-t)^2 * t * c1 + 3 * (1-t) * t^2 * c2 + t^3 * p1
+        value += pow(1-t, 3) * x
+        value += 3 * pow(1-t, 2) * t * c1
+        value += 3 * (1-t) * pow(t, 2) * c2
+        value += pow(t, 3) * y
+        return value
+    }
+}
+

Sources/SwiftUICharts/PieChart/PieChartCell.swift

@@ -12,7 +12,7 @@ struct PieSlice: Identifiable {
     var id = UUID()
     var startDeg: Double
     var endDeg: Double
-    var value: Int
+    var value: Double
     var normalizedValue: Double
 }
 

Sources/SwiftUICharts/PieChart/PieChartRow.swift

@@ -9,7 +9,7 @@
 import SwiftUI
 
 public struct PieChartRow : View {
-    var data: [Int]
+    var data: [Double]
     var backgroundColor: Color
     var accentColor: Color
     var slices: [PieSlice] {

Sources/SwiftUICharts/PieChart/PieChartView.swift

@@ -9,15 +9,20 @@
 import SwiftUI
 
 public struct PieChartView : View {
-    public var data: [Int]
+    public var data: [Double]
     public var title: String
     public var legend: String?
     public var style: ChartStyle
-    public init(data: [Int], title: String, legend: String? = nil, style: ChartStyle = Styles.pieChartStyleOne ){
+    public var formSize:CGSize
+    public var dropShadow: Bool
+
+    public init(data: [Double], title: String, legend: String? = nil, style: ChartStyle = Styles.pieChartStyleOne, form: CGSize? = ChartForm.medium, dropShadow: Bool? = true ){
         self.data = data
         self.title = title
         self.legend = legend
         self.style = style
+        self.formSize = form!
+        self.dropShadow = dropShadow!
     }
     
     public var body: some View {
@@ -25,7 +30,7 @@ public struct PieChartView : View {
             Rectangle()
                 .fill(self.style.backgroundColor)
                 .cornerRadius(20)
-                .shadow(color: Color.gray, radius: 12)
+                .shadow(color: Color.gray, radius: self.dropShadow ? 12 : 0)
             VStack(alignment: .leading){
                 HStack{
                     Text(self.title)
@@ -46,7 +51,7 @@ public struct PieChartView : View {
                 }
                 
             }
-        }.frame(width: self.style.chartFormSize.width, height: self.style.chartFormSize.height)
+        }.frame(width: self.formSize.width, height: self.formSize.height)
     }
 }