damus

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

Router.swift (10254B)

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