@use-voltra/ios-client 2.1.1 → 2.3.0

package/ios/ui/Style/JSColorParser.swift

@@ -8,7 +8,9 @@ enum JSColorParser {
     // Optimize: standard trim and lowercase
     let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
 
-    if trimmed.isEmpty { return nil }
+    if trimmed.isEmpty {
+      return nil
+    }
 
     // 1. Hex (with or without #)
     if trimmed.hasPrefix("#") {
@@ -57,7 +59,9 @@ enum JSColorParser {
     guard let string = value as? String else { return nil }
 
     let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
-    if trimmed.isEmpty { return nil }
+    if trimmed.isEmpty {
+      return nil
+    }
 
     if trimmed.hasPrefix("#") {
       return parseHexComponents(trimmed)
@@ -477,7 +481,9 @@ enum JSColorParser {
 
   private static func normalizeUnit(_ value: Double) -> Double {
     var result = value.truncatingRemainder(dividingBy: 1)
-    if result < 0 { result += 1 }
+    if result < 0 {
+      result += 1
+    }
     return result
   }
 
@@ -506,12 +512,22 @@ enum JSColorParser {
   /// Helper function for HSL to RGB conversion
   private static func hueToRgb(p: Double, q: Double, t: Double) -> Double {
     var t = t
-    if t < 0 { t += 1 }
-    if t > 1 { t -= 1 }
+    if t < 0 {
+      t += 1
+    }
+    if t > 1 {
+      t -= 1
+    }
 
-    if t < 1.0 / 6.0 { return p + (q - p) * 6 * t }
-    if t < 1.0 / 2.0 { return q }
-    if t < 2.0 / 3.0 { return p + (q - p) * (2.0 / 3.0 - t) * 6 }
+    if t < 1.0 / 6.0 {
+      return p + (q - p) * 6 * t
+    }
+    if t < 1.0 / 2.0 {
+      return q
+    }
+    if t < 2.0 / 3.0 {
+      return p + (q - p) * (2.0 / 3.0 - t) * 6
+    }
     return p
   }
 }

package/ios/ui/Style/JSGradientParser.swift

@@ -200,12 +200,16 @@ enum JSGradientParser {
         depth += 1
       } else if char == ")" {
         depth -= 1
-        if depth < 0 { return [] }
+        if depth < 0 {
+          return []
+        }
       }
 
       if char == ",", depth == 0 {
         let token = current.trimmingCharacters(in: .whitespacesAndNewlines)
-        if token.isEmpty { return [] }
+        if token.isEmpty {
+          return []
+        }
         args.append(token)
         current = ""
       } else {
@@ -216,7 +220,9 @@ enum JSGradientParser {
     guard depth == 0 else { return [] }
 
     let token = current.trimmingCharacters(in: .whitespacesAndNewlines)
-    if token.isEmpty { return [] }
+    if token.isEmpty {
+      return []
+    }
     args.append(token)
     return args
   }
@@ -231,7 +237,9 @@ enum JSGradientParser {
         depth += 1
       } else if char == ")" {
         depth -= 1
-        if depth < 0 { return [] }
+        if depth < 0 {
+          return []
+        }
       }
 
       if char.isWhitespace, depth == 0 {
@@ -269,10 +277,14 @@ enum JSGradientParser {
     for word in words {
       switch word {
       case "left", "right":
-        if horizontal != nil { return nil }
+        if horizontal != nil {
+          return nil
+        }
         horizontal = word
       case "top", "bottom":
-        if vertical != nil { return nil }
+        if vertical != nil {
+          return nil
+        }
         vertical = word
       default:
         return nil
@@ -418,10 +430,14 @@ enum JSGradientParser {
     for token in tokens {
       switch token {
       case "left":
-        if x != nil { return nil }
+        if x != nil {
+          return nil
+        }
         x = 0
       case "right":
-        if x != nil { return nil }
+        if x != nil {
+          return nil
+        }
         x = 1
       case "center":
         if x == nil {
@@ -432,10 +448,14 @@ enum JSGradientParser {
           return nil
         }
       case "top":
-        if y != nil { return nil }
+        if y != nil {
+          return nil
+        }
         y = 0
       case "bottom":
-        if y != nil { return nil }
+        if y != nil {
+          return nil
+        }
         y = 1
       default:
         return nil
@@ -613,8 +633,12 @@ enum JSGradientParser {
     guard !stops.isEmpty else { return [] }
 
     var positions = stops.map(\.position)
-    if positions.first == nil { positions[0] = 0 }
-    if positions.last == nil { positions[positions.count - 1] = 1 }
+    if positions.first == nil {
+      positions[0] = 0
+    }
+    if positions.last == nil {
+      positions[positions.count - 1] = 1
+    }
 
     var lastDefined: Double?
     for idx in positions.indices {

package/ios/ui/Style/JSStyleParser.swift

@@ -2,16 +2,24 @@ import SwiftUI
 
 enum JSStyleParser {
   static func number(_ value: Any?) -> CGFloat? {
-    if let v = value as? CGFloat { return v }
-    if let v = value as? Double { return CGFloat(v) }
-    if let v = value as? Int { return CGFloat(v) }
+    if let v = value as? CGFloat {
+      return v
+    }
+    if let v = value as? Double {
+      return CGFloat(v)
+    }
+    if let v = value as? Int {
+      return CGFloat(v)
+    }
     // Handle "20.5" strings if necessary, though rarer in raw JSON objects
     return nil
   }
 
   static func sizeValue(_ value: Any?) -> SizeValue? {
     // Numeric → Fixed
-    if let n = number(value) { return .fixed(n) }
+    if let n = number(value) {
+      return .fixed(n)
+    }
     // String → Fill / Wrap / try numeric
     guard let str = value as? String else { return nil }
     switch str {
@@ -19,7 +27,9 @@ enum JSStyleParser {
     case "auto": return .wrap
     default:
       // Try parsing as numeric string
-      if let n = Double(str) { return .fixed(CGFloat(n)) }
+      if let n = Double(str) {
+        return .fixed(CGFloat(n))
+      }
       return nil
     }
   }
@@ -50,8 +60,12 @@ enum JSStyleParser {
   static func boolean(_ value: Any?) -> Bool {
     guard let value = value else { return false }
 
-    if let bool = value as? Bool { return bool }
-    if let int = value as? Int { return int == 1 }
+    if let bool = value as? Bool {
+      return bool
+    }
+    if let int = value as? Int {
+      return int == 1
+    }
     if let string = value as? String {
       return string.lowercased() == "true"
     }
@@ -107,9 +121,15 @@ enum JSStyleParser {
     let hasUnderline = string.contains("underline")
     let hasLineThrough = string.contains("line-through") || string.contains("strikethrough")
 
-    if hasUnderline, hasLineThrough { return .underlineLineThrough }
-    if hasUnderline { return .underline }
-    if hasLineThrough { return .lineThrough }
+    if hasUnderline, hasLineThrough {
+      return .underlineLineThrough
+    }
+    if hasUnderline {
+      return .underline
+    }
+    if hasLineThrough {
+      return .lineThrough
+    }
     return .none
   }
 
@@ -128,8 +148,12 @@ enum JSStyleParser {
   static func overflow(_ value: Any?) -> Overflow? {
     guard let string = (value as? String)?.lowercased() else { return nil }
 
-    if string == "hidden" { return .hidden }
-    if string == "visible" { return .visible }
+    if string == "hidden" {
+      return .hidden
+    }
+    if string == "visible" {
+      return .visible
+    }
     return nil
   }
 

package/ios/ui/Style/LayoutStyle.swift

@@ -112,15 +112,23 @@ struct LayoutModifier: ViewModifier {
 
   /// Derive effective ideal width: explicit width, then flexBasis, then nil
   private var effectiveIdealWidth: CGFloat? {
-    if let w = widthValue { return w }
-    if case let .fixed(v) = style.flexBasis { return v }
+    if let w = widthValue {
+      return w
+    }
+    if case let .fixed(v) = style.flexBasis {
+      return v
+    }
     return nil
   }
 
   /// Derive effective ideal height: explicit height, then flexBasis, then nil
   private var effectiveIdealHeight: CGFloat? {
-    if let h = heightValue { return h }
-    if case let .fixed(v) = style.flexBasis { return v }
+    if let h = heightValue {
+      return h
+    }
+    if case let .fixed(v) = style.flexBasis {
+      return v
+    }
     return nil
   }
 

package/ios/ui/Views/VoltraChart.swift

@@ -49,7 +49,9 @@ public struct VoltraChart: VoltraView {
   }
 
   private func bool(_ v: JSONValue) -> Bool? {
-    if case let .bool(value) = v { return value }
+    if case let .bool(value) = v {
+      return value
+    }
     return nil
   }
 
@@ -60,16 +62,22 @@ public struct VoltraChart: VoltraView {
     else { return nil }
 
     let props = dict.compactMapValues { jsonValue(from: $0) }
-    if props.isEmpty { return nil }
+    if props.isEmpty {
+      return nil
+    }
 
     let visible = props["v"].flatMap(bool) ?? props["visible"].flatMap(bool)
     let color = (props["c"] ?? props["color"]).flatMap {
-      if case let .string(value) = $0 { return JSColorParser.parse(value) }
+      if case let .string(value) = $0 {
+        return JSColorParser.parse(value)
+      }
       return nil
     }
     let lineWidth = (props["lw"] ?? props["lineWidth"]).flatMap(num).map { CGFloat($0) }
     let dash = ((props["d"] ?? props["dash"]).flatMap {
-      if case let .array(values) = $0 { return values.compactMap(num).map { CGFloat($0) } }
+      if case let .array(values) = $0 {
+        return values.compactMap(num).map { CGFloat($0) }
+      }
       return nil
     })
 
@@ -140,7 +148,11 @@ public struct VoltraChart: VoltraView {
       default: return 0
       }
     }()
-    let series: String? = pt.count >= 3 ? { if case let .string(s) = pt[2] { return s }; return nil }() : nil
+    let series: String? = pt.count >= 3 ? {
+      if case let .string(s) = pt[2] {
+        return s
+      }; return nil
+    }() : nil
     switch pt[0] {
     case let .string(x): return (x, nil, y, series)
     case let .double(x): return (nil, x, y, series)
@@ -149,6 +161,103 @@ public struct VoltraChart: VoltraView {
     }
   }
 
+  // MARK: - Y scale
+
+  /// Y-axis bounds pinned by the `yScale` prop; either side may be left to the data.
+  private struct YScale {
+    let min: Double?
+    let max: Double?
+  }
+
+  private func parseYScale(from raw: String?) -> YScale? {
+    guard let raw,
+          let data = raw.data(using: .utf8),
+          let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+    else { return nil }
+
+    let props = dict.compactMapValues { jsonValue(from: $0) }
+    let min = (props["mn"] ?? props["min"]).flatMap(num)
+    let max = (props["mx"] ?? props["max"]).flatMap(num)
+    if min == nil, max == nil {
+      return nil
+    }
+    return YScale(min: min, max: max)
+  }
+
+  /// Domain to hand SwiftUI when `yScale` pins a bound. The open side follows the data exactly as
+  /// `computeYDomain` in Android's ChartBitmapRenderer.kt frames it, so both platforms agree.
+  private func yScaleDomain(_ marks: [WireMark], pinned: YScale) -> ClosedRange<Double> {
+    let auto = autoYDomain(marks)
+    var lower = pinned.min ?? auto.lowerBound
+    var upper = pinned.max ?? auto.upperBound
+
+    if upper <= lower {
+      // A pin that inverts the domain still has to leave something to draw in: keep the span the
+      // data asked for on the side the caller left open, and ignore a pair that cannot be drawn.
+      let span = auto.upperBound - auto.lowerBound
+      if pinned.max == nil {
+        upper = lower + span
+      } else if pinned.min == nil {
+        lower = upper - span
+      } else {
+        return auto
+      }
+      if upper <= lower {
+        upper = lower + 1
+      }
+    }
+
+    return lower ... upper
+  }
+
+  private func autoYDomain(_ marks: [WireMark]) -> ClosedRange<Double> {
+    var values = marks.flatMap { mark -> [Double] in
+      guard mark.type != "sector" else { return [] }
+      return (mark.data ?? []).map { xy($0).y }
+    }
+    values += marks.compactMap { $0.type == "rule" ? $0.props["yv"].flatMap(num) : nil }
+
+    let finite = values.filter(\.isFinite)
+    guard let dataMin = finite.min(), let dataMax = finite.max() else { return 0 ... 1 }
+
+    // Bars and areas measure their value against the baseline, so zero stays in range.
+    if marks.contains(where: { $0.type == "bar" || $0.type == "area" }) {
+      let lower = Swift.min(dataMin, 0)
+      let upper = Swift.max(dataMax, 0)
+      return upper > lower ? lower ... upper : lower ... (lower + 1)
+    }
+
+    guard dataMax > dataMin else {
+      let padding = dataMin == 0 ? 1 : abs(dataMin) * Self.yDomainPaddingRatio
+      return (dataMin - padding) ... (dataMax + padding)
+    }
+
+    let padding = (dataMax - dataMin) * Self.yDomainPaddingRatio
+    var lower = dataMin - padding
+    var upper = dataMax + padding
+
+    // Padding must not invent values on the other side of the baseline, and data that almost
+    // reaches zero keeps it in view.
+    if dataMin >= 0, lower < 0 {
+      lower = 0
+    }
+    if dataMax <= 0, upper > 0 {
+      upper = 0
+    }
+    let span = upper - lower
+    if lower > 0, lower < span * Self.zeroSnapRatio {
+      lower = 0
+    }
+    if upper < 0, -upper < span * Self.zeroSnapRatio {
+      upper = 0
+    }
+
+    return lower ... upper
+  }
+
+  private static let yDomainPaddingRatio = 0.1
+  private static let zeroSnapRatio = 0.25
+
   // MARK: - body
 
   public var body: some View {
@@ -159,10 +268,12 @@ public struct VoltraChart: VoltraView {
     let yAxisGridStyle = parseAxisGridStyle(from: params.yAxisGridStyle)
     let legendVis = visibility(params.legendVisibility)
     let legendItems = parseLegendItems(from: params.foregroundStyleScale)
+    let yDomain = parseYScale(from: params.yScale).map { yScaleDomain(wireMarks, pinned: $0) }
 
     Chart {
       buildAll(wireMarks)
     }
+    .applyChartYScale(domain: yDomain)
     .applyForegroundStyleScale(params.foregroundStyleScale)
     .applyChartStyle(
       element.style,
@@ -186,12 +297,24 @@ public struct VoltraChart: VoltraView {
 
   @ChartContentBuilder
   private func buildMark(_ m: WireMark) -> some ChartContent {
-    if m.type == "bar" { barContent(m) }
-    if m.type == "line" { lineContent(m) }
-    if m.type == "area" { areaContent(m) }
-    if m.type == "point" { pointContent(m) }
-    if m.type == "rule" { ruleContent(m) }
-    if #available(iOS 17.0, macOS 14.0, *), m.type == "sector" { sectorContent(m) }
+    if m.type == "bar" {
+      barContent(m)
+    }
+    if m.type == "line" {
+      lineContent(m)
+    }
+    if m.type == "area" {
+      areaContent(m)
+    }
+    if m.type == "point" {
+      pointContent(m)
+    }
+    if m.type == "rule" {
+      ruleContent(m)
+    }
+    if #available(iOS 17.0, macOS 14.0, *), m.type == "sector" {
+      sectorContent(m)
+    }
   }
 
   // MARK: Bar
@@ -208,10 +331,16 @@ public struct VoltraChart: VoltraView {
     let (xStr, xNum, y, series) = xy(pt)
     let cr: CGFloat? = props["cr"].flatMap(num).map { CGFloat($0) }
     let barWidth: MarkDimension = {
-      if let v = props["w"].flatMap(num) { return .fixed(CGFloat(v)) }
+      if let v = props["w"].flatMap(num) {
+        return .fixed(CGFloat(v))
+      }
       return .automatic
     }()
-    let grouped: Bool = { if case let .string(s)? = props["stk"] { return s == "grouped" }; return false }()
+    let grouped: Bool = {
+      if case let .string(s)? = props["stk"] {
+        return s == "grouped"
+      }; return false
+    }()
 
     if let x = xStr {
       if let series {
@@ -555,15 +684,21 @@ public struct VoltraChart: VoltraView {
        case let .string(category) = pt[1]
     {
       let inner: MarkDimension = {
-        if let v = props["ir"].flatMap(num) { return .ratio(CGFloat(v)) }
+        if let v = props["ir"].flatMap(num) {
+          return .ratio(CGFloat(v))
+        }
         return .automatic
       }()
       let outer: MarkDimension = {
-        if let v = props["or"].flatMap(num) { return .ratio(CGFloat(v)) }
+        if let v = props["or"].flatMap(num) {
+          return .ratio(CGFloat(v))
+        }
         return .automatic
       }()
       let inset: CGFloat = {
-        if let v = props["agin"].flatMap(num) { return CGFloat(v) }
+        if let v = props["agin"].flatMap(num) {
+          return CGFloat(v)
+        }
         return 0
       }()
 
@@ -698,6 +833,15 @@ private extension View {
     }
   }
 
+  @ViewBuilder
+  func applyChartYScale(domain: ClosedRange<Double>?) -> some View {
+    if let domain {
+      chartYScale(domain: domain)
+    } else {
+      self
+    }
+  }
+
   @ViewBuilder
   func applyChartClipping(decoration: DecorationStyle, hasClipping: Bool) -> some View {
     if hasClipping {

package/ios/ui/Views/VoltraLinearGradient.swift

@@ -57,12 +57,16 @@ public struct VoltraLinearGradient: VoltraView {
           }
         }
       }
-      if !stops.isEmpty { return Gradient(stops: stops) }
+      if !stops.isEmpty {
+        return Gradient(stops: stops)
+      }
     }
     if let colorsStr = params.colors {
       let parts = colorsStr.split(separator: "|").map(String.init)
       let colors: [Color] = parts.compactMap { JSColorParser.parse($0) }
-      if !colors.isEmpty { return Gradient(colors: colors) }
+      if !colors.isEmpty {
+        return Gradient(colors: colors)
+      }
     }
     // Fallback neutral gradient
     return Gradient(colors: [Color.black.opacity(0.25), Color.black.opacity(0.05)])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@use-voltra/ios-client",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "description": "Client-only Voltra APIs for iOS",
   "main": "./build/commonjs/index.js",
   "module": "./build/module/index.js",
@@ -39,9 +39,9 @@
     "@expo/plist": "^0.3.5",
     "dedent": "^1.7.1",
     "xcode": "^3.0.1",
-    "@use-voltra/expo-plugin": "^2.1.1",
-    "@use-voltra/ios": "^2.1.1",
-    "@use-voltra/compiler": "^2.1.1"
+    "@use-voltra/compiler": "^2.3.0",
+    "@use-voltra/ios": "^2.3.0",
+    "@use-voltra/expo-plugin": "^2.3.0"
   },
   "peerDependencies": {
     "expo": "*",
@@ -125,7 +125,7 @@
     "format:swift:fix": "swiftformat ios",
     "lint": "oxlint src expo-plugin/src",
     "typecheck": "tsc -p tsconfig.typecheck.json --noEmit && tsc -p expo-plugin/tsconfig.typecheck.json --noEmit",
-    "test": "jest --config expo-plugin/jest.config.js",
+    "test": "jest --config jest.dynamic-widget.config.js && jest --config expo-plugin/jest.config.js",
     "test:swift": "cd ios && swift test"
   }
 }

package/src/dynamic-widget/api.ts

@@ -0,0 +1,25 @@
+import { getNativeVoltra } from '../native/NativeVoltra.js'
+import { assertRunningOnApple } from '../utils/assertRunningOnApple.js'
+
+export type DynamicWidgetPropsValue =
+  | string
+  | number
+  | boolean
+  | null
+  | ReadonlyArray<DynamicWidgetPropsValue>
+  | Readonly<{ [dynamicWidgetPropName: string]: DynamicWidgetPropsValue }>
+
+export type DynamicWidgetProps = Readonly<{
+  [dynamicWidgetPropName: string]: DynamicWidgetPropsValue
+}>
+
+export const updateDynamicWidget = async (
+  dynamicWidgetId: string,
+  dynamicWidgetProps: DynamicWidgetProps
+): Promise<void> => {
+  if (!assertRunningOnApple()) return Promise.resolve()
+
+  const dynamicWidgetPropsJson = JSON.stringify(dynamicWidgetProps)
+
+  return getNativeVoltra().updateDynamicWidget(dynamicWidgetId, dynamicWidgetPropsJson)
+}

package/src/events.ts

@@ -30,15 +30,28 @@ export type VoltraInteractionEvent = BasicVoltraEvent & {
   payload: string
 }
 
+export type VoltraDynamicLiveActivityRenderFailedEvent = BasicVoltraEvent & {
+  type: 'dynamicLiveActivityRenderFailed'
+  activityName: string
+  definitionId: string
+  message: string
+}
+
 const noopSubscription: EventSubscription = {
   remove: () => {},
 }
 
+// Codegen EventEmitter subscriptions do not tell native code when their last
+// JavaScript listener goes away. Keep this count at the public API boundary so
+// the App Group queue is drained only while it can actually be delivered.
+let dynamicRenderFailureListenerCount = 0
+
 export type VoltraEventMap = {
   activityTokenReceived: VoltraActivityTokenReceivedEvent
   activityPushToStartTokenReceived: VoltraActivityPushToStartTokenReceivedEvent
   stateChange: VoltraActivityUpdateEvent
   interaction: VoltraInteractionEvent
+  dynamicLiveActivityRenderFailed: VoltraDynamicLiveActivityRenderFailedEvent
 }
 
 export function addVoltraListener<K extends keyof VoltraEventMap>(
@@ -63,6 +76,27 @@ export function addVoltraListener<K extends keyof VoltraEventMap>(
       return voltraModule.onStateChanged(listener as (arg: VoltraActivityUpdateEvent) => void)
     case 'interaction':
       return voltraModule.onInteraction(listener as (arg: VoltraInteractionEvent) => void)
+    case 'dynamicLiveActivityRenderFailed':
+      const subscription = voltraModule.onDynamicLiveActivityRenderFailed(
+        listener as (arg: VoltraDynamicLiveActivityRenderFailedEvent) => void
+      )
+      dynamicRenderFailureListenerCount += 1
+      if (dynamicRenderFailureListenerCount === 1) {
+        voltraModule.setDynamicLiveActivityRenderFailureListenerActive(true)
+      }
+
+      let removed = false
+      return {
+        remove: () => {
+          if (removed) return
+          removed = true
+          subscription.remove()
+          dynamicRenderFailureListenerCount -= 1
+          if (dynamicRenderFailureListenerCount === 0) {
+            voltraModule.setDynamicLiveActivityRenderFailureListenerActive(false)
+          }
+        },
+      }
     default:
       console.warn(`[Voltra] Event '${event}' is not supported. Returning no-op subscription.`)
       return noopSubscription