Add horizontal waterfall arrow focus

Ariver

2026-06-19 b1368b6a51379714958af82cb1e3dc24183b0583

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import Foundation
 
public enum WindowSpaceMappingPolicy {
    public static func mergedSpaceIDsByWindowID(
        requestedWindowIDs: [UInt32],
        directSpaceIDsByWindowID: [UInt32: [UInt64]],
        windowIDsBySpaceID: [UInt64: [UInt32]],
        orderedSpaceIDs: [UInt64]
    ) -> [UInt32: [UInt64]] {
        let requestedWindowIDSet = Set(requestedWindowIDs)
        var result: [UInt32: [UInt64]] = [:]
 
        for windowID in requestedWindowIDs {
            let directSpaceIDs = orderedUnique(directSpaceIDsByWindowID[windowID] ?? [])
            if !directSpaceIDs.isEmpty {
                result[windowID] = directSpaceIDs
            }
        }
 
        for spaceID in normalizedSpaceOrder(
            orderedSpaceIDs: orderedSpaceIDs,
            windowIDsBySpaceID: windowIDsBySpaceID
        ) {
            for windowID in windowIDsBySpaceID[spaceID] ?? [] {
                guard requestedWindowIDSet.contains(windowID),
                      result[windowID] == nil
                else {
                    continue
                }
 
                result[windowID, default: []].append(spaceID)
            }
        }
 
        return result.mapValues(orderedUnique)
    }
 
    private static func normalizedSpaceOrder(
        orderedSpaceIDs: [UInt64],
        windowIDsBySpaceID: [UInt64: [UInt32]]
    ) -> [UInt64] {
        let orderedUniqueSpaceIDs = orderedUnique(orderedSpaceIDs)
        if !orderedUniqueSpaceIDs.isEmpty {
            return orderedUniqueSpaceIDs
        }
 
        return windowIDsBySpaceID.keys.sorted()
    }
 
    private static func orderedUnique<T: Hashable>(_ values: [T]) -> [T] {
        var seen = Set<T>()
        return values.filter { seen.insert($0).inserted }
    }
}