@craft-native/ios 0.0.194 → 0.0.196

package/dist/cli.js

@@ -881,6 +881,7 @@ function writeShell(output, config) {
   cpSync(join3(TEMPLATES_DIR, "CraftWebAudio.swift"), join3(output, "Sources", "CraftWebAudio.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftHybrid.swift"), join3(output, "Sources", "CraftHybrid.swift"));
   writeFileSync(join3(output, "Sources", "CraftCrashReporter.swift"), readFileSync(join3(TEMPLATES_DIR, "CraftCrashReporter.swift"), "utf-8").replace(/\{\{CRAFT_VERSION\}\}/g, CRAFT_VERSION));
+  cpSync(join3(TEMPLATES_DIR, "CraftLiveActivities.swift"), join3(output, "Sources", "CraftLiveActivities.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftActivityAttributes.swift"), join3(output, "Shared", "CraftActivityAttributes.swift"));
   for (const [enabled, folder, template, filename] of [
     [config.enableLiveActivities, "WidgetExtension", "CraftLiveActivityWidget.swift.template", `${name}LiveActivity.swift`],

package/dist/index.js

@@ -1018,6 +1018,7 @@ function writeShell(output, config) {
   cpSync(join3(TEMPLATES_DIR, "CraftWebAudio.swift"), join3(output, "Sources", "CraftWebAudio.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftHybrid.swift"), join3(output, "Sources", "CraftHybrid.swift"));
   writeFileSync2(join3(output, "Sources", "CraftCrashReporter.swift"), readFileSync2(join3(TEMPLATES_DIR, "CraftCrashReporter.swift"), "utf-8").replace(/\{\{CRAFT_VERSION\}\}/g, CRAFT_VERSION));
+  cpSync(join3(TEMPLATES_DIR, "CraftLiveActivities.swift"), join3(output, "Sources", "CraftLiveActivities.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftActivityAttributes.swift"), join3(output, "Shared", "CraftActivityAttributes.swift"));
   for (const [enabled, folder, template, filename] of [
     [config.enableLiveActivities, "WidgetExtension", "CraftLiveActivityWidget.swift.template", `${name}LiveActivity.swift`],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-native/ios",
-  "version": "0.0.194",
+  "version": "0.0.196",
   "homepage": "https://github.com/craft-native/craft/tree/main/packages/ios#readme",
   "repository": {
     "type": "git",

package/templates/CraftActivityAttributes.swift

@@ -7,8 +7,20 @@ struct CraftActivityAttributes: ActivityAttributes {
         let distanceMeters: Double
         let durationSeconds: Double
         let progress: Double
+        var staleStatus: String?
+        var detail: String?
+        /// Epoch milliseconds. SwiftUI advances these timers without app updates.
+        var timerStartedAt: Double?
+        var timerEndsAt: Double?
+        var paused: Bool?
+        var remainingSeconds: Double?
+        var heartRate: Double?
+        var showsDistance: Bool?
     }
 
     let activityId: String
     let title: String
+    var symbol: String?
+    var deepLink: String?
+    var tint: String?
 }

package/templates/CraftApp.swift

@@ -2752,6 +2752,10 @@ struct CraftWebView: UIViewRepresentable {
                 }
 
             // MARK: - Live Activities
+            case "isLiveActivityAvailable":
+                liveActivity(method: "isAvailable", args: [], callbackId: callbackId)
+            case "listLiveActivities":
+                liveActivity(method: "list", args: [], callbackId: callbackId)
             case "startLiveActivity":
                 if config.enableLiveActivities {
                     startLiveActivity(body: body, callbackId: callbackId)
@@ -5380,6 +5384,8 @@ struct CraftWebView: UIViewRepresentable {
                     };
                 })();
                 craft.liveActivity = {
+                    isAvailable: function() { return craft._invoke('isLiveActivityAvailable'); },
+                    list: function() { return craft._invoke('listLiveActivities'); },
                     start: function(options) { return craft._invoke('startLiveActivity', options || {}); },
                     update: function(idOrState, state) {
                         if (typeof idOrState !== 'string') return craft._invoke('updateLiveActivity', idOrState || {});
@@ -7463,123 +7469,25 @@ struct CraftWebView: UIViewRepresentable {
         }
 
         // MARK: - Live Activities
-        private func startLiveActivity(body: [String: Any], callbackId: String?) {
-            guard #available(iOS 16.2, *), ActivityAuthorizationInfo().areActivitiesEnabled else {
-                rejectCallback(callbackId, error: "Live Activities are unavailable")
-                return
-            }
-            let attributes = CraftActivityAttributes(
-                activityId: body["activityId"] as? String ?? UUID().uuidString,
-                title: body["title"] as? String ?? config.appName
-            )
-            let state = CraftActivityAttributes.ContentState(
-                status: body["status"] as? String ?? "Recording",
-                distanceMeters: body["distanceMeters"] as? Double ?? 0,
-                durationSeconds: body["durationSeconds"] as? Double ?? 0,
-                progress: min(max(body["progress"] as? Double ?? 0, 0), 1)
-            )
-            do {
-                let activity = try Activity.request(
-                    attributes: attributes,
-                    content: ActivityContent(state: state, staleDate: nil),
-                    pushType: nil
-                )
-                resolveCallback(callbackId, result: ["id": activity.id])
-            } catch {
-                rejectCallback(callbackId, error: error.localizedDescription)
+        private func liveActivity(method: String, args: [Any], callbackId: String?) {
+            let token = armDeadline(Coordinator.liveActivityDeadline, callbackId: callbackId, error: "Live Activity request timed out")
+            CraftLiveActivities.perform(method: method, args: args, enabled: config.enableLiveActivities, appName: config.appName) { [weak self] result in
+                guard let self, self.claimDeadline(token) else { return }
+                switch result {
+                case .success(let value): self.resolveCallback(callbackId, result: value)
+                case .failure(let error): self.rejectCallback(callbackId, error: error.message)
+                }
             }
         }
 
+        private func startLiveActivity(body: [String: Any], callbackId: String?) {
+            liveActivity(method: "start", args: [body], callbackId: callbackId)
+        }
         private func updateLiveActivity(body: [String: Any], callbackId: String?) {
-            guard #available(iOS 16.2, *) else {
-                rejectCallback(callbackId, error: "No Live Activity is running")
-                return
-            }
-            let activities = Activity<CraftActivityAttributes>.activities
-            let activity: Activity<CraftActivityAttributes>
-            if let activityId = body["id"] as? String {
-                guard let matchingActivity = activities.first(where: { $0.id == activityId }) else {
-                    rejectCallback(callbackId, error: "No Live Activity with id \(activityId) is running")
-                    return
-                }
-                activity = matchingActivity
-            } else {
-                guard let currentActivity = activities.first else {
-                    rejectCallback(callbackId, error: "No Live Activity is running")
-                    return
-                }
-                activity = currentActivity
-            }
-            let current = activity.content.state
-            let state = CraftActivityAttributes.ContentState(
-                status: body["status"] as? String ?? current.status,
-                distanceMeters: body["distanceMeters"] as? Double ?? current.distanceMeters,
-                durationSeconds: body["durationSeconds"] as? Double ?? current.durationSeconds,
-                progress: min(max(body["progress"] as? Double ?? current.progress, 0), 1)
-            )
-            let token = armDeadline(
-                Coordinator.liveActivityDeadline,
-                callbackId: callbackId,
-                error: "Activity.update did not return within \(Int(Coordinator.liveActivityDeadline))s"
-            )
-            Task {
-                await activity.update(ActivityContent(state: state, staleDate: nil))
-                await MainActor.run { [weak self] in
-                    guard let self, self.claimDeadline(token) else { return }
-                    self.resolveCallback(callbackId, result: ["updated": true])
-                }
-            }
+            liveActivity(method: "update", args: [body["id"] ?? NSNull(), body], callbackId: callbackId)
         }
-
         private func endLiveActivity(body: [String: Any], callbackId: String?) {
-            guard #available(iOS 16.2, *) else {
-                resolveCallback(callbackId, result: ["ended": false])
-                return
-            }
-            let activities = Activity<CraftActivityAttributes>.activities
-            let activity: Activity<CraftActivityAttributes>
-            if let activityId = body["id"] as? String {
-                guard let matchingActivity = activities.first(where: { $0.id == activityId }) else {
-                    rejectCallback(callbackId, error: "No Live Activity with id \(activityId) is running")
-                    return
-                }
-                activity = matchingActivity
-            } else {
-                guard let currentActivity = activities.first else {
-                    resolveCallback(callbackId, result: ["ended": false])
-                    return
-                }
-                activity = currentActivity
-            }
-            let hasFinalState = body["status"] != nil
-                || body["distanceMeters"] != nil
-                || body["durationSeconds"] != nil
-                || body["progress"] != nil
-            let finalContent: ActivityContent<CraftActivityAttributes.ContentState>?
-            if hasFinalState {
-                let current = activity.content.state
-                let state = CraftActivityAttributes.ContentState(
-                    status: body["status"] as? String ?? current.status,
-                    distanceMeters: body["distanceMeters"] as? Double ?? current.distanceMeters,
-                    durationSeconds: body["durationSeconds"] as? Double ?? current.durationSeconds,
-                    progress: min(max(body["progress"] as? Double ?? current.progress, 0), 1)
-                )
-                finalContent = ActivityContent(state: state, staleDate: nil)
-            } else {
-                finalContent = nil
-            }
-            let token = armDeadline(
-                Coordinator.liveActivityDeadline,
-                callbackId: callbackId,
-                error: "Activity.end did not return within \(Int(Coordinator.liveActivityDeadline))s"
-            )
-            Task {
-                await activity.end(finalContent, dismissalPolicy: .default)
-                await MainActor.run { [weak self] in
-                    guard let self, self.claimDeadline(token) else { return }
-                    self.resolveCallback(callbackId, result: ["ended": true])
-                }
-            }
+            liveActivity(method: "end", args: [body["id"] ?? NSNull(), body], callbackId: callbackId)
         }
 
         // MARK: - Screen Capture

package/templates/CraftLiveActivities.swift

@@ -0,0 +1,98 @@
+import ActivityKit
+import Foundation
+
+/// ActivityKit belongs to the process, not a web view or a retained STX screen.
+/// A stable application activityId reattaches after a screen or app restart.
+enum CraftLiveActivities {
+    static func perform(method: String, args: [Any], enabled: Bool, appName: String, completion: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+        guard enabled else {
+            if method == "isAvailable" { completion(.success(false)); return }
+            completion(.failure(CraftNativeActionError(code: "CAPABILITY_DISABLED", message: "Live Activities are disabled")))
+            return
+        }
+        guard #available(iOS 16.2, *) else {
+            if method == "isAvailable" { completion(.success(false)) }
+            else { completion(.failure(CraftNativeActionError(code: "UNSUPPORTED", message: "Live Activities require iOS 16.2"))) }
+            return
+        }
+        Task { @MainActor in
+            do {
+                let activities = Activity<CraftActivityAttributes>.activities.filter { $0.activityState == .active || $0.activityState == .stale }
+                switch method {
+                case "isAvailable": completion(.success(ActivityAuthorizationInfo().areActivitiesEnabled))
+                case "list": completion(.success(activities.map { ["id": $0.id, "activityId": $0.attributes.activityId, "title": $0.attributes.title] }))
+                case "start":
+                    guard ActivityAuthorizationInfo().areActivitiesEnabled else {
+                        throw CraftNativeActionError(code: "NOT_ALLOWED", message: "Live Activities are turned off in Settings")
+                    }
+                    let body = args.first as? [String: Any] ?? [:]
+                    guard let key = body["activityId"] as? String, !key.isEmpty,
+                          let title = body["title"] as? String, !title.isEmpty else {
+                        throw CraftNativeActionError(code: "INVALID_ARGUMENT", message: "A Live Activity needs activityId and title")
+                    }
+                    let state = content(body)
+                    if let existing = activities.first(where: { $0.attributes.activityId == key }) {
+                        await existing.update(ActivityContent(state: state, staleDate: staleDate(body)))
+                        completion(.success(["id": existing.id]))
+                        return
+                    }
+                    let attributes = CraftActivityAttributes(activityId: key, title: String(title.prefix(160)), symbol: body["symbol"] as? String, deepLink: safeURL(body["deepLink"] as? String), tint: body["tint"] as? String)
+                    let activity = try Activity.request(attributes: attributes, content: ActivityContent(state: state, staleDate: staleDate(body)), pushType: nil)
+                    completion(.success(["id": activity.id]))
+                case "update", "end":
+                    let id = args.first as? String
+                    let activity = id == nil ? activities.first : activities.first(where: { $0.id == id })
+                    guard let activity else {
+                        if method == "end" { completion(.success(["ended": false])); return }
+                        throw CraftNativeActionError(code: "NOT_FOUND", message: "No matching Live Activity is running")
+                    }
+                    let body = args.count > 1 ? args[1] as? [String: Any] ?? [:] : [:]
+                    let state = content(body, previous: activity.content.state)
+                    if method == "end" {
+                        await activity.end(ActivityContent(state: state, staleDate: nil), dismissalPolicy: .immediate)
+                        completion(.success(["ended": true]))
+                    } else {
+                        await activity.update(ActivityContent(state: state, staleDate: staleDate(body)))
+                        completion(.success(["updated": true]))
+                    }
+                default: throw CraftNativeActionError(code: "UNKNOWN_ACTION", message: "Unsupported Live Activities method")
+                }
+            } catch let error as CraftNativeActionError { completion(.failure(error)) }
+            catch { completion(.failure(CraftNativeActionError(code: "ACTIVITY_ERROR", message: error.localizedDescription))) }
+        }
+    }
+
+    private static func safeURL(_ value: String?) -> String? {
+        guard let value, let url = URL(string: value), let scheme = url.scheme?.lowercased(),
+              !["javascript", "data", "file"].contains(scheme) else { return nil }
+        return value
+    }
+
+    private static func finite(_ body: [String: Any], _ key: String, _ fallback: Double? = nil) -> Double? {
+        guard body.keys.contains(key) else { return fallback }
+        guard let number = body[key] as? NSNumber, number.doubleValue.isFinite else { return nil }
+        return max(0, number.doubleValue)
+    }
+
+    private static func staleDate(_ body: [String: Any]) -> Date? {
+        finite(body, "staleAt").map { Date(timeIntervalSince1970: $0 / 1000) }
+    }
+
+    @available(iOS 16.2, *)
+    private static func content(_ body: [String: Any], previous: CraftActivityAttributes.ContentState? = nil) -> CraftActivityAttributes.ContentState {
+        CraftActivityAttributes.ContentState(
+            status: String((body["status"] as? String ?? previous?.status ?? "").prefix(120)),
+            distanceMeters: finite(body, "distanceMeters", previous?.distanceMeters) ?? 0,
+            durationSeconds: finite(body, "durationSeconds", previous?.durationSeconds) ?? 0,
+            progress: min(finite(body, "progress", previous?.progress) ?? 0, 1),
+            staleStatus: body["staleStatus"] as? String ?? previous?.staleStatus,
+            detail: body["detail"] as? String ?? previous?.detail,
+            timerStartedAt: finite(body, "timerStartedAt", previous?.timerStartedAt),
+            timerEndsAt: finite(body, "timerEndsAt", previous?.timerEndsAt),
+            paused: body["paused"] as? Bool ?? previous?.paused,
+            remainingSeconds: finite(body, "remainingSeconds", previous?.remainingSeconds),
+            heartRate: finite(body, "heartRate", previous?.heartRate),
+            showsDistance: body["showsDistance"] as? Bool ?? previous?.showsDistance
+        )
+    }
+}

package/templates/CraftLiveActivityWidget.swift.template

@@ -4,59 +4,112 @@ import WidgetKit
 
 @main
 struct CraftLiveActivityBundle: WidgetBundle {
-    var body: some Widget {
-        CraftLiveActivityWidget()
-    }
+    var body: some Widget { CraftLiveActivityWidget() }
 }
 
 struct CraftLiveActivityWidget: Widget {
     var body: some WidgetConfiguration {
         ActivityConfiguration(for: CraftActivityAttributes.self) { context in
             HStack(spacing: 12) {
-                Image(systemName: "figure.run")
-                    .foregroundStyle(.green)
-                VStack(alignment: .leading, spacing: 3) {
-                    Text(context.attributes.title).font(.headline)
-                    Text(context.state.status).font(.caption).foregroundStyle(.secondary)
+                Image(systemName: symbol(context)).font(.title2).foregroundStyle(tint(context))
+                VStack(alignment: .leading, spacing: 4) {
+                    Text(context.attributes.title).font(.headline).lineLimit(1)
+                    if let detail = context.state.detail, !detail.isEmpty {
+                        Text(detail).font(.subheadline).lineLimit(1)
+                    }
+                    Text(context.isStale ? context.state.staleStatus ?? context.state.status : context.state.status).font(.caption).foregroundStyle(.secondary).lineLimit(1)
                 }
-                Spacer()
-                VStack(alignment: .trailing, spacing: 3) {
-                    Text(distance(context.state.distanceMeters)).font(.headline.monospacedDigit())
-                    Text(duration(context.state.durationSeconds)).font(.caption.monospacedDigit())
+                Spacer(minLength: 8)
+                VStack(alignment: .trailing, spacing: 4) {
+                    timer(context).font(.title2.monospacedDigit().weight(.semibold))
+                    metrics(context).font(.caption.monospacedDigit())
                 }
             }
             .padding()
-            .activityBackgroundTint(Color(red: 0, green: 0.24, blue: 0.18))
+            .activityBackgroundTint(Color(red: 0.07, green: 0.10, blue: 0.16))
             .activitySystemActionForegroundColor(.white)
+            .widgetURL(context.attributes.deepLink.flatMap(URL.init(string:)))
         } dynamicIsland: { context in
             DynamicIsland {
                 DynamicIslandExpandedRegion(.leading) {
-                    Label(context.state.status, systemImage: "figure.run")
+                    Image(systemName: symbol(context)).foregroundStyle(tint(context)).font(.title2)
                 }
                 DynamicIslandExpandedRegion(.trailing) {
-                    Text(distance(context.state.distanceMeters)).monospacedDigit()
+                    timer(context).font(.title2.monospacedDigit().weight(.semibold))
+                }
+                DynamicIslandExpandedRegion(.center) {
+                    VStack(spacing: 3) {
+                        Text(context.attributes.title).font(.headline).lineLimit(1)
+                        Text(context.isStale ? context.state.staleStatus ?? context.state.status : context.state.status).font(.caption).foregroundStyle(.secondary).lineLimit(1)
+                    }
                 }
                 DynamicIslandExpandedRegion(.bottom) {
-                    ProgressView(value: context.state.progress)
-                        .tint(.green)
+                    VStack(spacing: 8) {
+                        HStack {
+                            Text(context.state.detail ?? "").font(.subheadline).lineLimit(1)
+                            Spacer()
+                            metrics(context).font(.caption.monospacedDigit())
+                        }
+                        if let end = context.state.timerEndsAt, context.state.paused != true, let start = context.state.timerStartedAt, end > start {
+                            ProgressView(timerInterval: date(start)...date(end), countsDown: false).labelsHidden().tint(tint(context))
+                        } else {
+                            ProgressView(value: context.state.progress).tint(tint(context))
+                        }
+                    }
                 }
             } compactLeading: {
-                Image(systemName: "figure.run")
+                Image(systemName: symbol(context)).foregroundStyle(tint(context))
             } compactTrailing: {
-                Text(distance(context.state.distanceMeters)).monospacedDigit()
+                timer(context).monospacedDigit().frame(maxWidth: 64)
             } minimal: {
-                Image(systemName: "figure.run")
+                Image(systemName: symbol(context)).foregroundStyle(tint(context))
             }
-            .keylineTint(.green)
+            .widgetURL(context.attributes.deepLink.flatMap(URL.init(string:)))
+            .keylineTint(tint(context))
         }
     }
 
-    private func distance(_ meters: Double) -> String {
-        String(format: "%.2f km", meters / 1000)
+    private func symbol(_ context: ActivityViewContext<CraftActivityAttributes>) -> String {
+        context.state.paused == true ? "pause.fill" : context.attributes.symbol ?? "timer"
+    }
+
+    private func tint(_ context: ActivityViewContext<CraftActivityAttributes>) -> Color {
+        let raw = context.attributes.tint?.trimmingCharacters(in: CharacterSet(charactersIn: "#")) ?? "007aff"
+        guard raw.count == 6, let value = UInt32(raw, radix: 16) else { return .blue }
+        return Color(red: Double((value >> 16) & 255) / 255, green: Double((value >> 8) & 255) / 255, blue: Double(value & 255) / 255)
+    }
+
+    private func date(_ milliseconds: Double) -> Date { Date(timeIntervalSince1970: milliseconds / 1000) }
+
+    @ViewBuilder
+    private func timer(_ context: ActivityViewContext<CraftActivityAttributes>) -> some View {
+        if context.state.paused == true {
+            Text(duration(context.state.remainingSeconds ?? context.state.durationSeconds))
+        } else if let end = context.state.timerEndsAt {
+            // Clamped at zero, with no JavaScript timer or per-second Activity.update.
+            let start = min(date(context.state.timerStartedAt ?? end - 1), date(end))
+            Text(timerInterval: start...date(end), countsDown: true)
+        } else if let start = context.state.timerStartedAt {
+            Text(date(start), style: .timer)
+        } else {
+            Text(duration(context.state.durationSeconds))
+        }
+    }
+
+    @ViewBuilder
+    private func metrics(_ context: ActivityViewContext<CraftActivityAttributes>) -> some View {
+        HStack(spacing: 8) {
+            if let bpm = context.state.heartRate, bpm > 0 {
+                Label("\(Int(bpm))", systemImage: "heart.fill").foregroundStyle(.pink).privacySensitive()
+            }
+            if context.state.showsDistance != false {
+                Text(Measurement(value: context.state.distanceMeters, unit: UnitLength.meters), format: .measurement(width: .abbreviated, usage: .road)).privacySensitive()
+            }
+        }
     }
 
     private func duration(_ seconds: Double) -> String {
         let value = max(Int(seconds), 0)
-        return String(format: "%02d:%02d", value / 60, value % 60)
+        return value >= 3600 ? String(format: "%d:%02d:%02d", value / 3600, value / 60 % 60, value % 60) : String(format: "%d:%02d", value / 60, value % 60)
     }
 }

package/templates/CraftNativeActions.swift

@@ -48,6 +48,7 @@ enum CraftNativeActions {
         if config.enableDeepLinks { values.append("deepLinks") }
         if config.enableLocalNotifications { values.append("notifications") }
         if config.enableHealthKit { values.append("health") }
+        if config.enableLiveActivities { values.append("liveActivities") }
         // The in-app browser and the system's web sign-in sheet (CraftBrowser).
         values.append("browser")
         if config.enableSocialAuth { values.append("appleSignIn") }
@@ -328,6 +329,11 @@ enum CraftNativeActions {
                 }
             }
             return
+        case ("LiveActivities", _):
+            CraftLiveActivities.perform(method: method, args: args, enabled: config.enableLiveActivities, appName: config.appName) { result in
+                complete(requestToken, result, completion)
+            }
+            return
         case ("Health", _):
             // Apple Health, the same as a page's `craft.health` (CraftHealth.swift).
             guard config.enableHealthKit else {

package/templates/CraftNativeFlatList.swift

@@ -214,6 +214,19 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         if flowLayout.estimatedItemSize != estimate, bounds.width > 0 {
             flowLayout.estimatedItemSize = estimate
         }
+        // Cells can outlive a change to the list's width (including its first
+        // constrained parent layout). Self-sizing must use the current extent,
+        // or UIKit repeatedly receives a preferred width wider than the list.
+        var changedExtent = false
+        for case let cell as Cell in visibleCells {
+            guard let identity = cell.representedIdentity, let item = itemsByIdentity[identity] else { continue }
+            let extent = itemExtent(isChrome: item.isChrome)
+            if cell.fittingExtent != extent {
+                cell.fittingExtent = extent
+                changedExtent = true
+            }
+        }
+        if changedExtent { flowLayout.invalidateLayout() }
         super.layoutSubviews()
         craftApplyCornerRadius()
     }

package/templates/CraftNativeScreen.swift

@@ -5534,6 +5534,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 scale = 1
             }
             indicator.indicatorScale = scale
+            applyTransform(style["transform"], to: indicator)
             indicator.color = color(props["color"]) ?? .tintColor
             indicator.hidesWhenStopped = props["hidesWhenStopped"] as? Bool ?? true
             if props["animating"] as? Bool == false {