damus

nostr ios client
git clone git://jb55.com/damus
Log | Files | Refs | README | LICENSE

Router.swift (9501B)

      1 //
      2 //  Router.swift
      3 //  damus
      4 //
      5 //  Created by Scott Penrose on 5/7/23.
      6 //
      7 
      8 import SwiftUI
      9 
     10 enum Route: Hashable {
     11     case ProfileByKey(pubkey: Pubkey)
     12     case Profile(profile: ProfileModel, followers: FollowersModel)
     13     case Followers(followers: FollowersModel)
     14     case Relay(relay: RelayURL, showActionButtons: Binding<Bool>)
     15     case RelayDetail(relay: RelayURL, metadata: RelayMetadata?)
     16     case Following(following: FollowingModel)
     17     case MuteList
     18     case RelayConfig
     19     case Script(script: ScriptModel)
     20     case Bookmarks
     21     case Config
     22     case EditMetadata
     23     case DMChat(dms: DirectMessageModel)
     24     case UserRelays(relays: [RelayURL])
     25     case KeySettings(keypair: Keypair)
     26     case AppearanceSettings(settings: UserSettingsStore)
     27     case NotificationSettings(settings: UserSettingsStore)
     28     case ZapSettings(settings: UserSettingsStore)
     29     case TranslationSettings(settings: UserSettingsStore)
     30     case ReactionsSettings(settings: UserSettingsStore)
     31     case SearchSettings(settings: UserSettingsStore)
     32     case DeveloperSettings(settings: UserSettingsStore)
     33     case FirstAidSettings(settings: UserSettingsStore)
     34     case Thread(thread: ThreadModel)
     35     case Reposts(reposts: EventsModel)
     36     case QuoteReposts(quotes: EventsModel)
     37     case Reactions(reactions: EventsModel)
     38     case Zaps(target: ZapTarget)
     39     case Search(search: SearchModel)
     40     case EULA
     41     case Login
     42     case CreateAccount
     43     case SaveKeys(account: CreateAccountModel)
     44     case Wallet(wallet: WalletModel)
     45     case WalletScanner(result: Binding<WalletScanResult>)
     46     case FollowersYouKnow(friendedFollowers: [Pubkey], followers: FollowersModel)
     47 
     48     @ViewBuilder
     49     func view(navigationCoordinator: NavigationCoordinator, damusState: DamusState) -> some View {
     50         switch self {
     51         case .ProfileByKey(let pubkey):
     52             ProfileView(damus_state: damusState, pubkey: pubkey)
     53         case .Profile(let profile, let followers):
     54             ProfileView(damus_state: damusState, profile: profile, followers: followers)
     55         case .Followers(let followers):
     56             FollowersView(damus_state: damusState, followers: followers)
     57         case .Relay(let relay, let showActionButtons):
     58             RelayView(state: damusState, relay: relay, showActionButtons: showActionButtons, recommended: false)
     59         case .RelayDetail(let relay, let metadata):
     60             RelayDetailView(state: damusState, relay: relay, nip11: metadata)
     61         case .Following(let following):
     62             FollowingView(damus_state: damusState, following: following)
     63         case .MuteList:
     64             MutelistView(damus_state: damusState)
     65         case .RelayConfig:
     66             RelayConfigView(state: damusState)
     67         case .Bookmarks:
     68             BookmarksView(state: damusState)
     69         case .Config:
     70             ConfigView(state: damusState)
     71         case .EditMetadata:
     72             EditMetadataView(damus_state: damusState)
     73         case .DMChat(let dms):
     74             DMChatView(damus_state: damusState, dms: dms)
     75         case .UserRelays(let relays):
     76             UserRelaysView(state: damusState, relays: relays)
     77         case .KeySettings(let keypair):
     78             KeySettingsView(keypair: keypair)
     79         case .AppearanceSettings(let settings):
     80             AppearanceSettingsView(damus_state: damusState, settings: settings)
     81         case .NotificationSettings(let settings):
     82             NotificationSettingsView(settings: settings)
     83         case .ZapSettings(let settings):
     84             ZapSettingsView(settings: settings)
     85         case .TranslationSettings(let settings):
     86             TranslationSettingsView(settings: settings, damus_state: damusState)
     87         case .ReactionsSettings(let settings):
     88             ReactionsSettingsView(settings: settings)
     89         case .SearchSettings(let settings):
     90             SearchSettingsView(settings: settings)
     91         case .DeveloperSettings(let settings):
     92             DeveloperSettingsView(settings: settings)
     93         case .FirstAidSettings(settings: let settings):
     94             FirstAidSettingsView(damus_state: damusState, settings: settings)
     95         case .Thread(let thread):
     96             ThreadView(state: damusState, thread: thread)
     97         case .Reposts(let reposts):
     98             RepostsView(damus_state: damusState, model: reposts)
     99         case .QuoteReposts(let quote_reposts):
    100             QuoteRepostsView(damus_state: damusState, model: quote_reposts)
    101         case .Reactions(let reactions):
    102             ReactionsView(damus_state: damusState, model: reactions)
    103         case .Zaps(let target):
    104             ZapsView(state: damusState, target: target)
    105         case .Search(let search):
    106             SearchView(appstate: damusState, search: search)
    107         case .EULA:
    108             EULAView(nav: navigationCoordinator)
    109         case .Login:
    110             LoginView(nav: navigationCoordinator)
    111         case .CreateAccount:
    112             CreateAccountView(nav: navigationCoordinator)
    113         case .SaveKeys(let account):
    114             SaveKeysView(account: account)
    115         case .Wallet(let walletModel):
    116             WalletView(damus_state: damusState, model: walletModel)
    117         case .WalletScanner(let walletScanResult):
    118             WalletScannerView(result: walletScanResult)
    119         case .FollowersYouKnow(let friendedFollowers, let followers):
    120             FollowersYouKnowView(damus_state: damusState, friended_followers: friendedFollowers, followers: followers)
    121         case .Script(let load_model):
    122             LoadScript(pool: damusState.pool, model: load_model)
    123         }
    124     }
    125 
    126     static func == (lhs: Route, rhs: Route) -> Bool {
    127         return lhs.hashValue == rhs.hashValue
    128     }
    129 
    130     func hash(into hasher: inout Hasher) {
    131         switch self {
    132         case .ProfileByKey(let pubkey):
    133             hasher.combine("profilebykey")
    134             hasher.combine(pubkey.id.bytes)
    135         case .Profile(let profile, _):
    136             hasher.combine("profile")
    137             hasher.combine(profile.pubkey.id.bytes)
    138         case .Followers:
    139             hasher.combine("followers")
    140         case .Relay(let relay, _):
    141             hasher.combine("relay")
    142             hasher.combine(relay)
    143         case .RelayDetail(let relay, _):
    144             hasher.combine("relayDetail")
    145             hasher.combine(relay)
    146         case .Following:
    147             hasher.combine("following")
    148         case .MuteList:
    149             hasher.combine("muteList")
    150         case .RelayConfig:
    151             hasher.combine("relayConfig")
    152         case .Bookmarks:
    153             hasher.combine("bookmarks")
    154         case .Config:
    155             hasher.combine("config")
    156         case .EditMetadata:
    157             hasher.combine("editMetadata")
    158         case .DMChat(let dms):
    159             hasher.combine("dms")
    160             hasher.combine(dms.our_pubkey)
    161         case .UserRelays(let relays):
    162             hasher.combine("userRelays")
    163             hasher.combine(relays)
    164         case .KeySettings(let keypair):
    165             hasher.combine("keySettings")
    166             hasher.combine(keypair.pubkey)
    167         case .AppearanceSettings:
    168             hasher.combine("appearanceSettings")
    169         case .NotificationSettings:
    170             hasher.combine("notificationSettings")
    171         case .ZapSettings:
    172             hasher.combine("zapSettings")
    173         case .TranslationSettings:
    174             hasher.combine("translationSettings")
    175         case .ReactionsSettings:
    176             hasher.combine("reactionsSettings")
    177         case .SearchSettings:
    178             hasher.combine("searchSettings")
    179         case .DeveloperSettings:
    180             hasher.combine("developerSettings")
    181         case .FirstAidSettings:
    182             hasher.combine("firstAidSettings")
    183         case .Thread(let threadModel):
    184             hasher.combine("thread")
    185             hasher.combine(threadModel.event.id)
    186         case .Reposts(let reposts):
    187             hasher.combine("reposts")
    188             hasher.combine(reposts.target)
    189         case .QuoteReposts(let evs_model):
    190             hasher.combine("quote_reposts")
    191             hasher.combine(evs_model.events.events.count)
    192         case .Zaps(let target):
    193             hasher.combine("zaps")
    194             hasher.combine(target.id)
    195             hasher.combine(target.pubkey)
    196         case .Reactions(let reactions):
    197             hasher.combine("reactions")
    198             hasher.combine(reactions.target)
    199         case .Search(let search):
    200             hasher.combine("search")
    201             hasher.combine(search.search)
    202         case .EULA:
    203             hasher.combine("eula")
    204         case .Login:
    205             hasher.combine("login")
    206         case .CreateAccount:
    207             hasher.combine("createAccount")
    208         case .SaveKeys(let account):
    209             hasher.combine("saveKeys")
    210             hasher.combine(account.pubkey)
    211         case .Wallet:
    212             hasher.combine("wallet")
    213         case .WalletScanner:
    214             hasher.combine("walletScanner")
    215         case .FollowersYouKnow(let friendedFollowers, let followers):
    216             hasher.combine("followersYouKnow")
    217             hasher.combine(friendedFollowers)
    218             hasher.combine(followers.sub_id)
    219         case .Script(let model):
    220             hasher.combine("script")
    221             hasher.combine(model.data.count)
    222         }
    223     }
    224 }
    225 
    226 class NavigationCoordinator: ObservableObject {
    227     @Published var path = [Route]()
    228 
    229     func push(route: Route) {
    230         guard route != path.last else {
    231             return
    232         }
    233         path.append(route)
    234     }
    235     
    236     func isAtRoot() -> Bool {
    237         return path.count == 0
    238     }
    239 
    240     func popToRoot() {
    241         path = []
    242     }
    243 }