CopilotForXcode/Core/Sources/SuggestionWidget/FeatureReducers/PanelFeature.swift at beb08894e71df711d7b2d5f4686de783c0bd6e46 · codehobby2022/CopilotForXcode · GitHub

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
import AppKit
import ComposableArchitecture
import Foundation

public struct PanelFeature: ReducerProtocol {
    public struct State: Equatable {
        var content: SharedPanelFeature.Content? {
            get { sharedPanelState.content ?? suggestionPanelState.content }
            set {
                sharedPanelState.content = newValue
                suggestionPanelState.content = newValue
            }
        }

        // MARK: SharedPanel

        var sharedPanelState = SharedPanelFeature.State()

        // MARK: SuggestionPanel

        var suggestionPanelState = SuggestionPanelFeature.State()
    }

    public enum Action: Equatable {
        case presentSuggestion
        case presentError(String)
        case presentPromptToCode
        case presentPanelContent(SharedPanelFeature.Content, shouldDisplay: Bool)
        case discardPanelContent
        case removeDisplayedContent
        case switchToAnotherEditorAndUpdateContent

        case sharedPanel(SharedPanelFeature.Action)
        case suggestionPanel(SuggestionPanelFeature.Action)
    }

    @Dependency(\.suggestionWidgetControllerDependency) var suggestionWidgetControllerDependency
    @Dependency(\.xcodeInspector) var xcodeInspector
    var windows: WidgetWindows { suggestionWidgetControllerDependency.windows }

    public var body: some ReducerProtocol<State, Action> {
        Scope(state: \.suggestionPanelState, action: /Action.suggestionPanel) {
            SuggestionPanelFeature()
        }

        Scope(state: \.sharedPanelState, action: /Action.sharedPanel) {
            SharedPanelFeature()
        }

        Reduce { state, action in
            switch action {
            case .presentSuggestion:
                return .run { send in
                    guard let provider = await fetchSuggestionProvider(
                        fileURL: xcodeInspector.activeDocumentURL
                    ) else { return }
                    let content = SharedPanelFeature.Content.suggestion(provider)
                    await send(.presentPanelContent(content, shouldDisplay: true))
                }.animation(.easeInOut(duration: 0.2))

            case let .presentError(errorDescription):
                return .run { send in
                    let content = SharedPanelFeature.Content.error(errorDescription)
                    await send(.presentPanelContent(content, shouldDisplay: true))
                }.animation(.easeInOut(duration: 0.2))

            case .presentPromptToCode:
                return .run { send in
                    guard let provider = await fetchPromptToCodeProvider(
                        fileURL: xcodeInspector.activeDocumentURL
                    ) else { return }
                    let content = SharedPanelFeature.Content.promptToCode(provider)
                    await send(.presentPanelContent(content, shouldDisplay: true))

                    // looks like we need a delay.
                    try await Task.sleep(nanoseconds: 150_000_000)
                    await NSApplication.shared.activate(ignoringOtherApps: true)
                    await windows.sharedPanelWindow.makeKey()
                }.animation(.easeInOut(duration: 0.2))

            case let .presentPanelContent(content, shouldDisplay):
                state.content = content

                guard shouldDisplay else { return .none }

                switch content {
                case .suggestion:
                    switch UserDefaults.shared.value(for: \.suggestionPresentationMode) {
                    case .nearbyTextCursor:
                        state.suggestionPanelState.isPanelDisplayed = true
                    case .floatingWidget:
                        state.sharedPanelState.isPanelDisplayed = true
                    }
                case .error:
                    state.sharedPanelState.isPanelDisplayed = true
                case .promptToCode:
                    state.sharedPanelState.isPanelDisplayed = true
                }

                return .none

            case .discardPanelContent:
                return .run { send in
                    let fileURL = xcodeInspector.activeDocumentURL
                    if let provider = await fetchPromptToCodeProvider(fileURL: fileURL) {
                        await send(.presentPanelContent(
                            .promptToCode(provider),
                            shouldDisplay: false
                        ))
                    } else if let provider = await fetchSuggestionProvider(fileURL: fileURL) {
                        await send(.presentPanelContent(
                            .suggestion(provider),
                            shouldDisplay: false
                        ))
                    } else {
                        await send(.removeDisplayedContent)
                    }
                }.animation(.easeInOut(duration: 0.2))

            case .switchToAnotherEditorAndUpdateContent:
                return .run { send in
                    let fileURL = xcodeInspector.activeDocumentURL
                    if let provider = await fetchPromptToCodeProvider(fileURL: fileURL) {
                        await send(.presentPanelContent(
                            .promptToCode(provider),
                            shouldDisplay: false
                        ))
                    } else if let provider = await fetchSuggestionProvider(fileURL: fileURL) {
                        await send(.presentPanelContent(
                            .suggestion(provider),
                            shouldDisplay: false
                        ))
                    } else {
                        await send(.removeDisplayedContent)
                    }
                }

            case .removeDisplayedContent:
                state.content = nil
                return .none

            case .sharedPanel:
                return .none
            case .suggestionPanel:
                return .none
            }
        }
    }

    func fetchSuggestionProvider(fileURL: URL) async -> SuggestionProvider? {
        guard let provider = await suggestionWidgetControllerDependency
            .suggestionWidgetDataSource?
            .suggestionForFile(at: fileURL) else { return nil }
        return provider
    }

    func fetchPromptToCodeProvider(fileURL: URL) async -> PromptToCodeProvider? {
        guard let provider = await suggestionWidgetControllerDependency
            .suggestionWidgetDataSource?
            .promptToCodeForFile(at: fileURL) else { return nil }
        return provider
    }
}