Room Member is now an interface SDK update (#711)

* migrated to the usage of a Protocol for the RoomMember

* removed unused file

* code improvement

* sliding sync new states

* sdk bump

* fix for tests

* fixing tests

* package resolved rollback

* rollback package.resolved

* fixed a mistakenly removed dependency

* Revert "fixed a mistakenly removed dependency"

This reverts commit 096d9da6142d8117bc1dfa6d5bbbd797b43b31ad.

* removing unnecessary Identifiable conformance

* pr suggestions

* pr comment

ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -111,8 +111,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/matrix-org/matrix-rust-components-swift",
       "state" : {
-        "revision" : "cc68dbd95a35a481a7398e7cc324e26917fd4022",
+        "revision" : "9eee9ba2f14eaa4981759295790bcbdbdebca747",
-        "version" : "1.0.47-alpha"
+        "version" : "1.0.48-alpha"
       }
     },
     {

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -50,6 +50,36 @@ class BugReportServiceMock: BugReportServiceProtocol {
         }
     }
 }
+class RoomMemberProxyMock: RoomMemberProxyProtocol {
+    var userID: String {
+        get { return underlyingUserID }
+        set(value) { underlyingUserID = value }
+    }
+    var underlyingUserID: String!
+    var displayName: String?
+    var avatarURL: URL?
+    var membership: MembershipState {
+        get { return underlyingMembership }
+        set(value) { underlyingMembership = value }
+    }
+    var underlyingMembership: MembershipState!
+    var isNameAmbiguous: Bool {
+        get { return underlyingIsNameAmbiguous }
+        set(value) { underlyingIsNameAmbiguous = value }
+    }
+    var underlyingIsNameAmbiguous: Bool!
+    var powerLevel: Int {
+        get { return underlyingPowerLevel }
+        set(value) { underlyingPowerLevel = value }
+    }
+    var underlyingPowerLevel: Int!
+    var normalizedPowerLevel: Int {
+        get { return underlyingNormalizedPowerLevel }
+        set(value) { underlyingNormalizedPowerLevel = value }
+    }
+    var underlyingNormalizedPowerLevel: Int!
+
+}
 class RoomProxyMock: RoomProxyProtocol {
     var id: String {
         get { return underlyingId }
@@ -321,10 +351,10 @@ class RoomProxyMock: RoomProxyProtocol {
     var membersCalled: Bool {
         return membersCallsCount > 0
     }
-    var membersReturnValue: Result<[RoomMemberProxy], RoomProxyError>!
+    var membersReturnValue: Result<[RoomMemberProxyProtocol], RoomProxyError>!
-    var membersClosure: (() async -> Result<[RoomMemberProxy], RoomProxyError>)?
+    var membersClosure: (() async -> Result<[RoomMemberProxyProtocol], RoomProxyError>)?
 
-    func members() async -> Result<[RoomMemberProxy], RoomProxyError> {
+    func members() async -> Result<[RoomMemberProxyProtocol], RoomProxyError> {
         membersCallsCount += 1
         if let membersClosure = membersClosure {
             return await membersClosure()

ElementX/Sources/Mocks/RoomMemberProxyMock.swift

@@ -0,0 +1,74 @@
+//
+// Copyright 2023 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+import MatrixRustSDK
+
+struct RoomMemberProxyMockConfiguration {
+    var userID: String
+    var displayName: String
+    var avatarURL: String?
+    var membership: MembershipState
+    var isNameAmbiguous: Bool
+    var powerLevel: Int
+    var normalizedPowerLevel: Int
+}
+
+extension RoomMemberProxyMock {
+    convenience init(with configuration: RoomMemberProxyMockConfiguration) {
+        self.init()
+        userID = configuration.userID
+        displayName = configuration.displayName
+        if let avatarURL = configuration.avatarURL {
+            self.avatarURL = URL(string: avatarURL)
+        }
+        membership = configuration.membership
+        isNameAmbiguous = configuration.isNameAmbiguous
+        powerLevel = configuration.powerLevel
+        normalizedPowerLevel = configuration.normalizedPowerLevel
+    }
+
+    // Mocks
+    static var mockAlice: RoomMemberProxyMock {
+        RoomMemberProxyMock(with: .init(userID: "alice@matrix.org",
+                                        displayName: "Alice",
+                                        avatarURL: nil,
+                                        membership: .join,
+                                        isNameAmbiguous: false,
+                                        powerLevel: 50,
+                                        normalizedPowerLevel: 50))
+    }
+
+    static var mockBob: RoomMemberProxyMock {
+        RoomMemberProxyMock(with: .init(userID: "bob@matrix.org",
+                                        displayName: "Bob",
+                                        avatarURL: nil,
+                                        membership: .join,
+                                        isNameAmbiguous: false,
+                                        powerLevel: 50,
+                                        normalizedPowerLevel: 50))
+    }
+
+    static var mockCharlie: RoomMemberProxyMock {
+        RoomMemberProxyMock(with: .init(userID: "charlie@matrix.org",
+                                        displayName: "Charlie",
+                                        avatarURL: nil,
+                                        membership: .join,
+                                        isNameAmbiguous: false,
+                                        powerLevel: 50,
+                                        normalizedPowerLevel: 50))
+    }
+}

ElementX/Sources/Mocks/RoomProxyMock.swift

@@ -30,7 +30,7 @@ struct RoomProxyMockConfiguration {
     var canonicalAlias: String?
     var alternativeAliases: [String] = []
     var hasUnreadNotifications = Bool.random()
-    var members: [RoomMemberProxy]?
+    var members: [RoomMemberProxyProtocol]?
 }
 
 extension RoomProxyMock {

ElementX/Sources/Screens/RoomDetails/RoomDetailsCoordinator.swift

@@ -62,7 +62,7 @@ final class RoomDetailsCoordinator: CoordinatorProtocol {
         AnyView(RoomDetailsScreen(context: viewModel.context))
     }
     
-    private func presentRoomMemberDetails(_ members: [RoomMemberProxy]) {
+    private func presentRoomMemberDetails(_ members: [RoomMemberProxyProtocol]) {
         let params = RoomMemberDetailsCoordinatorParameters(mediaProvider: parameters.mediaProvider,
                                                             members: members)
         let coordinator = RoomMemberDetailsCoordinator(parameters: params)

ElementX/Sources/Screens/RoomDetails/RoomDetailsModels.swift

@@ -22,7 +22,7 @@ import UIKit
 // MARK: View model
 
 enum RoomDetailsViewModelAction {
-    case requestMemberDetailsPresentation([RoomMemberProxy])
+    case requestMemberDetailsPresentation([RoomMemberProxyProtocol])
     case leftRoom
     case cancel
 }
@@ -86,8 +86,8 @@ struct RoomDetailsMember: Identifiable, Equatable {
     let name: String?
     let avatarURL: URL?
 
-    init(withProxy proxy: RoomMemberProxy) {
+    init(withProxy proxy: RoomMemberProxyProtocol) {
-        id = proxy.userId
+        id = proxy.userID
         name = proxy.displayName
         avatarURL = proxy.avatarURL
     }

ElementX/Sources/Screens/RoomDetails/RoomDetailsViewModel.swift

@@ -20,7 +20,7 @@ typealias RoomDetailsViewModelType = StateStoreViewModel<RoomDetailsViewState, R
 
 class RoomDetailsViewModel: RoomDetailsViewModelType, RoomDetailsViewModelProtocol {
     private let roomProxy: RoomProxyProtocol
-    private var members: [RoomMemberProxy] = [] {
+    private var members: [RoomMemberProxyProtocol] = [] {
         didSet {
             state.members = members.map { RoomDetailsMember(withProxy: $0) }
         }

ElementX/Sources/Screens/RoomDetails/View/RoomDetailsScreen.swift

@@ -182,7 +182,7 @@ struct RoomDetailsScreen: View {
 
 struct RoomDetails_Previews: PreviewProvider {
     static let viewModel = {
-        let members: [RoomMemberProxy] = [
+        let members: [RoomMemberProxyMock] = [
             .mockAlice,
             .mockBob,
             .mockCharlie

ElementX/Sources/Screens/RoomMembers/RoomMemberDetailsCoordinator.swift

@@ -18,7 +18,7 @@ import SwiftUI
 
 struct RoomMemberDetailsCoordinatorParameters {
     let mediaProvider: MediaProviderProtocol
-    let members: [RoomMemberProxy]
+    let members: [RoomMemberProxyProtocol]
 }
 
 enum RoomMemberDetailsCoordinatorAction {

ElementX/Sources/Screens/RoomMembers/RoomMemberDetailsViewModel.swift

@@ -24,7 +24,7 @@ class RoomMemberDetailsViewModel: RoomMemberDetailsViewModelType, RoomMemberDeta
     var callback: ((RoomMemberDetailsViewModelAction) -> Void)?
 
     init(mediaProvider: MediaProviderProtocol,
-         members: [RoomMemberProxy]) {
+         members: [RoomMemberProxyProtocol]) {
         self.mediaProvider = mediaProvider
         super.init(initialViewState: .init(members: members.map { RoomDetailsMember(withProxy: $0) },
                                            bindings: .init()),

ElementX/Sources/Screens/RoomMembers/View/RoomMemberDetailsMemberCell.swift

@@ -48,7 +48,7 @@ struct RoomMemberDetailsMemberCell: View {
 
 struct RoomMemberDetailsMemberCell_Previews: PreviewProvider {
     static var previews: some View {
-        let members: [RoomMemberProxy] = [
+        let members: [RoomMemberProxyMock] = [
             .mockAlice,
             .mockBob,
             .mockCharlie
@@ -57,7 +57,7 @@ struct RoomMemberDetailsMemberCell_Previews: PreviewProvider {
                                                    members: members)
         
         return VStack {
-            ForEach(members) { member in
+            ForEach(members, id: \.userID) { member in
                 RoomMemberDetailsMemberCell(member: .init(withProxy: member), context: viewModel.context)
             }
         }

ElementX/Sources/Screens/RoomMembers/View/RoomMemberDetailsScreen.swift

@@ -50,7 +50,7 @@ struct RoomMemberDetailsScreen: View {
 
 struct RoomMemberDetails_Previews: PreviewProvider {
     static let viewModel = {
-        let members: [RoomMemberProxy] = [
+        let members: [RoomMemberProxyMock] = [
             .mockAlice,
             .mockBob,
             .mockCharlie

ElementX/Sources/Screens/StartChat/StartChatModels.swift

@@ -25,7 +25,7 @@ struct StartChatViewState: BindableState {
     var bindings = StartChatScreenViewStateBindings()
     
     // TODO: bind with real service, and mock data only in preview
-    var suggestedUsers: [RoomMemberProxy] = [.mockAlice, .mockBob, .mockCharlie]
+    var suggestedUsers: [RoomMemberProxyMock] = [.mockAlice, .mockBob, .mockCharlie]
 }
 
 struct StartChatScreenViewStateBindings {

ElementX/Sources/Screens/StartChat/View/StartChatScreen.swift

@@ -60,7 +60,7 @@ struct StartChatScreen: View {
     
     private var suggestionsSection: some View {
         Section {
-            ForEach(context.viewState.suggestedUsers, id: \.userId) { user in
+            ForEach(context.viewState.suggestedUsers, id: \.userID) { user in
                 StartChatSuggestedUserCell(user: user, imageProvider: context.imageProvider)
             }
         } header: {

ElementX/Sources/Screens/StartChat/View/StartChatSuggestedUserCell.swift

@@ -17,14 +17,14 @@
 import SwiftUI
 
 struct StartChatSuggestedUserCell: View {
-    let user: RoomMemberProxy
+    let user: RoomMemberProxyProtocol
     let imageProvider: ImageProviderProtocol?
     
     var body: some View {
         HStack(spacing: 13) {
             LoadableAvatarImage(url: user.avatarURL,
                                 name: user.displayName,
-                                contentID: user.userId,
+                                contentID: user.userID,
                                 avatarSize: .user(on: .home),
                                 imageProvider: imageProvider)
                 .accessibilityHidden(true)
@@ -32,11 +32,11 @@ struct StartChatSuggestedUserCell: View {
             VStack(alignment: .leading, spacing: 4) {
                 // covers both nil and empty state
                 let displayName = user.displayName ?? ""
-                Text(displayName.isEmpty ? user.userId : displayName)
+                Text(displayName.isEmpty ? user.userID : displayName)
                     .font(.element.title3)
                     .foregroundColor(.element.primaryContent)
                 if !displayName.isEmpty {
-                    Text(user.userId)
+                    Text(user.userID)
                         .font(.element.subheadline)
                         .foregroundColor(.element.tertiaryContent)
                 }

ElementX/Sources/Services/Room/RoomMember/RoomMemberProxy.swift

@@ -0,0 +1,54 @@
+//
+// Copyright 2023 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+import MatrixRustSDK
+
+final class RoomMemberProxy: RoomMemberProxyProtocol {
+    private let member: RoomMemberProtocol
+
+    init(member: RoomMemberProtocol) {
+        self.member = member
+    }
+
+    var userID: String {
+        member.userId()
+    }
+
+    var displayName: String? {
+        member.displayName()
+    }
+
+    var avatarURL: URL? {
+        member.avatarUrl().flatMap(URL.init(string:))
+    }
+
+    var membership: MembershipState {
+        member.membership()
+    }
+
+    var isNameAmbiguous: Bool {
+        member.isNameAmbiguous()
+    }
+
+    var powerLevel: Int {
+        Int(member.powerLevel())
+    }
+
+    var normalizedPowerLevel: Int {
+        Int(member.normalizedPowerLevel())
+    }
+}

ElementX/Sources/Services/Room/RoomMember/RoomMemberProxyProtocol.swift

@@ -0,0 +1,29 @@
+//
+// Copyright 2022 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+import MatrixRustSDK
+
+// sourcery: AutoMockable
+protocol RoomMemberProxyProtocol {
+    var userID: String { get }
+    var displayName: String? { get }
+    var avatarURL: URL? { get }
+    var membership: MembershipState { get }
+    var isNameAmbiguous: Bool { get }
+    var powerLevel: Int { get }
+    var normalizedPowerLevel: Int { get }
+}

ElementX/Sources/Services/Room/RoomMemberProxy.swift

@@ -1,93 +0,0 @@
-//
-// Copyright 2022 New Vector Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-import Foundation
-import MatrixRustSDK
-
-struct RoomMemberProxy {
-    private let member: RoomMember
-
-    init(with member: RoomMember) {
-        self.member = member
-    }
-
-    var userId: String {
-        member.userId
-    }
-
-    var displayName: String? {
-        member.displayName
-    }
-
-    var avatarURL: URL? {
-        member.avatarUrl.flatMap(URL.init(string:))
-    }
-
-    var membership: MembershipState {
-        member.membership
-    }
-
-    var isNameAmbiguous: Bool {
-        member.isNameAmbiguous
-    }
-
-    var powerLevel: Int64 {
-        member.powerLevel
-    }
-
-    var normalizedPowerLevel: Int64 {
-        member.normalizedPowerLevel
-    }
-}
-
-extension RoomMemberProxy: Identifiable {
-    var id: String {
-        userId
-    }
-}
-
-// Mocks
-extension RoomMemberProxy {
-    static var mockAlice: RoomMemberProxy {
-        RoomMemberProxy(with: .init(userId: "alice@matrix.org",
-                                    displayName: "Alice",
-                                    avatarUrl: nil,
-                                    membership: .join,
-                                    isNameAmbiguous: false,
-                                    powerLevel: 50,
-                                    normalizedPowerLevel: 50))
-    }
-    
-    static var mockBob: RoomMemberProxy {
-        RoomMemberProxy(with: .init(userId: "bob@matrix.org",
-                                    displayName: "Bob",
-                                    avatarUrl: nil,
-                                    membership: .join,
-                                    isNameAmbiguous: false,
-                                    powerLevel: 50,
-                                    normalizedPowerLevel: 50))
-    }
-    
-    static var mockCharlie: RoomMemberProxy {
-        RoomMemberProxy(with: .init(userId: "charlie@matrix.org",
-                                    displayName: "Charlie",
-                                    avatarUrl: nil,
-                                    membership: .join,
-                                    isNameAmbiguous: false,
-                                    powerLevel: 50,
-                                    normalizedPowerLevel: 50))
-    }
-}

ElementX/Sources/Services/Room/RoomProxy.swift

@@ -271,11 +271,11 @@ class RoomProxy: RoomProxyProtocol {
         }
     }
     
-    func members() async -> Result<[RoomMemberProxy], RoomProxyError> {
+    func members() async -> Result<[RoomMemberProxyProtocol], RoomProxyError> {
         await Task.dispatch(on: .global()) {
             do {
                 let members = try self.room.members()
-                return .success(members.map { RoomMemberProxy(with: $0) })
+                return .success(members.map { RoomMemberProxy(member: $0) })
             } catch {
                 return .failure(.failedRetrievingMembers)
             }

ElementX/Sources/Services/Room/RoomProxyProtocol.swift

@@ -76,7 +76,7 @@ protocol RoomProxyProtocol {
 
     func reportContent(_ eventID: String, reason: String?) async -> Result<Void, RoomProxyError>
 
-    func members() async -> Result<[RoomMemberProxy], RoomProxyError>
+    func members() async -> Result<[RoomMemberProxyProtocol], RoomProxyError>
     
     func retryDecryption(for sessionID: String) async
 

ElementX/Sources/UITests/UITestsAppCoordinator.swift

@@ -270,10 +270,11 @@ class MockScreen: Identifiable {
             return navigationSplitCoordinator
         case .roomDetailsScreen:
             let navigationStackCoordinator = NavigationStackCoordinator()
+            let members: [RoomMemberProxyMock] = [.mockAlice, .mockBob, .mockCharlie]
             let roomProxy = RoomProxyMock(with: .init(id: "MockRoomIdentifier",
                                                       displayName: "Room",
                                                       isEncrypted: true,
-                                                      members: [.mockAlice, .mockBob, .mockCharlie]))
+                                                      members: members))
             let coordinator = RoomDetailsCoordinator(parameters: .init(navigationStackCoordinator: navigationStackCoordinator,
                                                                        roomProxy: roomProxy,
                                                                        mediaProvider: MockMediaProvider()))
@@ -281,13 +282,14 @@ class MockScreen: Identifiable {
             return navigationStackCoordinator
         case .roomDetailsScreenWithRoomAvatar:
             let navigationStackCoordinator = NavigationStackCoordinator()
+            let members: [RoomMemberProxyMock] = [.mockAlice, .mockBob, .mockCharlie]
             let roomProxy = RoomProxyMock(with: .init(id: "MockRoomIdentifier",
                                                       displayName: "Room",
                                                       topic: "Bacon ipsum dolor amet commodo incididunt ribeye dolore cupidatat short ribs.",
                                                       avatarURL: URL.picturesDirectory,
                                                       isEncrypted: true,
                                                       canonicalAlias: "#mock:room.org",
-                                                      members: [.mockAlice, .mockBob, .mockCharlie]))
+                                                      members: members))
             let coordinator = RoomDetailsCoordinator(parameters: .init(navigationStackCoordinator: navigationStackCoordinator,
                                                                        roomProxy: roomProxy,
                                                                        mediaProvider: MockMediaProvider()))
@@ -295,8 +297,9 @@ class MockScreen: Identifiable {
             return navigationStackCoordinator
         case .roomMemberDetailsScreen:
             let navigationStackCoordinator = NavigationStackCoordinator()
+            let members: [RoomMemberProxyMock] = [.mockAlice, .mockBob, .mockCharlie]
             let coordinator = RoomMemberDetailsCoordinator(parameters: .init(mediaProvider: MockMediaProvider(),
-                                                                             members: [.mockAlice, .mockBob, .mockCharlie]))
+                                                                             members: members))
             navigationStackCoordinator.setRootCoordinator(coordinator)
             return navigationStackCoordinator
         case .reportContent:

UnitTests/Sources/MediaProvider/MediaLoaderTests.swift

@@ -118,7 +118,23 @@ private class MockMediaLoadingClient: ClientProtocol {
     func startSync(timelineLimit: UInt16?) { }
     
     func createRoom(request: MatrixRustSDK.CreateRoomParameters) throws -> String { fatalError() }
-    
+
+    func getDmRoom(userId: String) throws -> MatrixRustSDK.Room? {
+        fatalError()
+    }
+
+    func ignoreUser(userId: String) throws {
+        fatalError()
+    }
+
+    func searchUsers(searchTerm: String, limit: UInt64) throws -> MatrixRustSDK.SearchUsersResults {
+        fatalError()
+    }
+
+    func unignoreUser(userId: String) throws {
+        fatalError()
+    }
+
     // swiftlint:disable:next function_parameter_count
     func setPusher(identifiers: MatrixRustSDK.PusherIdentifiers,
                    kind: MatrixRustSDK.PusherKind,

UnitTests/Sources/RoomDetailsViewModelTests.swift

@@ -30,7 +30,8 @@ class RoomDetailsScreenViewModelTests: XCTestCase {
     }
 
     func testLeaveRoomTappedWhenPublic() async {
-        roomProxyMock = RoomProxyMock(with: .init(displayName: "Test", isPublic: true, members: [.mockBob, .mockAlice]))
+        let mockedMembers: [RoomMemberProxyMock] = [.mockBob, .mockAlice]
+        roomProxyMock = RoomProxyMock(with: .init(displayName: "Test", isPublic: true, members: mockedMembers))
         viewModel = RoomDetailsViewModel(roomProxy: roomProxyMock, mediaProvider: MockMediaProvider())
         context.send(viewAction: .processTapLeave)
         await Task.yield()
@@ -39,7 +40,8 @@ class RoomDetailsScreenViewModelTests: XCTestCase {
     }
 
     func testLeavRoomTappedWhenRoomNotPublic() async {
-        roomProxyMock = RoomProxyMock(with: .init(displayName: "Test", isPublic: false, members: [.mockBob, .mockAlice]))
+        let mockedMembers: [RoomMemberProxyMock] = [.mockBob, .mockAlice]
+        roomProxyMock = RoomProxyMock(with: .init(displayName: "Test", isPublic: false, members: mockedMembers))
         viewModel = RoomDetailsViewModel(roomProxy: roomProxyMock, mediaProvider: MockMediaProvider())
         context.send(viewAction: .processTapLeave)
         await Task.yield()

project.yml

@@ -42,7 +42,7 @@ include:
 packages:
   MatrixRustSDK:
     url: https://github.com/matrix-org/matrix-rust-components-swift
-    exactVersion: 1.0.47-alpha
+    exactVersion: 1.0.48-alpha
     # path: ../matrix-rust-sdk
   DesignKit:
     path: DesignKit