damus

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

Router.swift (11587B)

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