@use-voltra/ios-client 1.4.1 → 2.0.0-rc.1

package/ios/ui/Generated/Parameters/SymbolParameters.swift

@@ -0,0 +1,59 @@
+//
+//  SymbolParameters.swift
+
+//  AUTO-GENERATED from data/components.json
+//  DO NOT EDIT MANUALLY - Changes will be overwritten
+//  Schema version: 1.0.0
+
+import Foundation
+
+/// Parameters for Symbol component
+/// Display SF Symbols with advanced configuration
+public struct SymbolParameters: ComponentParameters {
+  /// SF Symbol name
+  public let name: String?
+
+  /// Symbol rendering type
+  public let type: String?
+
+  /// Symbol scale
+  public let scale: String?
+
+  /// Symbol weight
+  public let weight: String?
+
+  /// Symbol size in points
+  public let size: Double
+
+  /// Tint color for the symbol
+  public let tintColor: String?
+
+  /// Pipe-separated colors for palette type
+  public let colors: String?
+
+  /// Image resize mode
+  public let resizeMode: String?
+
+  enum CodingKeys: String, CodingKey {
+    case name
+    case type
+    case scale
+    case weight
+    case size
+    case tintColor
+    case colors
+    case resizeMode
+  }
+
+  public init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    name = try container.decodeIfPresent(String.self, forKey: .name)
+    type = try container.decodeIfPresent(String.self, forKey: .type)
+    scale = try container.decodeIfPresent(String.self, forKey: .scale)
+    weight = try container.decodeIfPresent(String.self, forKey: .weight)
+    size = try container.decodeIfPresent(Double.self, forKey: .size) ?? 24
+    tintColor = try container.decodeIfPresent(String.self, forKey: .tintColor)
+    colors = try container.decodeIfPresent(String.self, forKey: .colors)
+    resizeMode = try container.decodeIfPresent(String.self, forKey: .resizeMode)
+  }
+}

package/ios/ui/Generated/Parameters/TextParameters.swift

@@ -0,0 +1,18 @@
+//
+//  TextParameters.swift
+
+//  AUTO-GENERATED from data/components.json
+//  DO NOT EDIT MANUALLY - Changes will be overwritten
+//  Schema version: 1.0.0
+
+import Foundation
+
+/// Parameters for Text component
+/// Display text content
+public struct TextParameters: ComponentParameters {
+  /// Maximum number of lines to display
+  public let numberOfLines: Double?
+
+  /// Text alignment for multiline text
+  public let multilineTextAlignment: String?
+}

package/ios/ui/Generated/Parameters/TimerParameters.swift

@@ -0,0 +1,54 @@
+//
+//  TimerParameters.swift
+
+//  AUTO-GENERATED from data/components.json
+//  DO NOT EDIT MANUALLY - Changes will be overwritten
+//  Schema version: 1.0.0
+
+import Foundation
+
+/// Parameters for Timer component
+/// Text-based countdown/stopwatch timer component
+public struct TimerParameters: ComponentParameters {
+  /// End time in milliseconds since epoch
+  public let endAtMs: Double?
+
+  /// Start time in milliseconds since epoch
+  public let startAtMs: Double?
+
+  /// Duration in milliseconds
+  public let durationMs: Double?
+
+  /// Count direction
+  public let direction: String
+
+  /// Text formatting style
+  public let textStyle: String
+
+  /// JSON-encoded TextTemplates object with running/completed templates
+  public let textTemplates: String?
+
+  /// Whether to show hours component when duration exceeds 60 minutes. If false, minutes will exceed 60 (e.g., 94:00 instead of 1:34:00)
+  public let showHours: Bool
+
+  enum CodingKeys: String, CodingKey {
+    case endAtMs
+    case startAtMs
+    case durationMs
+    case direction
+    case textStyle
+    case textTemplates
+    case showHours
+  }
+
+  public init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    endAtMs = try container.decodeIfPresent(Double.self, forKey: .endAtMs)
+    startAtMs = try container.decodeIfPresent(Double.self, forKey: .startAtMs)
+    durationMs = try container.decodeIfPresent(Double.self, forKey: .durationMs)
+    direction = try container.decodeIfPresent(String.self, forKey: .direction) ?? "down"
+    textStyle = try container.decodeIfPresent(String.self, forKey: .textStyle) ?? "timer"
+    textTemplates = try container.decodeIfPresent(String.self, forKey: .textTemplates)
+    showHours = try container.decodeIfPresent(Bool.self, forKey: .showHours) ?? false
+  }
+}

package/ios/ui/Generated/Parameters/ToggleParameters.swift

@@ -0,0 +1,24 @@
+//
+//  ToggleParameters.swift
+
+//  AUTO-GENERATED from data/components.json
+//  DO NOT EDIT MANUALLY - Changes will be overwritten
+//  Schema version: 1.0.0
+
+import Foundation
+
+/// Parameters for Toggle component
+/// Toggle switch control
+public struct ToggleParameters: ComponentParameters {
+  /// Initial toggle state
+  public let defaultValue: Bool
+
+  enum CodingKeys: String, CodingKey {
+    case defaultValue
+  }
+
+  public init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    defaultValue = try container.decodeIfPresent(Bool.self, forKey: .defaultValue) ?? false
+  }
+}

package/ios/ui/Generated/Parameters/VStackParameters.swift

@@ -0,0 +1,34 @@
+//
+//  VStackParameters.swift
+
+//  AUTO-GENERATED from data/components.json
+//  DO NOT EDIT MANUALLY - Changes will be overwritten
+//  Schema version: 1.0.0
+
+import Foundation
+
+/// Parameters for VStack component
+/// Vertical stack container
+public struct VStackParameters: ComponentParameters {
+  /// Horizontal alignment
+  public let alignment: String
+
+  /// Layout mode. 'stack' uses native SwiftUI stacks. 'flex' uses RN-like flexbox.
+  public let layout: String
+
+  /// Spacing between children. Takes precedence over gap style property.
+  public let spacing: Double?
+
+  enum CodingKeys: String, CodingKey {
+    case alignment
+    case layout
+    case spacing
+  }
+
+  public init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    alignment = try container.decodeIfPresent(String.self, forKey: .alignment) ?? "center"
+    layout = try container.decodeIfPresent(String.self, forKey: .layout) ?? "stack"
+    spacing = try container.decodeIfPresent(Double.self, forKey: .spacing)
+  }
+}

package/ios/ui/Generated/Parameters/ViewParameters.swift

@@ -0,0 +1,12 @@
+//
+//  ViewParameters.swift
+
+//  AUTO-GENERATED from data/components.json
+//  DO NOT EDIT MANUALLY - Changes will be overwritten
+//  Schema version: 1.0.0
+
+import Foundation
+
+/// Parameters for View component
+/// Flex container with configurable direction. Always uses flexbox layout.
+public struct ViewParameters: ComponentParameters {}

package/ios/ui/Generated/Parameters/ZStackParameters.swift

@@ -0,0 +1,15 @@
+//
+//  ZStackParameters.swift
+
+//  AUTO-GENERATED from data/components.json
+//  DO NOT EDIT MANUALLY - Changes will be overwritten
+//  Schema version: 1.0.0
+
+import Foundation
+
+/// Parameters for ZStack component
+/// Depth-based stack container
+public struct ZStackParameters: ComponentParameters {
+  /// Child alignment
+  public let alignment: String?
+}

package/ios/ui/Helpers/VoltraDeepLinkResolver.swift

@@ -0,0 +1,43 @@
+import ActivityKit
+import Foundation
+import SwiftUI
+
+enum VoltraDeepLinkResolver {
+  static func deepLinkScheme() -> String? {
+    if let types = Bundle.main.object(forInfoDictionaryKey: "CFBundleURLTypes") as? [[String: Any]] {
+      for t in types {
+        if let schemes = t["CFBundleURLSchemes"] as? [String], let s = schemes.first, !s.isEmpty {
+          return s
+        }
+      }
+    }
+    return Bundle.main.bundleIdentifier
+  }
+
+  static func resolve(
+    _ attributes: VoltraAttributes
+  ) -> URL? {
+    if let raw = attributes.deepLinkUrl, !raw.isEmpty {
+      return resolveUrl(raw)
+    }
+    return nil
+  }
+
+  /// Resolves a URL string, supporting both absolute and relative paths
+  /// - Parameter raw: The URL string (e.g., "myapp://path", "/path", or "path")
+  /// - Returns: A resolved URL, or nil if invalid
+  static func resolveUrl(_ raw: String) -> URL? {
+    guard !raw.isEmpty else { return nil }
+
+    // If it's already an absolute URL, use it as-is
+    if raw.contains("://"), let url = URL(string: raw) { return url }
+
+    // Otherwise, prepend the app's URL scheme
+    if let scheme = deepLinkScheme() {
+      let path = raw.hasPrefix("/") ? raw : "/\(raw)"
+      return URL(string: "\(scheme)://\(path.trimmingCharacters(in: CharacterSet(charactersIn: "/")))")
+    }
+
+    return nil
+  }
+}

package/ios/ui/Helpers/VoltraProgressDriver.swift

@@ -0,0 +1,52 @@
+//
+//  VoltraProgressDriver.swift
+//  Voltra
+//
+//  Centralised helpers for time-driven progress behaviour shared by Timer,
+//  ProgressView, and Gauge implementations.
+//
+
+import Foundation
+
+enum VoltraProgressDriver {
+  /// Resolve a time range from the common millisecond-based parameters.
+  ///
+  /// - Parameters:
+  ///   - startAtMs: Epoch milliseconds when the animation should begin. Optional.
+  ///   - endAtMs: Epoch milliseconds when the animation should end. Optional but preferred.
+  ///   - durationMs: Duration in milliseconds. Used when `endAtMs` is omitted.
+  /// - Returns: A closed `Date` range representing the timeline, or `nil` if insufficient data was supplied.
+  static func resolveRange(startAtMs: Double?, endAtMs: Double?, durationMs: Double?) -> ClosedRange<Date>? {
+    if let endAtMs = endAtMs {
+      return Date.toTimerInterval(startAtMs: startAtMs, endAtMs: endAtMs)
+    }
+
+    if let durationMs = durationMs {
+      let now = Date()
+      let durationSeconds = max(0, durationMs / 1000)
+      let startDate: Date
+      if let startAtMs = startAtMs {
+        startDate = Date(timeIntervalSince1970: startAtMs / 1000)
+      } else {
+        startDate = now
+      }
+      let endDate = startDate.addingTimeInterval(durationSeconds)
+      let clampedEnd = max(endDate, now)
+      return startDate ... clampedEnd
+    }
+
+    return nil
+  }
+
+  /// Compute progress (0...1) for the supplied range at `date`.
+  ///
+  /// The progress value is clamped to `[0, 1]` unless `clamp` is `false`.
+  static func progress(for range: ClosedRange<Date>, at date: Date = Date(), clamp: Bool = true) -> Double {
+    let total = range.upperBound.timeIntervalSince(range.lowerBound)
+    if total <= 0 { return clamp ? 1 : 0 }
+    let elapsed = date.timeIntervalSince(range.lowerBound)
+    let ratio = elapsed / total
+    if !clamp { return ratio }
+    return min(max(ratio, 0), 1)
+  }
+}

package/ios/ui/Layout/FlexContainerHelper.swift

@@ -0,0 +1,114 @@
+import SwiftUI
+
+// MARK: - Shared Flex Container Rendering
+
+/// Shared values computed from a flex container's style
+struct FlexContainerValues {
+  let padding: EdgeInsets
+  let alignItems: FlexAlign
+  let justifyContent: FlexJustify
+  let gap: CGFloat
+  let layout: LayoutStyle
+  let decoration: DecorationStyle
+  let rendering: RenderingStyle
+}
+
+enum FlexContainerHelper {
+  /// Parse flex container values from an element's style dictionary.
+  /// `alignmentMapping` converts component-specific alignment strings (e.g. "leading", "top")
+  /// to FlexAlign values, used as fallback when alignItems isn't set in style.
+  static func parseValues(
+    from element: VoltraElement,
+    alignmentFallback: FlexAlign = .stretch
+  ) -> FlexContainerValues {
+    let anyStyle = element.style?.mapValues { $0.toAny() } ?? [:]
+    let (layout, decoration, rendering, _) = StyleConverter.convert(anyStyle)
+
+    let alignItemsFromStyle = (anyStyle["alignItems"] as? String).flatMap { FlexAlign(fromStyle: $0) }
+    let justifyContentFromStyle = (anyStyle["justifyContent"] as? String).flatMap { FlexJustify(fromStyle: $0) }
+
+    let finalAlignItems = alignItemsFromStyle ?? alignmentFallback
+    let justifyContent = justifyContentFromStyle ?? .flexStart
+    let gap = layout.gap ?? 0
+
+    return FlexContainerValues(
+      padding: layout.padding ?? EdgeInsets(),
+      alignItems: finalAlignItems,
+      justifyContent: justifyContent,
+      gap: gap,
+      layout: layout,
+      decoration: decoration,
+      rendering: rendering
+    )
+  }
+
+  /// Map a VStack alignment string to a FlexAlign fallback
+  static func verticalAlignmentFallback(_ alignment: String) -> FlexAlign {
+    switch alignment.lowercased() {
+    case "leading": return .flexStart
+    case "trailing": return .flexEnd
+    case "center": return .center
+    default: return .stretch
+    }
+  }
+
+  /// Map an HStack alignment string to a FlexAlign fallback
+  static func horizontalAlignmentFallback(_ alignment: String) -> FlexAlign {
+    switch alignment.lowercased() {
+    case "top": return .flexStart
+    case "bottom": return .flexEnd
+    case "center": return .center
+    default: return .stretch
+    }
+  }
+}
+
+// MARK: - Flex Container View Modifier
+
+/// Applies layout, decoration, rendering, margin, offset, positioning, and zIndex
+/// to a flex container — everything except padding (handled by the flex engine).
+/// Also sets FlexItemLayoutKey so this view can be a flex child of another container.
+struct FlexContainerStyleModifier: ViewModifier {
+  let values: FlexContainerValues
+
+  func body(content: Content) -> some View {
+    let layout = values.layout
+    let layoutWithoutPadding: LayoutStyle = {
+      var l = layout
+      l.padding = nil
+      return l
+    }()
+
+    content
+      .modifier(LayoutModifier(style: layoutWithoutPadding))
+      .modifier(DecorationModifier(style: values.decoration, layout: layout))
+      .modifier(RenderingModifier(style: values.rendering))
+      .voltraIfLet(layout.margin) { c, margin in
+        c.background(.clear).padding(margin)
+      }
+      .voltraIfLet(layout.relativeOffset) { c, offset in
+        c.offset(x: offset.x, y: offset.y)
+      }
+      .voltraIfLet(layout.absolutePosition) { c, position in
+        c.position(x: position.x, y: position.y)
+      }
+      .voltraIfLet(layout.zIndex) { c, z in
+        c.zIndex(z)
+      }
+      // Set FlexItemLayoutKey so this container can be a flex child of another container
+      .layoutValue(key: FlexItemLayoutKey.self, value: FlexItemValues(
+        flexGrow: layout.flexGrow,
+        flexShrink: layout.flexShrink,
+        flexBasis: layout.flexBasis,
+        width: layout.width,
+        height: layout.height,
+        minWidth: layout.minWidth,
+        maxWidth: layout.maxWidth,
+        minHeight: layout.minHeight,
+        maxHeight: layout.maxHeight,
+        alignSelf: layout.alignSelf,
+        margin: layout.margin,
+        aspectRatio: layout.aspectRatio
+      ))
+  }
+}