Remove widget reconciliation from SwiftUI sitemap update path (#1139)

updateUI now replaces currentPage wholesale instead of mutating existing
OpenHABWidget objects through reconcileWidgets/copyWidgetProperties.
Row inputs are already computed from fresh page data before any stored
state changes, so the mutable widget graph was redundant as a rendering
model. Deletes:

- reconcileWidgets(_:with:) and copyWidgetProperties(from:to:) — 70 lines
  of in-place @published mutation that ran on every changed poll
- injectSendCommand(for:) — the injected widget.sendCommand closure was
  never invoked; all row views call viewModel.sendCommand(command,for:itemName)
  directly via @EnvironmentObject
- rowWidgetIndex / buildWidgetIndex / widget(for:) — the RowID→OpenHABWidget
  lookup was dead code; no row view called widget(for:)
- WidgetRenderKey and its five support types — only used by trackWidgetUpdates
  which was removed in the previous commit

loadCurrentPage drops the injectSendCommand call for the same reason.
rebuildRowInputs drops the index rebuild. No behaviour change for any
interactive row; slider optimistic values, segmented/selection sync, and
media refresh all go through the row-input and item-name paths that were
already in place.

Signed-off-by: Tim Mueller-Seydlitz <timbms@gmail.com>

Author: timbms

openHAB/Models/SitemapPageViewModel+SupportTypes.swift

@@ -26,180 +26,3 @@ struct QueuedCommand {
     let version: Int
 }
 
-// swiftlint:disable:next file_types_order
-struct WidgetRenderKey: Equatable {
-    let label: String
-    let icon: String
-    let state: String
-    let iconColor: String
-    let labelColor: String
-    let valueColor: String
-    let url: String
-    let period: String
-    let service: String
-    let legend: Bool?
-    let refresh: Int
-    let height: Double?
-    let forceAsItem: Bool?
-    let visibility: Bool
-    let staticIcon: Bool?
-    let switchSupport: Bool
-    let minValue: Double
-    let maxValue: Double
-    let step: Double
-    let pattern: String?
-    let unit: String?
-    let type: OpenHABWidget.WidgetType
-    let linkedPageLink: String?
-    let linkedPageTitle: String?
-    let mappings: [WidgetMappingKey]
-    let item: WidgetItemKey?
-    let childWidgetIDs: [String]
-
-    static func from(widget: OpenHABWidget) -> WidgetRenderKey {
-        WidgetRenderKey(
-            label: widget.label,
-            icon: widget.icon,
-            state: widget.state,
-            iconColor: widget.iconColor,
-            labelColor: widget.labelcolor,
-            valueColor: widget.valuecolor,
-            url: widget.url,
-            period: widget.period,
-            service: widget.service,
-            legend: widget.legend,
-            refresh: widget.refresh,
-            height: widget.height,
-            forceAsItem: widget.forceAsItem,
-            visibility: widget.visibility,
-            staticIcon: widget.staticIcon,
-            switchSupport: widget.switchSupport,
-            minValue: widget.minValue,
-            maxValue: widget.maxValue,
-            step: widget.step,
-            pattern: widget.pattern,
-            unit: widget.unit,
-            type: widget.type,
-            linkedPageLink: widget.linkedPage?.link,
-            linkedPageTitle: widget.linkedPage?.title,
-            mappings: widget.mappings.map(WidgetMappingKey.init),
-            item: WidgetItemKey.from(item: widget.item),
-            childWidgetIDs: widget.widgets.map(\.widgetId)
-        )
-    }
-
-    // Could be synthesized automatically by compiler. But this takes too long
-    static func == (lhs: WidgetRenderKey, rhs: WidgetRenderKey) -> Bool {
-        lhs.label == rhs.label &&
-            lhs.icon == rhs.icon &&
-            lhs.state == rhs.state &&
-            lhs.iconColor == rhs.iconColor &&
-            lhs.labelColor == rhs.labelColor &&
-            lhs.valueColor == rhs.valueColor &&
-            lhs.url == rhs.url &&
-            lhs.period == rhs.period &&
-            lhs.service == rhs.service &&
-            lhs.legend == rhs.legend &&
-            lhs.refresh == rhs.refresh &&
-            lhs.height == rhs.height &&
-            lhs.forceAsItem == rhs.forceAsItem &&
-            lhs.visibility == rhs.visibility &&
-            lhs.staticIcon == rhs.staticIcon &&
-            lhs.switchSupport == rhs.switchSupport &&
-            lhs.minValue == rhs.minValue &&
-            lhs.maxValue == rhs.maxValue &&
-            lhs.step == rhs.step &&
-            lhs.pattern == rhs.pattern &&
-            lhs.unit == rhs.unit &&
-            lhs.type == rhs.type &&
-            lhs.linkedPageLink == rhs.linkedPageLink &&
-            lhs.linkedPageTitle == rhs.linkedPageTitle &&
-            lhs.mappings == rhs.mappings &&
-            lhs.item == rhs.item &&
-            lhs.childWidgetIDs == rhs.childWidgetIDs
-    }
-}
-
-struct WidgetMappingKey: Equatable {
-    let command: String
-    let label: String
-    let row: Int?
-    let column: Int?
-    let icon: String?
-    let releaseCommand: String?
-
-    init(_ mapping: OpenHABWidgetMapping) {
-        command = mapping.command
-        label = mapping.label
-        row = mapping.row
-        column = mapping.column
-        icon = mapping.icon
-        releaseCommand = mapping.releaseCommand
-    }
-}
-
-struct WidgetItemKey: Equatable {
-    let name: String
-    let state: String?
-    let link: String
-    let label: String
-    let type: OpenHABItem.ItemType?
-    let groupType: OpenHABItem.ItemType?
-    let stateDescription: WidgetStateDescriptionKey?
-    let commandOptions: [WidgetCommandOptionKey]
-
-    static func from(item: OpenHABItem?) -> WidgetItemKey? {
-        guard let item else { return nil }
-        return WidgetItemKey(
-            name: item.name,
-            state: item.state,
-            link: item.link,
-            label: item.label,
-            type: item.type,
-            groupType: item.groupType,
-            stateDescription: WidgetStateDescriptionKey.from(stateDescription: item.stateDescription),
-            commandOptions: item.commandDescription?.commandOptions.map(WidgetCommandOptionKey.init) ?? []
-        )
-    }
-}
-
-struct WidgetStateDescriptionKey: Equatable {
-    let minimum: Double
-    let maximum: Double
-    let step: Double
-    let readOnly: Bool
-    let numberPattern: String?
-    let options: [WidgetOptionKey]
-
-    static func from(stateDescription: OpenHABStateDescription?) -> WidgetStateDescriptionKey? {
-        guard let stateDescription else { return nil }
-        return WidgetStateDescriptionKey(
-            minimum: stateDescription.minimum,
-            maximum: stateDescription.maximum,
-            step: stateDescription.step,
-            readOnly: stateDescription.readOnly,
-            numberPattern: stateDescription.numberPattern,
-            options: stateDescription.options.map(WidgetOptionKey.init)
-        )
-    }
-}
-
-struct WidgetOptionKey: Equatable {
-    let value: String
-    let label: String
-
-    init(_ option: OpenHABOptions) {
-        value = option.value
-        label = option.label
-    }
-}
-
-struct WidgetCommandOptionKey: Equatable {
-    let command: String
-    let label: String?
-
-    init(_ option: OpenHABCommandOptions) {
-        command = option.command
-        label = option.label
-    }
-}

openHAB/Models/SitemapPageViewModel.swift

@@ -96,7 +96,6 @@ class SitemapPageViewModel: ObservableObject {
     private var commandStateResetTasks: [String: Task<Void, Never>] = [:]
     private var commandStateVersions: [String: Int] = [:]
     private var queuedCommands: [String: QueuedCommand] = [:]
-    private var rowWidgetIndex: [RowID: OpenHABWidget] = [:]
     private var sliderValueOverrides: [String: Double] = [:]
     private var sliderOverrideResetTasks: [String: Task<Void, Never>] = [:]
     private var lastForegroundRefreshAt: Date = .distantPast
@@ -267,28 +266,12 @@ class SitemapPageViewModel: ObservableObject {
 
     func rebuildRowInputs() {
         let pageKey = "\(defaultSitemap)|\(pageId)"
-        let widgets = relevantWidgets
-        let inputs = SitemapRowInputMapper.map(pageKey: pageKey, widgets: widgets)
-        rowWidgetIndex = buildWidgetIndex(pageKey: pageKey, widgets: widgets)
+        let inputs = SitemapRowInputMapper.map(pageKey: pageKey, widgets: relevantWidgets)
         if inputs != rowInputs {
             rowInputs = inputs
         }
     }
 
-    private func buildWidgetIndex(pageKey: String, widgets: [OpenHABWidget]) -> [RowID: OpenHABWidget] {
-        var occurrenceByWidgetID: [String: Int] = [:]
-        var index: [RowID: OpenHABWidget] = [:]
-        index.reserveCapacity(widgets.count)
-        for widget in widgets {
-            let identityWidgetID = SitemapRowInputMapper.rowIdentityWidgetID(for: widget)
-            occurrenceByWidgetID[identityWidgetID, default: 0] += 1
-            let occurrence = occurrenceByWidgetID[identityWidgetID]!
-            let rowID = RowID(pageKey: pageKey, widgetId: identityWidgetID, occurrence: occurrence)
-            index[rowID] = widget
-        }
-        return index
-    }
-
     /// Increments `widgetUpdateVersions` for each row whose content differs between `oldInputs`
     /// and `newInputs`, keyed by full row identity.
     func bumpWidgetVersions(from oldInputs: [SitemapRowInput], to newInputs: [SitemapRowInput]) {
@@ -303,10 +286,6 @@ class SitemapPageViewModel: ObservableObject {
         }
     }
 
-    func widget(for rowID: RowID) -> OpenHABWidget? {
-        rowWidgetIndex[rowID]
-    }
-
     func widgetUpdateVersion(for rowID: RowID) -> Int {
         widgetUpdateVersions[rowID.rawValue] ?? 0
     }
@@ -547,7 +526,7 @@ extension SitemapPageViewModel {
 
         let pageKey = "\(defaultSitemap)|\(pageId)"
 
-        // Snapshot what the list would render from the new data — before any widget mutation.
+        // Snapshot new inputs from fresh page data — no widget object mutation.
         let incomingFiltered: [OpenHABWidget]
         if searchText.isEmpty {
             incomingFiltered = page.widgets
@@ -559,36 +538,23 @@ extension SitemapPageViewModel {
         let previewInputs = SitemapRowInputMapper.map(pageKey: pageKey, widgets: incomingFiltered)
 
         let titleChanged = currentPage == nil || currentPage?.title != page.title
-        let canSkipReconciliation = searchText.isEmpty && previewInputs == rowInputs && !titleChanged
-        guard !canSkipReconciliation else {
+        let inputsChanged = previewInputs != rowInputs
+
+        // When search is empty and nothing the UI renders has changed, skip the update entirely.
+        if searchText.isEmpty, !inputsChanged, !titleChanged {
             _ = clearSyncedSliderOverrides(using: page.widgets)
             return
         }
 
-        // Something changed — reconcile widget objects and update stored state.
-        let currentWidgets = currentPage?.widgets ?? []
-        let structureChanged = currentWidgets.count != page.widgets.count
-            || !zip(currentWidgets, page.widgets).allSatisfy { $0.widgetId == $1.widgetId }
-        let reconciledWidgets = reconcileWidgets(page.widgets, with: currentWidgets)
-        injectSendCommand(for: reconciledWidgets)
-
-        if structureChanged || titleChanged {
-            page.widgets = reconciledWidgets
-            currentPage = page
-        } else {
-            currentPage?.widgets = reconciledWidgets
-        }
-
-        _ = clearSyncedSliderOverrides(using: reconciledWidgets)
-
-        // Rebuild command-dispatch index from the now-current reconciled widgets.
-        rowWidgetIndex = buildWidgetIndex(pageKey: pageKey, widgets: relevantWidgets)
+        // Replace currentPage wholesale — no in-place widget reconciliation.
+        currentPage = page
 
-        // Bump widget versions only for rows whose content actually changed.
-        bumpWidgetVersions(from: rowInputs, to: previewInputs)
+        _ = clearSyncedSliderOverrides(using: page.widgets)
 
-        // Publish new row inputs — guaranteed to differ from current (checked above).
-        rowInputs = previewInputs
+        if inputsChanged {
+            bumpWidgetVersions(from: rowInputs, to: previewInputs)
+            rowInputs = previewInputs
+        }
     }
 
     private func clearSyncedSliderOverrides(using widgets: [OpenHABWidget]) -> Int {
@@ -661,80 +627,10 @@ extension SitemapPageViewModel {
             throw SitemapPageError.noData
         }
 
-        injectSendCommand(for: page.widgets)
         currentPage = page
         rebuildRowInputs()
     }
 
-    private func reconcileWidgets(_ newWidgets: [OpenHABWidget], with currentWidgets: [OpenHABWidget]) -> [OpenHABWidget] {
-        var buckets: [String: [OpenHABWidget]] = [:]
-        for widget in currentWidgets {
-            buckets[widget.widgetId, default: []].append(widget)
-        }
-
-        var reconciled: [OpenHABWidget] = []
-        reconciled.reserveCapacity(newWidgets.count)
-
-        for newWidget in newWidgets {
-            if var candidates = buckets[newWidget.widgetId], !candidates.isEmpty {
-                let existing = candidates.removeFirst()
-                buckets[newWidget.widgetId] = candidates
-
-                // Always copy server properties to avoid missing updates when
-                // non-keyed fields change (for example group summary/state rows).
-                let previousChildren = existing.widgets
-                copyWidgetProperties(from: newWidget, to: existing)
-                existing.widgets = reconcileWidgets(newWidget.widgets, with: previousChildren)
-
-                reconciled.append(existing)
-            } else {
-                reconciled.append(newWidget)
-            }
-        }
-
-        return reconciled
-    }
-
-    private func copyWidgetProperties(from source: OpenHABWidget, to target: OpenHABWidget) {
-        target.label = source.label
-        target.icon = source.icon
-        target.state = source.state
-        target.type = source.type
-        target.isLeaf = source.isLeaf
-        target.item = source.item
-        target.iconColor = source.iconColor
-        target.labelcolor = source.labelcolor
-        target.valuecolor = source.valuecolor
-        target.url = source.url
-        target.period = source.period
-        target.service = source.service
-        target.legend = source.legend
-        target.refresh = source.refresh
-        target.height = source.height
-        target.forceAsItem = source.forceAsItem
-        target.minValue = source.minValue
-        target.maxValue = source.maxValue
-        target.step = source.step
-        target.pattern = source.pattern
-        target.unit = source.unit
-        target.switchSupport = source.switchSupport
-        target.mappings = source.mappings
-        target.linkedPage = source.linkedPage
-        target.visibility = source.visibility
-        target.staticIcon = source.staticIcon
-        target.text = source.text
-        target.inputHint = source.inputHint
-        target.encoding = source.encoding
-        target.labelSource = source.labelSource
-        target.releaseOnly = source.releaseOnly
-        target.row = source.row
-        target.column = source.column
-        target.releaseCommand = source.releaseCommand
-        target.command = source.command
-        target.stateless = source.stateless
-        target.yAxisDecimalPattern = source.yAxisDecimalPattern
-    }
-
     private func shouldRetryLongPolling(after error: any Error) -> Bool {
         if let urlError = OpenAPIErrorInspector.underlyingURLError(from: error) {
             switch urlError.code {
@@ -757,17 +653,6 @@ extension SitemapPageViewModel {
         return false
     }
 
-    private func injectSendCommand(for widgets: [OpenHABWidget]) {
-        for widget in widgets {
-            widget.sendCommand = { [weak self] item, command in
-                self?.sendCommand(item, commandToSend: command)
-            }
-
-            // If widget has nested children (e.g., frames/groups), inject recursively
-            injectSendCommand(for: widget.widgets)
-        }
-    }
-
     @MainActor
     func pushSitemap(name: String, path: String?) async {
         defaultSitemap = name