sitepong 0.2.2 → 0.2.4

package/ios/LiveActivity/widget/DSLRenderer.swift

@@ -0,0 +1,538 @@
+import SwiftUI
+import WidgetKit
+
+// MARK: - DSLView
+
+@available(iOS 16.2, *)
+struct DSLView: View {
+    let node: DSLNode
+    let data: [String: AnyCodable]
+
+    var body: some View {
+        applyStyle(to: renderNode())
+    }
+
+    // MARK: - Node routing
+
+    @ViewBuilder
+    private func renderNode() -> some View {
+        switch node.type {
+        case "vstack":
+            renderVStack()
+        case "hstack":
+            renderHStack()
+        case "zstack":
+            renderZStack()
+        case "text":
+            renderText()
+        case "image":
+            renderImage()
+        case "spacer":
+            renderSpacer()
+        case "gauge":
+            renderGauge()
+        case "progress":
+            renderProgress()
+        case "shape":
+            renderShape()
+        case "container":
+            renderContainer()
+        case "conditional":
+            renderConditional()
+        default:
+            EmptyView()
+        }
+    }
+
+    // MARK: - Stack views
+
+    @ViewBuilder
+    private func renderVStack() -> some View {
+        let alignment = horizontalAlignment(from: prop("alignment")?.stringValue)
+        let spacing = prop("spacing")?.doubleValue
+
+        VStack(alignment: alignment, spacing: spacing.map { CGFloat($0) }) {
+            renderChildren()
+        }
+    }
+
+    @ViewBuilder
+    private func renderHStack() -> some View {
+        let alignment = verticalAlignment(from: prop("alignment")?.stringValue)
+        let spacing = prop("spacing")?.doubleValue
+
+        HStack(alignment: alignment, spacing: spacing.map { CGFloat($0) }) {
+            renderChildren()
+        }
+    }
+
+    @ViewBuilder
+    private func renderZStack() -> some View {
+        let alignment = compositeAlignment(from: prop("alignment")?.stringValue)
+
+        ZStack(alignment: alignment) {
+            renderChildren()
+        }
+    }
+
+    // MARK: - Text
+
+    @ViewBuilder
+    private func renderText() -> some View {
+        let content = interpolate(prop("value")?.stringValue ?? "")
+        let fontPreset = prop("font")?.stringValue
+        let fontSize = prop("fontSize")?.doubleValue
+        let fontWeightName = prop("fontWeight")?.stringValue
+        let color = prop("color")?.stringValue
+        let italic = prop("italic")?.boolValue ?? false
+        let monoDigit = prop("monospacedDigit")?.boolValue ?? false
+        let lineLimit = prop("lineLimit")?.intValue
+
+        let weight = symbolWeight(fontWeightName)
+        let size = fontSize ?? fontPresetSize(fontPreset) ?? 14
+
+        var font = Font.system(size: size, weight: weight)
+        if monoDigit {
+            font = font.monospacedDigit()
+        }
+
+        let textView = Text(content)
+            .font(font)
+            .italic(italic)
+
+        if let lineLimit = lineLimit {
+            if let color = Color(hex: color) {
+                textView.foregroundStyle(color).lineLimit(lineLimit)
+            } else {
+                textView.lineLimit(lineLimit)
+            }
+        } else {
+            if let color = Color(hex: color) {
+                textView.foregroundStyle(color)
+            } else {
+                textView
+            }
+        }
+    }
+
+    // MARK: - Image (SF Symbols only)
+
+    @ViewBuilder
+    private func renderImage() -> some View {
+        let symbolName = interpolate(prop("symbol")?.stringValue ?? prop("name")?.stringValue ?? "questionmark")
+        let color = prop("color")?.stringValue
+        let weightName = prop("weight")?.stringValue
+        let size = prop("size")?.doubleValue ?? 16
+
+        let weight = symbolWeight(weightName)
+
+        let img = Image(systemName: symbolName)
+            .font(.system(size: size, weight: weight))
+
+        if let color = Color(hex: color) {
+            img.foregroundStyle(color)
+        } else {
+            img
+        }
+    }
+
+    // MARK: - Spacer
+
+    @ViewBuilder
+    private func renderSpacer() -> some View {
+        if let minLength = prop("minLength")?.doubleValue {
+            Spacer(minLength: CGFloat(minLength))
+        } else {
+            Spacer()
+        }
+    }
+
+    // MARK: - Gauge (iOS 16+)
+
+    @ViewBuilder
+    private func renderGauge() -> some View {
+        let value = prop("value")?.doubleValue ?? 0
+        let minVal = prop("min")?.doubleValue ?? 0
+        let maxVal = prop("max")?.doubleValue ?? 1
+        let label = interpolate(prop("label")?.stringValue ?? "")
+        let gaugeStyle = prop("style")?.stringValue ?? "linear"
+        let tintColor = prop("tint")?.stringValue
+        let trackColor = prop("trackColor")?.stringValue
+
+        let clamped = max(minVal, min(maxVal, value))
+
+        if gaugeStyle == "circular" {
+            Gauge(value: clamped, in: minVal...maxVal) {
+                Text(label)
+            }
+            .gaugeStyle(.accessoryCircular)
+            .tint(Color(hex: tintColor) ?? .accentColor)
+        } else {
+            Gauge(value: clamped, in: minVal...maxVal) {
+                Text(label)
+            }
+            .gaugeStyle(.accessoryLinear)
+            .tint(Color(hex: tintColor) ?? .accentColor)
+        }
+    }
+
+    // MARK: - ProgressView
+
+    @ViewBuilder
+    private func renderProgress() -> some View {
+        let value = prop("value")?.doubleValue ?? 0
+        let tintColor = prop("tint")?.stringValue
+
+        ProgressView(value: max(0, min(1, value)))
+            .tint(Color(hex: tintColor) ?? .accentColor)
+    }
+
+    // MARK: - Shape
+
+    @ViewBuilder
+    private func renderShape() -> some View {
+        let shapeType = prop("shape")?.stringValue ?? "rectangle"
+        let fillColor = prop("fill")?.stringValue
+        let strokeColor = prop("stroke")?.stringValue
+        let strokeWidth = prop("strokeWidth")?.doubleValue ?? 1
+
+        switch shapeType {
+        case "circle":
+            if let strokeColor = Color(hex: strokeColor) {
+                Circle().stroke(strokeColor, lineWidth: strokeWidth)
+                    .background(Circle().fill(Color(hex: fillColor) ?? .clear))
+            } else {
+                Circle().fill(Color(hex: fillColor) ?? .clear)
+            }
+        case "capsule":
+            if let strokeColor = Color(hex: strokeColor) {
+                Capsule().stroke(strokeColor, lineWidth: strokeWidth)
+                    .background(Capsule().fill(Color(hex: fillColor) ?? .clear))
+            } else {
+                Capsule().fill(Color(hex: fillColor) ?? .clear)
+            }
+        case "roundedRectangle":
+            let radius = prop("radius")?.doubleValue ?? 8
+            if let strokeColor = Color(hex: strokeColor) {
+                RoundedRectangle(cornerRadius: radius).stroke(strokeColor, lineWidth: strokeWidth)
+                    .background(RoundedRectangle(cornerRadius: radius).fill(Color(hex: fillColor) ?? .clear))
+            } else {
+                RoundedRectangle(cornerRadius: radius).fill(Color(hex: fillColor) ?? .clear)
+            }
+        default: // rectangle
+            if let strokeColor = Color(hex: strokeColor) {
+                Rectangle().stroke(strokeColor, lineWidth: strokeWidth)
+                    .background(Rectangle().fill(Color(hex: fillColor) ?? .clear))
+            } else {
+                Rectangle().fill(Color(hex: fillColor) ?? .clear)
+            }
+        }
+    }
+
+    // MARK: - Container
+
+    @ViewBuilder
+    private func renderContainer() -> some View {
+        // Just renders children; style is applied by applyStyle
+        VStack(spacing: 0) {
+            renderChildren()
+        }
+    }
+
+    // MARK: - Conditional
+
+    @ViewBuilder
+    private func renderConditional() -> some View {
+        let condition = prop("condition")?.stringValue ?? ""
+        if evaluateCondition(condition) {
+            renderChildren()
+        }
+    }
+
+    // MARK: - Children rendering
+
+    @ViewBuilder
+    private func renderChildren() -> some View {
+        if let children = node.children {
+            ForEach(children) { child in
+                DSLView(node: child, data: data)
+                    .applyAnimation(child.animation)
+            }
+        }
+    }
+
+    // MARK: - Style application
+
+    @ViewBuilder
+    private func applyStyle<V: View>(to view: V) -> some View {
+        let styled = view
+            .modifier(DSLPaddingModifier(padding: node.style?.padding))
+            .modifier(DSLFrameModifier(frame: node.style?.frame))
+            .modifier(DSLBackgroundModifier(
+                backgroundColor: node.style?.backgroundColor,
+                backgroundGradient: node.style?.backgroundGradient,
+                cornerRadius: node.style?.cornerRadius
+            ))
+            .modifier(DSLForegroundModifier(foregroundColor: node.style?.foregroundColor))
+            .modifier(DSLOpacityModifier(opacity: node.style?.opacity))
+            .modifier(DSLShadowModifier(shadow: node.style?.shadow))
+
+        if node.style?.cornerRadius != nil && node.style?.backgroundColor == nil && node.style?.backgroundGradient == nil {
+            styled.clipShape(RoundedRectangle(cornerRadius: node.style!.cornerRadius!))
+        } else {
+            styled
+        }
+    }
+
+    // MARK: - Helpers
+
+    private func prop(_ key: String) -> AnyCodable? {
+        node.props?[key]
+    }
+
+    /// Replace `{{varName}}` with data dictionary values.
+    private func interpolate(_ text: String) -> String {
+        var result = text
+        let pattern = "\\{\\{(\\w+)\\}\\}"
+        guard let regex = try? NSRegularExpression(pattern: pattern) else { return text }
+        let matches = regex.matches(in: text, range: NSRange(text.startIndex..., in: text))
+
+        for match in matches.reversed() {
+            guard let keyRange = Range(match.range(at: 1), in: text),
+                  let fullRange = Range(match.range, in: text) else { continue }
+            let key = String(text[keyRange])
+            if let replacement = data[key]?.stringValue ?? data[key]?.doubleValue.map(String.init) ?? data[key]?.intValue.map(String.init) {
+                result = result.replacingCharacters(in: fullRange, with: replacement)
+            }
+        }
+        return result
+    }
+
+    /// Evaluate simple conditions like `{{status}} == 'active'`
+    private func evaluateCondition(_ condition: String) -> Bool {
+        let interpolated = interpolate(condition)
+        // Support: `value == 'literal'` or `value != 'literal'`
+        if interpolated.contains("!=") {
+            let parts = interpolated.components(separatedBy: "!=").map { $0.trimmingCharacters(in: .whitespaces) }
+            guard parts.count == 2 else { return false }
+            return stripQuotes(parts[0]) != stripQuotes(parts[1])
+        } else if interpolated.contains("==") {
+            let parts = interpolated.components(separatedBy: "==").map { $0.trimmingCharacters(in: .whitespaces) }
+            guard parts.count == 2 else { return false }
+            return stripQuotes(parts[0]) == stripQuotes(parts[1])
+        }
+        // Truthy check: non-empty string
+        return !interpolated.trimmingCharacters(in: .whitespaces).isEmpty
+    }
+
+    private func stripQuotes(_ s: String) -> String {
+        var result = s
+        if (result.hasPrefix("'") && result.hasSuffix("'")) ||
+           (result.hasPrefix("\"") && result.hasSuffix("\"")) {
+            result.removeFirst()
+            result.removeLast()
+        }
+        return result
+    }
+
+    /// Map font preset names to sizes.
+    private func fontPresetSize(_ preset: String?) -> Double? {
+        switch preset {
+        case "largeTitle": return 34
+        case "title": return 28
+        case "title2": return 22
+        case "title3": return 20
+        case "headline": return 17
+        case "body": return 17
+        case "callout": return 16
+        case "subheadline": return 15
+        case "footnote": return 13
+        case "caption": return 12
+        case "caption2": return 11
+        default: return nil
+        }
+    }
+}
+
+// MARK: - Alignment helpers
+
+private func horizontalAlignment(from name: String?) -> HorizontalAlignment {
+    switch name {
+    case "center": return .center
+    case "trailing": return .trailing
+    case "leading": return .leading
+    default: return .leading
+    }
+}
+
+private func verticalAlignment(from name: String?) -> VerticalAlignment {
+    switch name {
+    case "top": return .top
+    case "bottom": return .bottom
+    case "center": return .center
+    default: return .center
+    }
+}
+
+private func compositeAlignment(from name: String?) -> Alignment {
+    switch name {
+    case "topLeading": return .topLeading
+    case "top": return .top
+    case "topTrailing": return .topTrailing
+    case "leading": return .leading
+    case "center": return .center
+    case "trailing": return .trailing
+    case "bottomLeading": return .bottomLeading
+    case "bottom": return .bottom
+    case "bottomTrailing": return .bottomTrailing
+    default: return .center
+    }
+}
+
+// MARK: - Style modifiers
+
+@available(iOS 16.2, *)
+struct DSLPaddingModifier: ViewModifier {
+    let padding: DSLPadding?
+
+    func body(content: Content) -> some View {
+        guard let p = padding else { return AnyView(content) }
+
+        if let all = p.all {
+            return AnyView(content.padding(all))
+        }
+
+        var view = AnyView(content)
+        if let h = p.horizontal {
+            view = AnyView(view.padding(.horizontal, h))
+        }
+        if let v = p.vertical {
+            view = AnyView(view.padding(.vertical, v))
+        }
+        if let t = p.top {
+            view = AnyView(view.padding(.top, t))
+        }
+        if let b = p.bottom {
+            view = AnyView(view.padding(.bottom, b))
+        }
+        if let l = p.leading {
+            view = AnyView(view.padding(.leading, l))
+        }
+        if let tr = p.trailing {
+            view = AnyView(view.padding(.trailing, tr))
+        }
+        return view
+    }
+}
+
+@available(iOS 16.2, *)
+struct DSLFrameModifier: ViewModifier {
+    let frame: DSLFrame?
+
+    func body(content: Content) -> some View {
+        guard let f = frame else { return AnyView(content) }
+
+        if f.width != nil || f.height != nil {
+            return AnyView(content.frame(
+                width: f.width.map { CGFloat($0) },
+                height: f.height.map { CGFloat($0) }
+            ))
+        }
+
+        return AnyView(content.frame(
+            minWidth: f.minWidth.map { CGFloat($0) },
+            maxWidth: f.maxWidth.map { CGFloat($0) },
+            minHeight: f.minHeight.map { CGFloat($0) },
+            maxHeight: f.maxHeight.map { CGFloat($0) }
+        ))
+    }
+}
+
+@available(iOS 16.2, *)
+struct DSLBackgroundModifier: ViewModifier {
+    let backgroundColor: String?
+    let backgroundGradient: DSLGradient?
+    let cornerRadius: Double?
+
+    func body(content: Content) -> some View {
+        let radius = cornerRadius ?? 0
+
+        if let gradient = backgroundGradient, !gradient.colors.isEmpty {
+            let colors = gradient.colors.compactMap { Color(hex: $0) }
+            let start = unitPoint(from: gradient.startPoint ?? "top")
+            let end = unitPoint(from: gradient.endPoint ?? "bottom")
+            return AnyView(
+                content.background(
+                    LinearGradient(colors: colors, startPoint: start, endPoint: end)
+                        .clipShape(RoundedRectangle(cornerRadius: radius))
+                )
+            )
+        } else if let bgColor = Color(hex: backgroundColor) {
+            return AnyView(
+                content.background(
+                    bgColor.clipShape(RoundedRectangle(cornerRadius: radius))
+                )
+            )
+        }
+        return AnyView(content)
+    }
+
+    private func unitPoint(from name: String) -> UnitPoint {
+        switch name {
+        case "top": return .top
+        case "bottom": return .bottom
+        case "leading": return .leading
+        case "trailing": return .trailing
+        case "topLeading": return .topLeading
+        case "topTrailing": return .topTrailing
+        case "bottomLeading": return .bottomLeading
+        case "bottomTrailing": return .bottomTrailing
+        case "center": return .center
+        default: return .top
+        }
+    }
+}
+
+@available(iOS 16.2, *)
+struct DSLForegroundModifier: ViewModifier {
+    let foregroundColor: String?
+
+    func body(content: Content) -> some View {
+        if let color = Color(hex: foregroundColor) {
+            AnyView(content.foregroundStyle(color))
+        } else {
+            AnyView(content)
+        }
+    }
+}
+
+@available(iOS 16.2, *)
+struct DSLOpacityModifier: ViewModifier {
+    let opacity: Double?
+
+    func body(content: Content) -> some View {
+        if let opacity = opacity {
+            content.opacity(opacity)
+        } else {
+            content
+        }
+    }
+}
+
+@available(iOS 16.2, *)
+struct DSLShadowModifier: ViewModifier {
+    let shadow: DSLShadow?
+
+    func body(content: Content) -> some View {
+        if let s = shadow {
+            content.shadow(
+                color: Color(hex: s.color) ?? .black.opacity(0.2),
+                radius: s.radius ?? 4,
+                x: s.x ?? 0,
+                y: s.y ?? 2
+            )
+        } else {
+            content
+        }
+    }
+}