@rentlydev/rently-tuya 0.1.0

package/ios/components/Alert.swift

@@ -0,0 +1,54 @@
+import Foundation
+import SwiftUI
+
+func getAlert(
+    title: String,
+    message: String,
+    primaryButtonTitle: String,
+    withCancelButton: Bool = false,
+    secondaryButtonTitle: String,
+    primaryAction: @escaping () -> Void,
+    secondaryAction: @escaping () -> Void = {}
+) -> Alert {
+    
+    updateAlertBackgroundColor()
+
+    return Alert(
+        title: Text(title),
+        message: Text(message),
+        primaryButton: withCancelButton
+            ? .default(Text(secondaryButtonTitle))
+            : .default(Text(secondaryButtonTitle), action: {
+                HeapAnalytics.trackEvent(eventName: "\(title)_\(secondaryButtonTitle)")
+                secondaryAction()
+            }),
+        secondaryButton: .default(Text(primaryButtonTitle), action: {
+            HeapAnalytics.trackEvent(eventName: "\(title)_\(primaryButtonTitle)")
+            primaryAction()
+        })
+    )
+}
+
+func getSuccessAlert(title: String) -> Alert {
+  
+  updateAlertBackgroundColor()
+  
+    return Alert(
+        title: Text("Success"),
+        message: Text(title),
+        dismissButton: .default(Text("OK"))
+    )
+}
+
+func getFailureAlert(title: String) -> Alert {
+  
+  updateAlertBackgroundColor()
+
+    return Alert(
+        title: Text("Failed"),
+        message: Text(title),
+        dismissButton: .default(Text("OK"))
+    )
+}
+
+

package/ios/components/AnchorButton.swift

@@ -0,0 +1,100 @@
+import SwiftUI
+
+struct AnchorButton: View {
+    var id: String
+    var title: String
+
+    // Font Size
+    var xs: Bool = false
+    var s: Bool = false
+    var m: Bool = false
+    var l: Bool = false
+    var xl18: Bool = false
+    var xl20: Bool = false
+    var xl22: Bool = false
+    var xl24: Bool = false
+    var xl28: Bool = false
+    
+    // Text Color
+    var primary: Bool = false
+    var secondary: Bool = false
+    var black: Bool = false
+
+    // Font Weight
+    var light: Bool = false
+    var medium: Bool = false
+    var semiBold: Bool = false
+    var bold: Bool = false
+
+    // Text Alignment
+    var left: Bool = false
+    var right: Bool = false
+    var center: Bool = true
+
+    var underLine: Bool = false
+    var strikeThrough: Bool = false
+    var disabled: Bool = false
+    var onClick: () -> Void = {}
+
+    var body: some View {
+        Button(action: {
+            if !disabled {
+                HeapAnalytics.trackEvent(eventName: id)
+                onClick()
+            }
+        }) {
+            Text(title)
+                .font(getFont())
+                .foregroundColor(getColor())
+                .underline(underLine, color: getColor())
+                .strikethrough(strikeThrough, color: getColor())
+                .frame(maxWidth: .infinity, alignment: getAlignment())
+        }
+        .disabled(disabled)
+        .accessibility(identifier: id)
+    }
+
+    private func getColor() -> Color {
+        if primary { return LocalColor.Primary.light }
+        if secondary { return LocalColor.Main.dark }
+        if black { return LocalColor.Monochrome.black }
+        return LocalColor.Primary.light
+    }
+
+    private func getFont() -> Font {
+        var fontName: String
+        switch (light, medium, semiBold, bold) {
+        case (true, _, _, _):
+            fontName = LocalFont.FontFamily.light
+        case (_, true, _, _):
+            fontName = LocalFont.FontFamily.medium
+        case (_, _, true, _):
+            fontName = LocalFont.FontFamily.semiBold
+        case (_, _, _, true):
+            fontName = LocalFont.FontFamily.bold
+        default:
+            fontName = LocalFont.FontFamily.medium
+        }
+
+        let fontSize: CGFloat
+        if xs { fontSize = LocalFont.FontSize.XS }
+        else if s { fontSize = LocalFont.FontSize.S }
+        else if m { fontSize = LocalFont.FontSize.M }
+        else if l { fontSize = LocalFont.FontSize.L }
+        else if xl18 { fontSize = LocalFont.FontSize.XL18 }
+        else if xl20 { fontSize = LocalFont.FontSize.XL20 }
+        else if xl22 { fontSize = LocalFont.FontSize.XL22 }
+        else if xl24 { fontSize = LocalFont.FontSize.XL24 }
+        else if xl28 { fontSize = LocalFont.FontSize.XL28 }
+        else { fontSize = LocalFont.FontSize.XL18 }
+
+        return Font.custom(fontName, size: fontSize)
+    }
+
+    private func getAlignment() -> Alignment {
+        if left { return .leading }
+        if right { return .trailing }
+        if center { return .center }
+        return .center // Default to center
+    }
+}

package/ios/components/Button.swift

@@ -0,0 +1,118 @@
+import SwiftUI
+
+struct CustomButton: View {
+    var id: String
+    var title: String
+    
+    // Font Size
+    var xs: Bool = false
+    var s: Bool = false
+    var m: Bool = false
+    var l: Bool = false
+    var xl18: Bool = false
+    var xl20: Bool = false
+    var xl22: Bool = false
+    var xl24: Bool = false
+    
+    // Button Color
+    var primary: Bool = false
+    var secondary: Bool = false
+    var tertiary: Bool = false
+    var black: Bool = false
+    
+    // Text/Border Color
+    var textColor: Color = .black
+    var borderColor: Color? = nil
+    
+    // Font Weight
+    var light: Bool = false
+    var medium: Bool = false
+    var semiBold: Bool = false
+    var bold: Bool = false
+    
+    var cornerRadius: CGFloat = 30
+    var disabled: Bool = false
+    var elevation: Bool = false
+    // Icon
+    var icon: Image? = nil
+
+    var onClick: () -> Void = {}
+    
+    var buttonColor: Color {
+        if primary {
+            return LocalColor.Primary.medium
+        } else if secondary {
+            return Color(red: 0.953, green: 0.467, blue: 0.529)
+        } else if tertiary {
+            return LocalColor.Monochrome.regular
+        } else if black {
+            return LocalColor.Monochrome.black
+        } else {
+            return LocalColor.Primary.light
+        }
+    }
+
+    var body: some View {
+        
+        let font: Font = {
+            var fontName: String
+            switch (light, medium, semiBold, bold) {
+            case (true, _, _, _):
+                fontName = LocalFont.FontFamily.light
+            case (_, true, _, _):
+                fontName = LocalFont.FontFamily.medium
+            case (_, _, true, _):
+                fontName = LocalFont.FontFamily.semiBold
+            case (_, _, _, true):
+                fontName = LocalFont.FontFamily.bold
+            default:
+                fontName = LocalFont.FontFamily.medium
+            }
+            
+            let fontSize: CGFloat
+            if xs { fontSize = LocalFont.FontSize.XS }
+            else if s { fontSize = LocalFont.FontSize.S }
+            else if m { fontSize = LocalFont.FontSize.M }
+            else if l { fontSize = LocalFont.FontSize.L }
+            else if xl18 { fontSize = LocalFont.FontSize.XL18 }
+            else if xl20 { fontSize = LocalFont.FontSize.XL20 }
+            else if xl22 { fontSize = LocalFont.FontSize.XL22 }
+            else if xl24 { fontSize = LocalFont.FontSize.XL24 }
+            else { fontSize = LocalFont.FontSize.M }
+            
+            return Font.custom(fontName, size: fontSize)
+        }()
+        
+            HStack() {
+                if let icon = icon {
+                    icon
+                        .resizable()
+                        .aspectRatio(contentMode: .fit)
+                        .frame(width: 24, height: 24)
+                }
+                
+                Text(title)
+                    .font(font)
+                    .foregroundColor(textColor)
+                    .frame(maxWidth: .infinity)
+            }
+            .padding()
+            .background(buttonColor)
+            .opacity(disabled ? 0.5 : 1)
+            .cornerRadius(cornerRadius)
+            .overlay(
+                RoundedRectangle(cornerRadius: cornerRadius)
+                    .stroke(borderColor ?? Color.clear, lineWidth: borderColor != nil ? 1 : 0)
+            )
+            .shadow(color: elevation ? .gray.opacity(0.5) : .clear, radius: elevation ? 5 : 0)
+            .onTapGesture {
+                if !disabled {
+                    HeapAnalytics.trackEvent(eventName: id)
+                    onClick()
+                }
+            }
+            .disabled(disabled)
+            .accessibility(identifier: "\(id)Button")
+    }
+}
+

package/ios/components/CustomDatePicker.swift

@@ -0,0 +1,275 @@
+import SwiftUI
+
+struct CustomDatePicker: View {
+    
+    @Binding var isVisible: Bool
+    @Binding var selectedDate: Date
+    var availableDays: [Int]
+    var minDate: Date? = nil
+    var onDateSelected: (Date) -> Void
+    var onMonthChanged: (Date) -> Void
+    var onCancel: () -> Void
+    var onOk: () -> Void
+    var onAppear: () -> Void
+    
+    @State private var tempDate: Date = Date()
+    @State private var displayedDate: Date = Date()
+    
+    @ObservedObject var tuya = Tuya.shared
+
+    var body: some View {
+        if isVisible {
+            ZStack {
+                LocalColor.Monochrome.black.opacity(0.5)
+                    .edgesIgnoringSafeArea(.all)
+                    .onTapGesture {
+                        isVisible = false
+                    }
+
+                VStack(spacing: 0) {
+                    HStack {
+                        VStack {
+                            Label(
+                                title: "Select a Date",
+                                l: true,
+                                white: true,
+                                left: true
+                            )
+                            .frame(maxWidth: .infinity, alignment: .leading)
+                            .padding(.top)
+                            
+                            Label(
+                                title: formatDate(date: tempDate),
+                                xl26: true,
+                                white: true,
+                                left: true
+                            )
+                            .frame(maxWidth: .infinity, alignment: .leading)
+                            .padding(.vertical, 6)
+                        }
+                        .padding(.horizontal, 12)
+                        
+                        Spacer()
+                    }
+                    .frame(maxWidth: .infinity)
+                    .background(LocalColor.Main.dark)
+
+                    HStack {
+                        Button(action: {
+                            displayedDate = previousMonth(from: displayedDate)
+                            onMonthChanged(displayedDate)
+                        }) {
+                            Image(systemName: "chevron.left")
+                                .padding()
+                                .foregroundColor(LocalColor.Main.dark)
+                        }
+                        .disabled(tuya.datePickerLoader)
+
+                        Spacer()
+                        
+                        Label(
+                            title: formatMonthYear(date: displayedDate),
+                            xl18: true,
+                            black: true,
+                            bold: true
+                        )
+
+                        Spacer()
+
+                        Button(action: {
+                            displayedDate = nextMonth(from: displayedDate)
+                            onMonthChanged(displayedDate)
+                        }) {
+                            Image(systemName: "chevron.right")
+                                .padding()
+                                .foregroundColor(LocalColor.Main.dark)
+                        }
+                        .disabled(tuya.datePickerLoader)
+                    }
+                    .padding()
+                    .background(LocalColor.Monochrome.white)
+
+                    if tuya.datePickerLoader {
+                        VStack {
+                            Spacer()
+                            ProgressView()
+                                .progressViewStyle(CircularProgressViewStyle(tint: LocalColor.Monochrome.black))
+                            Spacer()
+                        }
+                        .frame(maxWidth: .infinity)
+                        .frame(height: 240)
+                    } else {
+                        CalendarView(
+                            displayedDate: displayedDate,
+                            selectedDate: $tempDate,
+                            availableDays: availableDays,
+                            minDate: minDate,
+                            onDateSelected: { date in
+                                tempDate = date
+                                onDateSelected(date)
+                            }
+                        )
+                        .frame(height: 240)
+                    }
+
+                    HStack {
+                        AnchorButton(
+                            id: "DatePicker_Cancel",
+                            title: "Cancel",
+                            l: true,
+                            secondary: true,
+                            center: true
+                        ) {
+                            onCancel()
+                        }
+                        
+                        AnchorButton(
+                            id: "DatePicker_OK",
+                            title: "OK",
+                            l: true,
+                            secondary: true,
+                            center: true
+                        ) {
+                            selectedDate = tempDate
+                            onOk()
+                        }
+                    }
+                    .padding()
+                    .padding(.vertical, 6)
+                }
+                .frame(maxWidth: 320)
+                .background(LocalColor.Monochrome.white)
+                .cornerRadius(12)
+                .shadow(radius: 5)
+                .padding(.horizontal, 24)
+            }
+            .onAppear {
+                tempDate = selectedDate
+                displayedDate = selectedDate
+                onAppear()
+            }
+        }
+    }
+
+    private func formatDate(date: Date) -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "MMM dd yyyy"
+        return formatter.string(from: date)
+    }
+
+    private func formatMonthYear(date: Date) -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "MMMM yyyy"
+        return formatter.string(from: date)
+    }
+
+    private func previousMonth(from date: Date) -> Date {
+        return Calendar.current.date(byAdding: .month, value: -1, to: date)!
+    }
+
+    private func nextMonth(from date: Date) -> Date {
+        return Calendar.current.date(byAdding: .month, value: 1, to: date)!
+    }
+}
+
+struct CalendarView: View {
+    let displayedDate: Date
+    @Binding var selectedDate: Date
+    let availableDays: [Int]
+    let minDate: Date?
+    var onDateSelected: (Date) -> Void
+
+    private let daysInWeek = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
+
+    var body: some View {
+        VStack(spacing: 5) {
+            HStack {
+                ForEach(daysInWeek, id: \.self) { day in
+                    Label(
+                        title: day,
+                        s: true,
+                        lightGrey: true
+                    )
+                    .frame(maxWidth: .infinity)
+                }
+            }
+
+            let calendarDays = generateCalendarDays()
+            LazyVGrid(columns: Array(repeating: GridItem(.flexible()), count: 7), spacing: 10) {
+                ForEach(calendarDays.indices, id: \.self) { index in
+                    if let day = calendarDays[index] {
+                        let isAvailable = isDayAvailable(day)
+                        let isSelected = isSelectedDate(day)
+
+                        Text("\(day)")
+                            .font(.footnote)
+                            .frame(width: 30, height: 30)
+                            .background(isSelected ? LocalColor.Main.dark : LocalColor.Monochrome.transparent)
+                            .foregroundColor(isSelected ? LocalColor.Monochrome.white : (isAvailable ? LocalColor.Monochrome.black : LocalColor.Monochrome.regular))
+                            .overlay(
+                                Circle()
+                                    .stroke(isAvailable ? LocalColor.Main.dark : LocalColor.Monochrome.transparent, lineWidth: 1)
+                            )
+                            .clipShape(Circle())
+                            .onTapGesture {
+                                if isAvailable {
+                                    selectDate(day)
+                                }
+                            }
+                    } else {
+                        Spacer()
+                    }
+                }
+            }
+        }
+        .padding()
+    }
+
+    private func generateCalendarDays() -> [Int?] {
+        let calendar = Calendar.current
+        let components = calendar.dateComponents([.year, .month], from: displayedDate)
+        guard let firstDayOfMonth = calendar.date(from: components) else { return [] }
+
+        let range = calendar.range(of: .day, in: .month, for: firstDayOfMonth)!
+        let firstWeekday = calendar.component(.weekday, from: firstDayOfMonth) - 1
+
+        var days: [Int?] = Array(repeating: nil, count: firstWeekday)
+        days.append(contentsOf: range.map { $0 })
+        return days
+    }
+
+    private func isDayAvailable(_ day: Int) -> Bool {
+        let calendar = Calendar.current
+        let components = DateComponents(year: calendar.component(.year, from: displayedDate),
+                                        month: calendar.component(.month, from: displayedDate),
+                                        day: day)
+        let date = calendar.date(from: components)!
+        if let minDate = minDate {
+            return availableDays.contains(day) && date >= minDate
+        }
+        return availableDays.contains(day)
+    }
+
+    private func isSelectedDate(_ day: Int) -> Bool {
+        let calendar = Calendar.current
+        let selectedDay = calendar.component(.day, from: selectedDate)
+        let selectedMonth = calendar.component(.month, from: selectedDate)
+        let selectedYear = calendar.component(.year, from: selectedDate)
+
+        let displayedMonth = calendar.component(.month, from: displayedDate)
+        let displayedYear = calendar.component(.year, from: displayedDate)
+
+        return day == selectedDay && selectedMonth == displayedMonth && selectedYear == displayedYear
+    }
+
+    private func selectDate(_ day: Int) {
+        let calendar = Calendar.current
+        var components = calendar.dateComponents([.year, .month], from: displayedDate)
+        components.day = day
+        if let date = calendar.date(from: components) {
+            selectedDate = date
+            onDateSelected(date)
+        }
+    }
+}
+

package/ios/components/Divider.swift

@@ -0,0 +1,28 @@
+import SwiftUI
+
+enum DividerDirection {
+    case horizontal
+    case vertical
+}
+
+struct Divider: View {
+    var thickness: CGFloat = 1
+    var direction: DividerDirection = .horizontal
+    var primary: Bool = false
+
+    var body: some View {
+        let color = primary ? LocalColor.Secondary.light : LocalColor.Secondary.light
+        
+        Group {
+            if direction == .vertical {
+                Rectangle()
+                    .fill(color)
+                    .frame(width: thickness)
+            } else {
+                Rectangle()
+                    .fill(color)
+                    .frame(height: thickness)
+            }
+        }
+    }
+}

package/ios/components/Image.swift

@@ -0,0 +1,72 @@
+import SwiftUI
+import Combine
+
+func Image(
+    imageName: String,
+    useTemplateRendering: Bool = false
+) -> Image {
+
+    guard let bundlePath = Bundle.main.path(forResource: "Resources", ofType: "bundle"),
+          let resourcesBundle = Bundle(path: bundlePath) else {
+        print("Tuya: Failed to locate Resources.bundle")
+        return Image(systemName: "questionmark.circle")
+            .renderingMode(useTemplateRendering ? .template : .original)
+    }
+
+    guard let uiImage = UIImage(named: imageName, in: resourcesBundle, compatibleWith: nil) else {
+        print("Tuya: Failed to load image: \(imageName) from Resources.bundle")
+        return Image(systemName: "questionmark.circle")
+            .renderingMode(useTemplateRendering ? .template : .original)
+    }
+
+    return Image(uiImage: uiImage)
+        .renderingMode(useTemplateRendering ? .template : .original)
+}
+
+class ImageLoader: ObservableObject {
+    @Published var image: Image?
+
+    private var cancellable: AnyCancellable?
+
+    func load(from url: URL) {
+        cancellable = URLSession.shared.dataTaskPublisher(for: url)
+            .map { data, response -> UIImage? in
+                return UIImage(data: data)
+            }
+            .map { uiImage in
+                if let uiImage = uiImage {
+                    return Image(uiImage: uiImage)
+                } else {
+                    return nil
+                }
+            }
+            .replaceError(with: nil)
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] in self?.image = $0 }
+    }
+
+    func cancel() {
+        cancellable?.cancel()
+    }
+}
+
+struct WebImage: View {
+    @ObservedObject private var loader = ImageLoader()
+    let url: URL
+    let placeholderImageName: String
+
+    var body: some View {
+        if let image = loader.image {
+            image
+                .resizable()
+                .scaledToFit()
+        } else {
+            Image(imageName: placeholderImageName)
+                .resizable()
+                .scaledToFit()
+                .onAppear {
+                    loader.load(from: url)
+                }
+        }
+    }
+}