fix(ios): replace UIColor light-dark() approach with LightDarkForeground ShapeStyle

The UIColor(dynamicProvider:) approach does not produce adaptive colors in WidgetKit.
Replace with LightDarkForeground: ShapeStyle whose resolve(in: EnvironmentValues) is
called by SwiftUI's rendering engine at draw time with the correct dark/light context.

- JSColorParser: add parseLightDarkComponents() returning both Color values as a pair;
  parseLightDark() private fallback (UIColor) kept for non-text contexts (borders,
  backgrounds); remove findTopLevelComma() in favour of splitLightDark()
- TextStyle: add lightDarkColors field; add LightDarkForeground: ShapeStyle
- StyleConverter.parseText: route light-dark() strings to lightDarkColors instead of
  the flat color field
- VoltraText: switch from foregroundColor to foregroundStyle(LightDarkForeground(...))
  when lightDarkColors is set

Author: burczu

packages/voltra/ios/ui/Style/JSColorParser.swift

@@ -33,8 +33,8 @@ enum JSColorParser {
       return parseHSL(trimmed)
     }
 
-    // 4. light-dark() — CSS Color Level 4 adaptive color
-    if trimmed.hasPrefix("light-dark") {
+    // 4. light-dark() — adaptive color, resolved natively by UIKit trait system
+    if trimmed.hasPrefix("light-dark(") {
       return parseLightDark(trimmed)
     }
 
@@ -97,45 +97,60 @@ enum JSColorParser {
 
   // MARK: - light-dark() Parser
 
-  /// Parses `light-dark(<lightColor>, <darkColor>)` into an adaptive Color that
-  /// automatically responds to the system color scheme via UITraitCollection.
-  private static func parseLightDark(_ string: String) -> Color? {
-    guard let function = parseFunctionCall(string, allowedNames: ["light-dark"]) else { return nil }
+  /// Splits a `light-dark(<light>, <dark>)` string into its two component strings.
+  private static func splitLightDark(_ trimmed: String) -> (lightStr: String, darkStr: String)? {
+    let prefix = "light-dark("
+    guard trimmed.hasPrefix(prefix) else { return nil }
+    let inner = String(trimmed.dropFirst(prefix.count))
+    guard inner.hasSuffix(")") else { return nil }
+    let body = String(inner.dropLast())
 
-    // Split on the first top-level comma — arguments may themselves contain commas
-    // (e.g. rgb(255, 0, 0)), so we must count parenthesis depth.
-    guard let splitIndex = findTopLevelComma(in: function.arguments) else { return nil }
+    var depth = 0
+    var commaIndex: String.Index? = nil
+    for idx in body.indices {
+      switch body[idx] {
+      case "(": depth += 1
+      case ")": depth -= 1
+      case "," where depth == 0 && commaIndex == nil: commaIndex = idx
+      default: break
+      }
+    }
 
-    let lightString = String(function.arguments[..<splitIndex]).trimmingCharacters(in: .whitespacesAndNewlines)
-    let darkString = String(function.arguments[function.arguments.index(after: splitIndex)...]).trimmingCharacters(in: .whitespacesAndNewlines)
+    guard let comma = commaIndex else { return nil }
+    return (
+      lightStr: String(body[..<comma]).trimmingCharacters(in: .whitespacesAndNewlines),
+      darkStr: String(body[body.index(after: comma)...]).trimmingCharacters(in: .whitespacesAndNewlines)
+    )
+  }
 
-    guard let lightColor = parse(lightString), let darkColor = parse(darkString) else { return nil }
+  /// Returns both Color values for a `light-dark()` string so the caller can resolve
+  /// via `LightDarkForeground: ShapeStyle` at draw time.
+  static func parseLightDarkComponents(_ value: Any?) -> (light: Color, dark: Color)? {
+    guard let string = value as? String else { return nil }
+    let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+    guard let split = splitLightDark(trimmed) else { return nil }
+    guard let lightColor = parse(split.lightStr),
+          let darkColor = parse(split.darkStr) else { return nil }
+    return (light: lightColor, dark: darkColor)
+  }
 
+  /// Fallback used by `parse()` for non-text contexts (e.g. borders, backgrounds).
+  /// Uses UIColor dynamic provider — best-effort; prefer parseLightDarkComponents()
+  /// + LightDarkForeground: ShapeStyle for text foreground colors.
+  private static func parseLightDark(_ string: String) -> Color? {
+    guard let split = splitLightDark(string),
+          let lightC = parseColorComponents(split.lightStr),
+          let darkC = parseColorComponents(split.darkStr) else { return nil }
     #if canImport(UIKit)
       return Color(uiColor: UIColor { traitCollection in
-        traitCollection.userInterfaceStyle == .dark
-          ? UIColor(darkColor)
-          : UIColor(lightColor)
+        let c = traitCollection.userInterfaceStyle == .dark ? darkC : lightC
+        return UIColor(red: c.red, green: c.green, blue: c.blue, alpha: c.alpha)
       })
     #else
-      return lightColor
+      return Color(.sRGB, red: lightC.red, green: lightC.green, blue: lightC.blue, opacity: lightC.alpha)
     #endif
   }
 
-  /// Returns the index of the first comma that is not nested inside parentheses.
-  private static func findTopLevelComma(in string: String) -> String.Index? {
-    var depth = 0
-    for index in string.indices {
-      switch string[index] {
-      case "(": depth += 1
-      case ")": depth -= 1
-      case "," where depth == 0: return index
-      default: break
-      }
-    }
-    return nil
-  }
-
   /// Parse named color strings
   private static func parseNamedColor(_ name: String) -> Color? {
     switch name {

packages/voltra/ios/ui/Style/StyleConverter.swift

@@ -153,9 +153,14 @@ enum StyleConverter {
   private static func parseText(_ js: [String: Any]) -> TextStyle {
     var style = TextStyle()
 
-    if let color = JSColorParser.parse(js["color"]) {
+    let colorValue = js["color"]
+    if let colorStr = colorValue as? String,
+       colorStr.trimmingCharacters(in: .whitespacesAndNewlines).lowercased().hasPrefix("light-dark("),
+       let components = JSColorParser.parseLightDarkComponents(colorStr) {
+      style.lightDarkColors = components
+    } else if let color = JSColorParser.parse(colorValue) {
       style.color = color
-      style.usesPrimaryColorInReducedPresentation = JSColorParser.shouldUsePrimaryColorInReducedPresentation(js["color"])
+      style.usesPrimaryColorInReducedPresentation = JSColorParser.shouldUsePrimaryColorInReducedPresentation(colorValue)
     }
 
     if let size = JSStyleParser.number(js["fontSize"]) {

packages/voltra/ios/ui/Style/TextStyle.swift

@@ -2,6 +2,7 @@ import SwiftUI
 
 struct TextStyle {
   var color: Color = .primary
+  var lightDarkColors: (light: Color, dark: Color)? = nil
   var usesPrimaryColorInReducedPresentation = false
   var fontSize: CGFloat = 17
   var fontWeight: Font.Weight = .regular
@@ -15,6 +16,19 @@ struct TextStyle {
   var fontVariant: Set<FontVariant> = []
 }
 
+/// A ShapeStyle whose resolve(in:) is called by SwiftUI's rendering engine at draw time,
+/// not during body evaluation. This is the correct hook for adaptive colors in WidgetKit
+/// because the rendering engine passes the correct dark/light environment to resolve(in:)
+/// even though @Environment(\.colorScheme) in body always reads as .light.
+struct LightDarkForeground: ShapeStyle {
+  let light: Color
+  let dark: Color
+
+  func resolve(in environment: EnvironmentValues) -> some ShapeStyle {
+    environment.colorScheme == .dark ? dark : light
+  }
+}
+
 struct TextStyleModifier: ViewModifier {
   let style: TextStyle
   @Environment(\.voltraEnvironment) private var voltraEnvironment

packages/voltra/ios/ui/Views/VoltraText.swift

@@ -74,9 +74,13 @@ public struct VoltraText: VoltraView {
       .kerning(textStyle.letterSpacing)
       .underline(textStyle.decoration == .underline || textStyle.decoration == .underlineLineThrough)
       .strikethrough(textStyle.decoration == .lineThrough || textStyle.decoration == .underlineLineThrough)
-      // These technically work on View, but good to keep close
       .font(font)
-      .foregroundColor(resolvedColor)
+      .foregroundStyle({
+        if let ld = textStyle.lightDarkColors {
+          return AnyShapeStyle(LightDarkForeground(light: ld.light, dark: ld.dark))
+        }
+        return AnyShapeStyle(resolvedColor)
+      }())
       .multilineTextAlignment(alignment)
       .lineSpacing(textStyle.lineSpacing)
       .voltraIfLet(params.numberOfLines) { view, numberOfLines in