Fix bug where profile view was showing more than just the notes and replies on the notes / notes & replies tabs

Changelog-Fixed: Fix bug where profile view was showing more than just the notes and replies on the notes / notes & replies tabs
Fixes: caa4bfe864 ("Fix bug where profile view was showing more than just the notes and replies on the notes / notes & replies tabs")
Signed-off-by: Terry Yiu <git@tyiu.xyz>

.github/ISSUE_TEMPLATE/app_release.md

@@ -0,0 +1,52 @@
+---
+name: App release process
+about: Begin preparing for a new app release
+title: 'Release: '
+labels: release-tasks
+assignees: ''
+
+---
+
+A new version release. Please attempt to follow the release process steps below in the order they are shown.
+
+## TestFlight release candidates
+
+### Release candidate 1
+
+**Version:** _[Enter full build information for the release candidate, including major and minor version number, build number, and commit hash]_
+
+1. [ ] Merge in all needed changes to `master`
+2. [ ] Check CI, make sure it is passing
+3. [ ] Prepare preliminary changelog as a draft PR: _[Enter PR link to changelog here]_
+4. [ ] Make a _release_ build and submit to the internal TestFlight group via our new Release candidate workflow in Xcode Cloud.
+5. [ ] Prepare short screencast style video with main changes for the announcement
+6. [ ] Publish release build to these TestFlight groups:
+    - [ ] Alpha testers group
+    - [ ] Translators group
+    - [ ] Purple group
+7. [ ] Publish announcement on Nostr
+
+
+_[Duplicate this release candidate section if there is more than one release candidate]_
+
+
+## App Store release
+
+1. [ ] Release candidate checks:
+    - [ ] Release candidate has been on Purple TestFlight for at least one week
+    - [ ] No blocker issues came from feedback from Purple users (double-check)
+    - [ ] Check with stakeholders
+    - [ ] Check with developers & product for any release showstoppers (e.g., critical newfound bugs)
+2. [ ] Thorough check on release notes
+3. [ ] Submit to App Store review (with manual publishing setting enabled)
+4. [ ] Get App Store approval from Apple
+5. [ ] Prepare announcement
+7. [ ] Publish on the App Store and make announcement
+8. [ ] Publish changelog and tag commit hash corresponding to the release
+9. [ ] Perform a version bump on the repository, in preparation for the next release
+
+
+## Notes/others
+
+_Enter any relevant notes here_
+

.github/pull_request_template.md

@@ -0,0 +1,37 @@
+## Summary
+
+_[Please provide a summary of the changes in this PR.]_
+
+## Checklist
+
+- [ ] I have read (or I am familiar with) the [Contribution Guidelines](../docs/CONTRIBUTING.md)
+- [ ] I have tested the changes in this PR
+- [ ] I have opened or referred to an existing github issue related to this change.
+- [ ] My PR is either small, or I have split it into smaller logical commits that are easier to review
+- [ ] I have added the signoff line to all my commits. See [Signing off your work](../docs/CONTRIBUTING.md#sign-your-work---the-developers-certificate-of-origin)
+- [ ] I have added appropriate changelog entries for the changes in this PR. See [Adding changelog entries](../docs/CONTRIBUTING.md#add-changelog-changed-changelog-fixed-etc)
+    - [ ] I do not need to add a changelog entry. Reason: _[Please provide a reason]_
+- [ ] I have added appropriate `Closes:` or `Fixes:` tags in the commit messages wherever applicable, or made sure those are not needed. See [Submitting patches](https://github.com/damus-io/damus/blob/master/docs/CONTRIBUTING.md#submitting-patches)
+
+## Test report
+
+_Please provide a test report for the changes in this PR. You can use the template below, but feel free to modify it as needed._
+
+**Device:** _[Please specify the device you used for testing]_
+
+**iOS:** _[Please specify the iOS version you used for testing]_
+
+**Damus:** _[Please specify the Damus version or commit hash you used for testing]_
+
+**Setup:** _[Please provide a brief description of the setup you used for testing, if applicable]_
+
+**Steps:** _[Please provide a list of steps you took to test the changes in this PR]_
+
+**Results:**
+- [ ] PASS
+- [ ] Partial PASS
+  - Details: _[Please provide details of the partial pass]_
+
+## Other notes
+
+_[Please provide any other information that you think is relevant to this PR.]_

ACKNOWLEDGEMENTS.md

@@ -0,0 +1,5 @@
+### Acknowledgements and licenses
+
+1. This product contains code derived from [Nostr SDK iOS](https://github.com/nostr-sdk/nostr-sdk-ios). [License](https://github.com/nostr-sdk/nostr-sdk-ios/blob/40df800c6749d7ce0b6fd7328e76cbc0dc71c87b/LICENSE)
+2. This product includes software developed by the "Marcin Krzyzanowski" (http://krzyzanowskim.com/). [License](https://github.com/krzyzanowskim/CryptoSwift/blob/e74bbbfbef939224b242ae7c342a90e60b88b5ce/LICENSE)
+

CHANGELOG.md

@@ -1,3 +1,236 @@
+## [1.12.3] - 2025-02-06
+
+### Added
+
+- Purple members who have been active for more than a year now get a special badge (Daniel D’Aquino)
+
+### Changed
+
+- Improved clarity of the mute button to indicate it can be used for blocking a user (Daniel D’Aquino)
+- Made the microphone access request message more clear to users (Daniel D’Aquino)
+
+[v1.12.3]: https://github.com/damus-io/damus/releases/tag/v1.12.3
+
+
+## [1.12](https://github.com/damus-io/damus/releases/tag/v1.12) - 2024-12-20
+
+### Added
+
+- Render Gif and video files while composing posts (Swift Coder)
+- Add profile info text in stretchable banner with follow button (Swift Coder)
+- Paste Gif image similar to jpeg and png files (Swift Coder)
+
+
+### Changed
+
+- Improved UX around the label for searching words (Daniel D’Aquino)
+- Improved accessibility support on some elements (Daniel D’Aquino)
+
+
+### Fixed
+
+- Fixed issue where the "next" button would appear hidden and hard to click on the create account view (Daniel D’Aquino)
+- Fix non scrollable wallet screen (Swift Coder)
+- Fixed suggested users category titles to be localizable (Terry Yiu)
+- Fixed GradientFollowButton to have consistent width and autoscale text limited to 1 line (Terry Yiu)
+- Fixed right-to-left localization issues (Terry Yiu)
+- Fixed AddMuteItemView to trim leading and trailing whitespaces from mute text and disallow adding text with only whitespaces (Terry Yiu)
+- Fixed SideMenuView text to autoscale and limit to 1 line (Terry Yiu)
+- Fixed an issue where a profile would need to be input twice in the search to be found (Daniel D’Aquino)
+- Fixed non-breaking spaces in localized strings (Terry Yiu)
+- Fixed localization issue on Add mute item button (Terry Yiu)
+- Replace non-breaking spaces with regular spaces as Apple's NSLocalizedString macro does not seem to work with it (Terry Yiu)
+- Fixed localization issues in RelayConfigView (Terry Yiu)
+- Fix duplicate uploads (Swift Coder)
+- Remove duplicate pubkey from Follow Suggestion list (Swift Coder)
+- Fix Page control indicator (Swift Coder)
+- Fix damus sharing issues (Swift Coder)
+- Fixed issue where banner edit button is unclickable (Daniel D’Aquino)
+- Handle empty notification pages by displaying suitable text (Swift Coder)
+
+[v1.12](https://github.com/damus-io/damus/releases/tag/v1.12): [https://github.com/damus-io/damus/releases/tag/v1.12]
+
+
+## [v1.11(10)](https://github.com/damus-io/damus/releases/tag/v1.11-10) - 2024-11-18
+
+### Added
+
+- Add Damus Share Feature (Swift)
+- Added new easy to use video controls for full screen video (Daniel D’Aquino)
+- Add Edit, Share, and Tap-gesture in Profile pic image viewer (Swift Coder)
+- Disappearing header, tabbar, and post button on scroll (ericholguin)
+- Add Apple translation popovers for notes for iOS 17.4+ and macOS 14.4+ (Terry Yiu)
+- Added NDB search functionality to the universe view (ericholguin)
+- Added mute button to ProfileActionSheet (chungwwei)
+- Added mute action to selected text menu (ericholguin)
+- Added support for pasting images from the clipboard to the post composer (Swift Coder)
+
+### Changed
+
+- Improved image carousel image fill behavior (Daniel D’Aquino)
+- Improved video syncing and bandwidth usage when switching between timeline video and full screen mode (Daniel D’Aquino)
+- Swipe to dismiss on full screen carousel now shows an opacity effect for improved UX (Daniel D’Aquino)
+- Removed event contents from full screen media carousel for cleaner view (Daniel D’Aquino)
+- Add share button for images on full screen image carousel view (Swift)
+- Changed boldness of font in side menu labels. (ericholguin)
+- Changed search notes button with searched keyword (ericholguin)
+- Changed opacity of tabbar and post button (ericholguin)
+- Allow multiple images to be uploaded at the same time (swiftcoder) (William Casarin)
+- Changed side menu design (ericholguin)
+- Truncate fulltext search results (William Casarin)
+- Expanded profile search results to 128 (William Casarin)
+- Expand nostrdb text search results to 128 items (William Casarin)
+- Use LazyVStack in text search results (William Casarin)
+
+### Fixed
+
+- Fixed missing tab bar on navigation (Swift Coder)
+- Fixed some issues where QR code would not work, and improved UX (Daniel D’Aquino)
+- Fixed iOS 18 gesture issues that would take user to the thread view when clicking on a video or unmuting it (Daniel D’Aquino)
+- Fixed several issues that would cause video to automatically play or pause incorrectly (Daniel D’Aquino)
+- Fixed issue where full screen video would disappear when going to landscape mode (Daniel D’Aquino)
+- Fixed portrait video size on full screen carousel (Daniel D’Aquino)
+- Fix avatar image on qrcode view (Swift Coder)
+- Fix banner image upload (Swift Coder)
+- Fix dismiss button visibility (Swift Coder)
+- Fix quote repost counting (William Casarin)
+- Fixed overlapping text in Universe View (ericholguin)
+- Fixed localization issues and exported strings (Terry Yiu)
+- Fix sensitive long-press gesture on event chat bubble in iOS 18 (Daniel D’Aquino)
+- Fixed bottom padding for tabbar (ericholguin)
+- Fixed localization build failures (Terry Yiu)
+- Fixed back nav button placement in profile edit view (ericholguin)
+- Friend profiles will now more likely show up in profile search (William Casarin)
+- Fix broken QR code scanner and fix landscape mode (Terry Yiu)
+
+[1.11(10)](https://github.com/damus-io/damus/releases/tag/v1.11-10): https://github.com/damus-io/damus/releases/tag/v1.11-10
+
+## [1.10.1] - 2024-09-22
+
+### Added
+
+- Push notification support (Daniel D’Aquino)
+- Added profile edit safe guards (Eric Holguin)
+- Tor relay icon (ericholguin)
+- Add highlighter for web pages (Daniel D’Aquino)
+- Add support for adding comments when creating a highlight (Daniel D’Aquino)
+- Add support for rendering highlights with comments (Daniel D’Aquino)
+- Ability to create highlights (ericholguin)
+- Highlights (NIP-84) (ericholguin)
+- Revamp emoji picker to be less error-prone and add search, frequently used, and multiple skin tone support capabilities (Terry Yiu)
+
+
+### Changed
+
+- Improve notification view filtering UX (Daniel D’Aquino)
+- Improve visibility of friends filter button (Daniel D’Aquino)
+- Changed the default banner from ostriches to damoose (Eric Holguin)
+- Changed image and banner url text fields to new sheet view (Eric Holguin)
+- Onboarding design (ericholguin)
+
+
+### Fixed
+
+- Fix items that became unclickable on iOS 18 (Daniel D’Aquino)
+- Fix many reconnection issues (William Casarin)
+- Fixed issue where theme would be changed to black and can't be switched back on iOS 18 (cr0bar)
+- Fixed some scenarios where the contact list would never be saved locally and cause issues when switching relays. (Daniel D’Aquino)
+- Fix albyhub zaps not appearing (William Casarin)
+- Fix inadvertent escape from mention suggestion menu when typing a space character (Daniel D’Aquino)
+- Fix profile view toolbar alignment bug in iOS 18 (Terry Yiu)
+- Create Account model now uses correct metadata (ericholguin)
+- Restore localization for custom tabs (William Casarin)
+- Fix iOS 18 reflection runtime error for custom picker (William Casarin)
+
+
+[1.10.1]: https://github.com/damus-io/damus/releases/tag/v1.10.1
+
+
+## [1.9.1 (4)] - 2024-08-13
+
+### Fixed
+
+- Fix crash when viewing notes with invalid image dimension metadata (Daniel D’Aquino)
+
+[1.9.1 (4)]: https://github.com/damus-io/damus/releases/tag/v1.9.1-4
+
+
+## [1.9 (14)] - 2024-07-14
+
+### Added
+
+- Completely new threads experience that is easier and more pleasant to use (Daniel D’Aquino)
+- Add emoji search to emoji picker (Terry Yiu)
+
+
+### Changed
+
+- Added first aid contact damus support email (alltheseas)
+- Disable mutiny wallet button (William Casarin)
+- Make friends show up first when searching for profiles (Terry Yiu)
+
+
+### Fixed
+
+- Fix crash on profile page when there are profile updates (William Casarin)
+- Fix crash when adding duplicate mute items (William Casarin)
+- Fix pretty bad crash when building flatbuffer profiles (William Casarin)
+- Fix reactions view to not show reactions from replies on parent note (Terry Yiu)
+- Fix missing Mute button in profile view menu (Terry Yiu)
+- Fixed wallet not disconnecting when a user logs out (ericholguin)
+- Fix stale feed issue when follow list is too big (Daniel D’Aquino)
+
+[1.9 (14)]: https://github.com/damus-io/damus/releases/tag/v1.9-14
+
+## [1.8] - 2024-05-11
+
+### Added
+
+- Added nip10 marker replies (William Casarin)
+- Add marker nip10 support when reading notes (William Casarin)
+- Added title image and tags to longform events (ericholguin)
+- Add First Aid solution for users who do not have a contact list created for their account (Daniel D’Aquino)
+- Relay fees metadata (ericholguin)
+- Added callbackuri for a better ux when connecting mutiny wallet nwc (ericholguin)
+- Add event content preview to the full screen carousel (Daniel D’Aquino)
+- Show list of quoted reposts in threads (William Casarin)
+- Proxy Tags are now viewable on Selected Events (ericholguin)
+- Connect to Mutiny Wallet Button (ericholguin)
+- Add ability to mute words, add new mutelist interface (Charlie) (William Casarin)
+- Add ability to mute hashtag from SearchView (Charlie Fish)
+
+
+### Changed
+
+- Change reactions to use a native looking emoji picker (Terry Yiu)
+- Relay detail design (ericholguin)
+- Updated Zeus logo (ericholguin)
+- Improve UX around video playback (Daniel D’Aquino)
+- Moved paste nwc button to main wallet view (ericholguin)
+- Errors with an NWC will show as an alert (ericholguin)
+- Relay config view user interface (ericholguin)
+- Always strip GPS data from images (kernelkind)
+
+
+### Fixed
+
+- Fix thread bug where a quote isn't picked up as a reply (William Casarin)
+- Fixed threads not loading sometimes (William Casarin)
+- Fixed issue where some replies were including the q tag (William Casarin)
+- Fixed issue where timeline was scrolling when it isn't supposed to (William Casarin)
+- Fix issue where bootstrap relays would inadvertently be added to the user's list on connectivity issues (Daniel D’Aquino)
+- Fix broken GIF uploads (Daniel D’Aquino)
+- Fix ghost notifications caused by Purple impending expiration notifications (Daniel D’Aquino)
+- Improve reliability of contact list creation during onboarding (Daniel D’Aquino)
+- Fix emoji reactions being cut off (ericholguin)
+- Fix image indicators to limit number of dots to not spill screen beyond visible margins (ericholguin)
+- Fix bug that would cause connection issues with relays defined with a trailing slash URL, and an inability to delete them. (Daniel D’Aquino)
+- Issue where NWC Scanner view would not dismiss after a failed scan/paste (ericholguin)
+
+
+
+[1.8]: https://github.com/damus-io/damus/releases/tag/v1.8
+
 ## [1.7-rc2] - 2024-02-28
 
 ### Added

DamusNotificationService/DamusNotificationService.entitlements

@@ -2,6 +2,8 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>com.apple.developer.kernel.extended-virtual-addressing</key>
+	<true/>
 	<key>com.apple.security.app-sandbox</key>
 	<true/>
 	<key>com.apple.security.application-groups</key>
@@ -10,5 +12,9 @@
 	</array>
 	<key>com.apple.security.network.client</key>
 	<true/>
+	<key>keychain-access-groups</key>
+	<array>
+		<string>$(AppIdentifierPrefix)com.jb55.damus2</string>
+	</array>
 </dict>
 </plist>

DamusNotificationService/NotificationFormatter.swift

@@ -55,6 +55,9 @@ struct NotificationFormatter {
         var identifier = ""
         
         switch notify.type {
+            case .tagged:
+                title = String(format: NSLocalizedString("Tagged by %@", comment: "Tagged by heading in local notification"), displayName)
+                identifier = "myMentionNotification"
             case .mention:
                 title = String(format: NSLocalizedString("Mentioned by %@", comment: "Mentioned by heading in local notification"), displayName)
                 identifier = "myMentionNotification"
@@ -70,6 +73,9 @@ struct NotificationFormatter {
             case .zap, .profile_zap:
                 // not handled here. Try `format_message(displayName: String, notify: LocalNotification, state: HeadlessDamusState) async -> (content: UNMutableNotificationContent, identifier: String)?`
                 return nil
+            case .reply:
+                title = String(format: NSLocalizedString("%@ replied to your note", comment: "Heading for local notification indicating a new reply"), displayName)
+                identifier = "myReplyNotification"
         }
         content.title = title
         content.body = notify.content
@@ -87,10 +93,11 @@ struct NotificationFormatter {
         
         // If it does not work, try async formatting methods
         let content = UNMutableNotificationContent()
-        
+
         switch notify.type {
             case .zap, .profile_zap:
                 guard let zap = await get_zap(from: notify.event, state: state) else {
+                    Log.debug("format_message: async get_zap failed", for: .push_notifications)
                     return nil
                 }
                 content.title = Self.zap_notification_title(zap)

DamusNotificationService/NotificationService.swift

@@ -27,9 +27,9 @@ class NotificationService: UNNotificationServiceExtension {
         // Log that we got a push notification
         Log.debug("Got nostr event push notification from pubkey %s", for: .push_notifications, nostr_event.pubkey.hex())
         
-        guard let state = NotificationExtensionState(),
-              let display_name = state.ndb.lookup_profile(nostr_event.pubkey)?.unsafeUnownedValue?.profile?.display_name  // We are not holding the txn here.
-        else {
+        guard let state = NotificationExtensionState() else {
+            Log.debug("Failed to open nostrdb", for: .push_notifications)
+
             // Something failed to initialize so let's go for the next best thing
             guard let improved_content = NotificationFormatter.shared.format_message(event: nostr_event) else {
                 // We cannot format this nostr event. Suppress notification.
@@ -39,7 +39,11 @@ class NotificationService: UNNotificationServiceExtension {
             contentHandler(improved_content)
             return
         }
-        
+
+        let txn = state.ndb.lookup_profile(nostr_event.pubkey)
+        let profile = txn?.unsafeUnownedValue?.profile
+        let name = Profile.displayName(profile: profile, pubkey: nostr_event.pubkey).displayName
+
         // Don't show notification details that match mute list.
         // TODO: Remove this code block once we get notification suppression entitlement from Apple. It will be covered by the `guard should_display_notification` block
         if state.mutelist_manager.is_event_muted(nostr_event) {
@@ -54,6 +58,7 @@ class NotificationService: UNNotificationServiceExtension {
         }
         
         guard should_display_notification(state: state, event: nostr_event, mode: .push) else {
+            Log.debug("should_display_notification failed", for: .push_notifications)
             // We should not display notification for this event. Suppress notification.
             // contentHandler(UNNotificationContent())
             // TODO: We cannot really suppress until we have the notification supression entitlement. Show the raw notification
@@ -62,6 +67,7 @@ class NotificationService: UNNotificationServiceExtension {
         }
         
         guard let notification_object = generate_local_notification_object(from: nostr_event, state: state) else {
+            Log.debug("generate_local_notification_object failed", for: .push_notifications)
             // We could not process this notification. Probably an unsupported nostr event kind. Suppress.
             // contentHandler(UNNotificationContent())
             // TODO: We cannot really suppress until we have the notification supression entitlement. Show the raw notification
@@ -70,9 +76,13 @@ class NotificationService: UNNotificationServiceExtension {
         }
         
         Task {
-            if let (improvedContent, _) = await NotificationFormatter.shared.format_message(displayName: display_name, notify: notification_object, state: state) {
-                contentHandler(improvedContent)
+            guard let (improvedContent, _) = await NotificationFormatter.shared.format_message(displayName: name, notify: notification_object, state: state) else {
+
+                Log.debug("NotificationFormatter.format_message failed", for: .push_notifications)
+                return
             }
+
+            contentHandler(improvedContent)
         }
     }
     

README.md

@@ -8,7 +8,7 @@ A twitter-like [nostr][nostr] client for iPhone, iPad and MacOS.
 
 [nostr]: https://github.com/fiatjaf/nostr
 
-## How is Damus better than twitter?
+## How is Damus better than X/Twitter?
 There are no toxic algorithms.\
 You can send or receive zaps (satoshis) without asking for permission.\
 [There is no central database](https://fiatjaf.com/nostr.html). Therefore, Damus is censorship resistant.\

TODO

@@ -0,0 +1 @@
+Fix q tags

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

@@ -1,6 +1,40 @@
 {
-  "originHash" : "babaf4d5748afecf49bbb702530d8e9576460692f478b0a50ee43195dd4440e2",
+  "originHash" : "085cf0f645323bf77edb52886489bf77b309a0a2d2b78a54beaf8520b540d596",
   "pins" : [
+    {
+      "identity" : "codescanner",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/twostraws/CodeScanner.git",
+      "state" : {
+        "revision" : "9fa582f4b36c69c2a55bff5fb3377eb170ae273c"
+      }
+    },
+    {
+      "identity" : "cryptoswift",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/krzyzanowskim/CryptoSwift.git",
+      "state" : {
+        "revision" : "e74bbbfbef939224b242ae7c342a90e60b88b5ce"
+      }
+    },
+    {
+      "identity" : "emojikit",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/tyiu/EmojiKit",
+      "state" : {
+        "revision" : "05805f72d63a6d6a2d7dc7fe14abd37c1317b11a",
+        "version" : "0.1.2"
+      }
+    },
+    {
+      "identity" : "emojipicker",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/tyiu/EmojiPicker.git",
+      "state" : {
+        "revision" : "0c28b4a1a6b8840cf2580bda59517f6d0a733dc8",
+        "version" : "0.1.1"
+      }
+    },
     {
       "identity" : "gsplayer",
       "kind" : "remoteSourceControl",
@@ -19,15 +53,6 @@
         "version" : "7.6.1"
       }
     },
-    {
-      "identity" : "mcemojipicker",
-      "kind" : "remoteSourceControl",
-      "location" : "https://github.com/izyumkin/MCEmojiPicker",
-      "state" : {
-        "revision" : "e0b4903b75ae1cc418d276d84d1cb946b8a1d73c",
-        "version" : "1.2.3"
-      }
-    },
     {
       "identity" : "secp256k1.swift",
       "kind" : "remoteSourceControl",
@@ -36,6 +61,15 @@
         "revision" : "40b4b38b3b1c83f7088c76189a742870e0ca06a9"
       }
     },
+    {
+      "identity" : "swift-collections",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-collections.git",
+      "state" : {
+        "revision" : "ee97538f5b81ae89698fd95938896dec5217b148",
+        "version" : "1.1.1"
+      }
+    },
     {
       "identity" : "swift-markdown-ui",
       "kind" : "remoteSourceControl",
@@ -62,13 +96,29 @@
         "version" : "509.0.0"
       }
     },
+    {
+      "identity" : "swift-trie",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/tyiu/swift-trie",
+      "state" : {
+        "revision" : "4c50bff6c168f74425f70476be62a072980d2da7",
+        "version" : "0.1.2"
+      }
+    },
+    {
+      "identity" : "swiftycrop",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/benedom/SwiftyCrop",
+      "state" : {
+        "revision" : "454d0a0d4faf6f3a19c8d817ab9d7d27524bd79f"
+      }
+    },
     {
       "identity" : "swipeactions",
       "kind" : "remoteSourceControl",
-      "location" : "https://github.com/aheze/SwipeActions",
+      "location" : "https://github.com/damus-io/SwipeActions.git",
       "state" : {
-        "revision" : "41e6f6dce02d8cfa164f8c5461a41340850ca3ab",
-        "version" : "1.1.0"
+        "revision" : "33d99756c3112e1a07c1732e3cddc5ad5bd0c5f4"
       }
     }
   ],

damus.xcodeproj/xcshareddata/xcschemes/HighlighterActionExtension.xcscheme

@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1540"
+   wasCreatedForAppExtension = "YES"
+   version = "2.0">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES"
+      buildArchitectures = "Automatic">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "D703D7162C66E47100A400EA"
+               BuildableName = "HighlighterActionExtension.appex"
+               BlueprintName = "HighlighterActionExtension"
+               ReferencedContainer = "container:damus.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "4CE6DEE227F7A08100C66700"
+               BuildableName = "damus.app"
+               BlueprintName = "damus"
+               ReferencedContainer = "container:damus.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      shouldAutocreateTestPlan = "YES">
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = ""
+      selectedLauncherIdentifier = "Xcode.IDEFoundation.Launcher.PosixSpawn"
+      launchStyle = "0"
+      askForAppToLaunch = "Yes"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES"
+      launchAutomaticallySubstyle = "2">
+      <RemoteRunnable
+         runnableDebuggingMode = "1"
+         BundleIdentifier = "com.apple.mobilesafari"
+         RemotePath = "/Library/Developer/CoreSimulator/Volumes/iOS_21F79/Library/Developer/CoreSimulator/Profiles/Runtimes/iOS 17.5.simruntime/Contents/Resources/RuntimeRoot/Applications/MobileSafari.app">
+      </RemoteRunnable>
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "4CE6DEE227F7A08100C66700"
+            BuildableName = "damus.app"
+            BlueprintName = "damus"
+            ReferencedContainer = "container:damus.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES"
+      askForAppToLaunch = "Yes"
+      launchAutomaticallySubstyle = "2">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "4CE6DEE227F7A08100C66700"
+            BuildableName = "damus.app"
+            BlueprintName = "damus"
+            ReferencedContainer = "container:damus.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

damus.xcodeproj/xcshareddata/xcschemes/damus.xcscheme

@@ -40,7 +40,7 @@
             </BuildableReference>
          </TestableReference>
          <TestableReference
-            skipped = "YES">
+            skipped = "NO">
             <BuildableReference
                BuildableIdentifier = "primary"
                BlueprintIdentifier = "4CE6DEFC27F7A08200C66700"

damus/Assets.xcassets/Colors/DamusHighlight.colorset/Contents.json

@@ -0,0 +1,38 @@
+{
+  "colors" : [
+    {
+      "color" : {
+        "color-space" : "srgb",
+        "components" : {
+          "alpha" : "1.000",
+          "blue" : "0xF2",
+          "green" : "0xD8",
+          "red" : "0xF4"
+        }
+      },
+      "idiom" : "universal"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "dark"
+        }
+      ],
+      "color" : {
+        "color-space" : "srgb",
+        "components" : {
+          "alpha" : "1.000",
+          "blue" : "0x45",
+          "green" : "0x17",
+          "red" : "0x47"
+        }
+      },
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

damus/Assets.xcassets/Illustrations/damoose.imageset/Contents.json

@@ -1,7 +1,7 @@
 {
   "images" : [
     {
-      "filename" : "profile-banner.jpeg",
+      "filename" : "damoose.jpeg",
       "idiom" : "universal"
     }
   ],

damus/Assets.xcassets/Logos/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

damus/Assets.xcassets/Logos/alby.imageset/Contents.json

@@ -0,0 +1,23 @@
+{
+  "images" : [
+    {
+      "filename" : "alby.svg",
+      "idiom" : "universal",
+      "scale" : "1x"
+    },
+    {
+      "filename" : "alby.svg",
+      "idiom" : "universal",
+      "scale" : "2x"
+    },
+    {
+      "filename" : "alby.svg",
+      "idiom" : "universal",
+      "scale" : "3x"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

damus/Assets.xcassets/Logos/coinos.imageset/Contents.json

@@ -0,0 +1,12 @@
+{
+  "images" : [
+    {
+      "filename" : "coinos.png",
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

damus/Assets.xcassets/Logos/tor.imageset/Contents.json

@@ -0,0 +1,12 @@
+{
+  "images" : [
+    {
+      "filename" : "tor.svg.png",
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

damus/Assets.xcassets/alby-go.imageset/Contents.json

@@ -0,0 +1,12 @@
+{
+  "images" : [
+    {
+      "filename" : "alby-go.png",
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

damus/Assets.xcassets/alby.imageset/Contents.json

@@ -1,23 +0,0 @@
-{
-  "images": [
-    {
-      "filename": "alby.svg",
-      "idiom": "universal",
-      "scale": "1x"
-    },
-    {
-      "idiom": "universal",
-      "scale": "2x",
-      "filename": "alby.svg"
-    },
-    {
-      "idiom": "universal",
-      "scale": "3x",
-      "filename": "alby.svg"
-    }
-  ],
-  "info": {
-    "author": "xcode",
-    "version": 1
-  }
-}

damus/Components/CustomPicker.swift

@@ -12,31 +12,25 @@ let RECTANGLE_GRADIENT = LinearGradient(gradient: Gradient(colors: [
     DamusColors.blue
 ]), startPoint: .leading, endPoint: .trailing)
 
-struct CustomPicker<SelectionValue: Hashable, Content: View>: View {
+struct CustomPicker<SelectionValue: Hashable>: View {
     
+    let tabs: [(String, SelectionValue)]
     @Environment(\.colorScheme) var colorScheme
-    
+
     @Namespace var picker
     @Binding var selection: SelectionValue
-    @ViewBuilder let content: Content
-    
+
     public var body: some View {
-        let contentMirror = Mirror(reflecting: content)
-        let blocksCount = Mirror(reflecting: contentMirror.descendant("value")!).children.count
         HStack {
-            ForEach(0..<blocksCount, id: \.self) { index in
-                let tupleBlock = contentMirror.descendant("value", ".\(index)")
-                let text = Mirror(reflecting: tupleBlock!).descendant("content") as! Text
-                let tag = Mirror(reflecting: tupleBlock!).descendant("modifier", "value", "tagged") as! SelectionValue
-                
+            ForEach(tabs, id: \.1) { (text, tag) in
                 Button {
                     withAnimation(.spring()) {
                         selection = tag
                     }
                 } label: {
-                    text
-                        .padding(EdgeInsets(top: 15, leading: 0, bottom: 10, trailing: 0))
+                    Text(text).padding(EdgeInsets(top: 15, leading: 0, bottom: 10, trailing: 0))
                         .font(.system(size: 14, weight: .heavy))
+                        .tag(tag)
                 }
                 .background(
                     Group {
@@ -52,7 +46,6 @@ struct CustomPicker<SelectionValue: Hashable, Content: View>: View {
                 .accentColor(tag == selection ? textColor() : .gray)
             }
         }
-        .background(Color(UIColor.systemBackground))
     }
     
     func textColor() -> Color {

damus/Components/DamusColors.swift

@@ -28,6 +28,7 @@ class DamusColors {
     static let green = Color("DamusGreen")
     static let purple = Color("DamusPurple")
     static let deepPurple = Color("DamusDeepPurple")
+    static let highlight = Color("DamusHighlight")
     static let blue = Color("DamusBlue")
     static let bitcoin = Color("Bitcoin")
     static let success = Color("DamusSuccessPrimary")

damus/Components/Gradients/DamusBackground.swift

@@ -20,6 +20,7 @@ struct DamusBackground: View {
             .resizable()
             .frame(maxWidth: .infinity, maxHeight: maxHeight, alignment: .center)
             .ignoresSafeArea()
+            .accessibilityHidden(true)
     }
 }
 

damus/Components/Gradients/MutinyGradient.swift

@@ -1,15 +0,0 @@
-//
-//  MutinyGradient.swift
-//  damus
-//
-//  Created by eric on 3/9/24.
-//
-
-import SwiftUI
-
-fileprivate let mutiny_grad_c1 = hex_col(r: 39, g: 95, b: 161)
-fileprivate let mutiny_grad_c2 = hex_col(r: 13, g: 33, b: 56)
-fileprivate let mutiny_grad = [mutiny_grad_c2, mutiny_grad_c1]
-
-let MutinyGradient: LinearGradient =
-    LinearGradient(colors: mutiny_grad, startPoint: .top, endPoint: .bottom)

damus/Components/ImageCarousel.swift

@@ -7,6 +7,7 @@
 
 import SwiftUI
 import Kingfisher
+import Combine
 
 // TODO: all this ShareSheet complexity can be replaced with ShareLink once we update to iOS 16
 struct ShareSheet: UIViewControllerRepresentable {
@@ -95,64 +96,203 @@ enum ImageShape {
     }
 }
 
+/// The `CarouselModel` helps `ImageCarousel` with some state management logic, keeping track of media sizes, and the ideal display size
+///
+/// This model is necessary because the state management logic required to keep track of media sizes for each one of the carousel items,
+/// and the ideal display size at each moment is not a trivial task.
+///
+/// The rules for the media fill are as follows:
+///  1. The media item should generally have a width that completely fills the width of its parent view
+///  2. The height of the carousel should be adjusted accordingly
+///  3. The only exception to rules 1 and 2 is when the total height would be 20% larger than the height of the device
+///  4. If none of the above can be computed (e.g. due to missing information), default to a reasonable height, where the media item will fit into.
+///
+/// ## Usage notes
+///
+/// The view is has the following state management responsibilities:
+///  1. Watching the size of the images (via the `.observe_image_size` modifier)
+///  2. Notifying this class of geometry reader changes, by setting `geo_size`
+///
+/// ## Implementation notes
+///
+/// This class is organized in a way to reduce stateful behavior and the transiency bugs it can cause.
+///
+/// This is accomplished through the following pattern:
+/// 1. The `current_item_fill` is a published property so that any updates instantly re-render the view
+/// 2. However, `current_item_fill` has a mathematical dependency on other members of this class
+/// 3. Therefore, the members on which the fill property depends on all have `didSet` observers that will cause the `current_item_fill` to be recalculated and published.
+///
+/// This pattern helps ensure that the state is always consistent and that the view is always up-to-date.
+/// 
+/// This class is marked as `@MainActor` since most of its properties are published and should be accessed from the main thread to avoid inconsistent SwiftUI state during renders
+@MainActor
 class CarouselModel: ObservableObject {
-    var current_url: URL?
-    var fillHeight: CGFloat
-    var maxHeight: CGFloat
-    var firstImageHeight: CGFloat?
+    // MARK: Immutable object attributes
+    // These are some attributes that are not expected to change throughout the lifecycle of this object
+    // These should not be modified after initialization to avoid state inconsistency
+    
+    /// The state of the app
+    let damus_state: DamusState
+    /// All urls in the carousel
+    let urls: [MediaUrl]
+    /// The default fill height for the carousel, if we cannot calculate a more appropriate height
+    /// **Usage note:** Default to this when `current_item_fill` is nil
+    let default_fill_height: CGFloat
+    /// The maximum height for any carousel item
+    let max_height: CGFloat
+    
+    
+    // MARK: Miscellaneous
+    
+    /// Holds items that allows us to cancel video size observers during de-initialization
+    private var all_cancellables: [AnyCancellable] = []
+    
+    
+    // MARK: State management properties
+    /// Properties relevant to state management. 
+    /// These should be made into computed/functional properties when possible to avoid stateful behavior
+    /// When that is not possible (e.g. when dealing with an observed published property), establish its mathematical dependencies, 
+    /// and use `didSet` observers to ensure that the state is always re-computed when necessary.
 
-    @Published var open_sheet: Bool
-    @Published var selectedIndex: Int
-    @Published var video_size: CGSize?
-    @Published var image_fill: ImageFill?
+    /// Stores information about the size of each media item in `urls`.
+    /// **Usage note:** The view is responsible for setting the size of image urls
+    var media_size_information: [URL: CGSize] {
+        didSet {
+            guard let current_url else { return }
+            // Upon updating information, update the carousel fill size if the size for the current url has changed
+            if oldValue[current_url] != media_size_information[current_url] {
+                self.refresh_current_item_fill()
+            }
+        }
+    }
+    /// Stores information about the geometry reader
+    /// **Usage note:** The view is responsible for setting this value
+    var geo_size: CGSize? {
+        didSet { self.refresh_current_item_fill() }
+    }
+    /// The index of the currently selected item
+    /// **Usage note:** The view is responsible for setting this value
+    @Published var selectedIndex: Int {
+        didSet { self.refresh_current_item_fill() }
+    }
+    /// The current fill for the media item.
+    /// **Usage note:** This property is read-only and should not be set directly. Update `selectedIndex` to update the current item being viewed.
+    var current_url: URL? {
+        return urls[safe: selectedIndex]?.url
+    }
+    /// Holds the ideal fill dimensions for the current item.
+    /// **Usage note:** This property is automatically updated when other properties are set, and should not be set directly
+    /// **Implementation note:** This property is mathematically dependent on geo_size, media_size_information, and `selectedIndex`, 
+    ///   and is automatically updated upon changes to these properties.
+    @Published private(set) var current_item_fill: ImageFill?
+    
+    
+    // MARK: Initialization and de-initialization
 
-    init(image_fill: ImageFill?) {
-        self.current_url = nil
-        self.fillHeight = 350
-        self.maxHeight = UIScreen.main.bounds.height * 1.2 // 1.2
-        self.firstImageHeight = nil
-        self.open_sheet = false
+    /// Initializes the `CarouselModel` with the given `DamusState` and `MediaUrl` array
+    init(damus_state: DamusState, urls: [MediaUrl]) {
+        // Immutable object attributes
+        self.damus_state = damus_state
+        self.urls = urls
+        self.default_fill_height = 350
+        self.max_height = UIScreen.main.bounds.height * 1.2 // 1.2
+        
+        // State management properties
         self.selectedIndex = 0
-        self.video_size = nil
-        self.image_fill = image_fill
+        self.current_item_fill = nil
+        self.geo_size = nil
+        self.media_size_information = [:]
+        
+        // Setup the rest of the state management logic
+        self.observe_video_sizes()
+        Task {
+            self.refresh_current_item_fill()
+        }
+    }
+    
+    /// This private function observes the video sizes for all videos
+    private func observe_video_sizes() {
+        for media_url in urls {
+            switch media_url {
+                case .video(let url):
+                    let video_player = damus_state.video.get_player(for: url)
+                    if let video_size = video_player.video_size {
+                        self.media_size_information[url] = video_size  // Set the initial size if available
+                    }
+                    let observer_cancellable = video_player.$video_size.sink(receiveValue: { new_size in
+                        self.media_size_information[url] = new_size    // Update the size when it changes
+                    })
+                    all_cancellables.append(observer_cancellable)      // Store the cancellable to cancel it later
+                case .image(_):
+                    break;  // Observing an image size needs to be done on the view directly, through the `.observe_image_size` modifier
+            }
+        }
+    }
+    
+    deinit {
+        for cancellable_item in all_cancellables {
+            cancellable_item.cancel()
+        }
+    }
+    
+    // MARK: State management and logic
+
+    /// This function refreshes the current item fill based on the current state of the model
+    /// **Usage note:** This is private, do not call this directly from outside the class.
+    /// **Implementation note:** This should be called using `didSet` observers on properties that affect the fill
+    private func refresh_current_item_fill() {
+        if let current_url,
+           let item_size = self.media_size_information[current_url],
+           let geo_size {
+            self.current_item_fill = ImageFill.calculate_image_fill(
+                geo_size: geo_size,
+                img_size: item_size,
+                maxHeight: self.max_height,
+                fillHeight: self.default_fill_height
+            )
+        }
+        else {
+            self.current_item_fill = nil    // Not enough information to compute the proper fill. Default to nil
+        }
     }
 }
 
 // MARK: - Image Carousel
+
+/// A carousel that displays images and videos
+/// 
+/// ## Implementation notes
+/// 
+/// - State management logic is mostly handled by `CarouselModel`, as it is complex, and becomes difficult to manage in a view
+///
 @MainActor
 struct ImageCarousel<Content: View>: View {
-    var urls: [MediaUrl]
-    
+    /// The event id of the note that this carousel is displaying
     let evid: NoteId
-    
-    let state: DamusState
+    /// The model that holds information and state of this carousel
+    /// This is observed to update the view when the model changes
     @ObservedObject var model: CarouselModel
     let content: ((_ dismiss: @escaping (() -> Void)) -> Content)?
 
     init(state: DamusState, evid: NoteId, urls: [MediaUrl]) {
-        self.urls = urls
         self.evid = evid
-        self.state = state
-        let media_model = state.events.get_cache_data(evid).media_metadata_model
-        self._model = ObservedObject(initialValue: CarouselModel(image_fill: media_model.fill))
+        self._model = ObservedObject(initialValue: CarouselModel(damus_state: state, urls: urls))
         self.content = nil
     }
     
     init(state: DamusState, evid: NoteId, urls: [MediaUrl], @ViewBuilder content: @escaping (_ dismiss: @escaping (() -> Void)) -> Content) {
-        self.urls = urls
         self.evid = evid
-        self.state = state
-        let media_model = state.events.get_cache_data(evid).media_metadata_model
-        self._model = ObservedObject(initialValue: CarouselModel(image_fill: media_model.fill))
+        self._model = ObservedObject(initialValue: CarouselModel(damus_state: state, urls: urls))
         self.content = content
     }
     
     var filling: Bool {
-        model.image_fill?.filling == true
+        model.current_item_fill?.filling == true
     }
     
     var height: CGFloat {
-        model.firstImageHeight ?? model.image_fill?.height ?? model.fillHeight
+        // Use the calculated fill height if available, otherwise use the default fill height
+        model.current_item_fill?.height ?? model.default_fill_height
     }
     
     func Placeholder(url: URL, geo_size: CGSize, num_urls: Int) -> some View {
@@ -160,7 +300,7 @@ struct ImageCarousel<Content: View>: View {
             if num_urls > 1 {
                 // jb55: quick hack since carousel with multiple images looks horrible with blurhash background
                 Color.clear
-            } else if let meta = state.events.lookup_img_metadata(url: url),
+            } else if let meta = model.damus_state.events.lookup_img_metadata(url: url),
                case .processed(let blurhash) = meta.state {
                 Image(uiImage: blurhash)
                     .resizable()
@@ -169,12 +309,6 @@ struct ImageCarousel<Content: View>: View {
                 Color.clear
             }
         }
-        .onAppear {
-            if self.model.image_fill == nil, let size = state.video.size_for_url(url) {
-                let fill = ImageFill.calculate_image_fill(geo_size: geo_size, img_size: size, maxHeight: model.maxHeight, fillHeight: model.fillHeight)
-                self.model.image_fill = fill
-            }
-        }
     }
     
     func Media(geo: GeometryProxy, url: MediaUrl, index: Int) -> some View {
@@ -183,24 +317,17 @@ struct ImageCarousel<Content: View>: View {
             case .image(let url):
                 Img(geo: geo, url: url, index: index)
                     .onTapGesture {
-                        model.open_sheet = true
+                        present(full_screen_item: .full_screen_carousel(urls: model.urls, selectedIndex: $model.selectedIndex))
                     }
             case .video(let url):
-                DamusVideoPlayer(url: url, video_size: $model.video_size, controller: state.video, style: .preview(on_tap: { model.open_sheet = true }))
-                    .onChange(of: model.video_size) { size in
-                        guard let size else { return }
-                        
-                        let fill = ImageFill.calculate_image_fill(geo_size: geo.size, img_size: size, maxHeight: model.maxHeight, fillHeight: model.fillHeight)
-
-                        print("video_size changed \(size)")
-                        if self.model.image_fill == nil {
-                            print("video_size firstImageHeight \(fill.height)")
-                            self.model.firstImageHeight = fill.height
-                            state.events.get_cache_data(evid).media_metadata_model.fill = fill
-                        }
-                        
-                        self.model.image_fill = fill
-                    }
+                   let video_model = model.damus_state.video.get_player(for: url)
+                    DamusVideoPlayerView(
+                        model: video_model,
+                        coordinator: model.damus_state.video,
+                        style: .preview(on_tap: {
+                            present(full_screen_item: .full_screen_carousel(urls: model.urls, selectedIndex: $model.selectedIndex))
+                        })
+                    )
             }
         }
     }
@@ -209,33 +336,21 @@ struct ImageCarousel<Content: View>: View {
         KFAnimatedImage(url)
             .callbackQueue(.dispatch(.global(qos:.background)))
             .backgroundDecode(true)
-            .imageContext(.note, disable_animation: state.settings.disable_animation)
+            .imageContext(.note, disable_animation: model.damus_state.settings.disable_animation)
             .image_fade(duration: 0.25)
             .cancelOnDisappear(true)
             .configure { view in
                 view.framePreloadCount = 3
             }
-            .imageFill(for: geo.size, max: model.maxHeight, fill: model.fillHeight) { fill in
-                state.events.get_cache_data(evid).media_metadata_model.fill = fill
-                // blur hash can be discarded when we have the url
-                // NOTE: this is the wrong place for this... we need to remove
-                //       it when the image is loaded in memory. This may happen
-                //       earlier than this (by the preloader, etc)
-                DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
-                    state.events.lookup_img_metadata(url: url)?.state = .not_needed
-                }
-                self.model.image_fill = fill
-                if index == 0 {
-                    self.model.firstImageHeight = fill.height
-                    //maxHeight = firstImageHeight ?? maxHeight
-                } else {
-                    //maxHeight = firstImageHeight ?? fill.height
-                }
-            }
+            .observe_image_size(size_changed: { size in
+                // Observe the image size to update the model when the size changes, so we can calculate the fill
+                model.media_size_information[url] = size
+            })
             .background {
-                Placeholder(url: url, geo_size: geo.size, num_urls: urls.count)
+                Placeholder(url: url, geo_size: geo.size, num_urls: model.urls.count)
             }
             .aspectRatio(contentMode: filling ? .fill : .fit)
+            .kfClickable()
             .position(x: geo.size.width / 2, y: geo.size.height / 2)
             .tabItem {
                 Text(url.absoluteString)
@@ -247,25 +362,19 @@ struct ImageCarousel<Content: View>: View {
     
     var Medias: some View {
         TabView(selection: $model.selectedIndex) {
-            ForEach(urls.indices, id: \.self) { index in
+            ForEach(model.urls.indices, id: \.self) { index in
                 GeometryReader { geo in
-                    Media(geo: geo, url: urls[index], index: index)
+                    Media(geo: geo, url: model.urls[index], index: index)
+                        .onChange(of: geo.size, perform: { new_size in
+                            model.geo_size = new_size
+                        })
+                        .onAppear {
+                            model.geo_size = geo.size
+                        }
                 }
             }
         }
         .tabViewStyle(PageTabViewStyle(indexDisplayMode: .never))
-        .fullScreenCover(isPresented: $model.open_sheet) {
-            if let content {
-                FullScreenCarouselView<Content>(video_controller: state.video, urls: urls, settings: state.settings, selectedIndex: $model.selectedIndex) {
-                    content({ // Dismiss closure
-                        model.open_sheet = false
-                    })
-                }
-            }
-            else {
-                FullScreenCarouselView<AnyView>(video_controller: state.video, urls: urls, settings: state.settings, selectedIndex: $model.selectedIndex)
-            }
-        }
         .frame(height: height)
         .onChange(of: model.selectedIndex) { value in
             model.selectedIndex = value
@@ -274,11 +383,17 @@ struct ImageCarousel<Content: View>: View {
     
     var body: some View {
         VStack {
-            Medias
-                .onTapGesture { }
+            if #available(iOS 18.0, *) {
+                Medias
+            } else {
+                // An empty tap gesture recognizer is needed on iOS 17 and below to suppress other overlapping tap recognizers
+                // Otherwise it will both open the carousel and go to a note at the same time
+                Medias.onTapGesture { }
+            }
             
-            if urls.count > 1 {
-                PageControlView(currentPage: $model.selectedIndex, numberOfPages: urls.count)
+            
+            if model.urls.count > 1 {
+                PageControlView(currentPage: $model.selectedIndex, numberOfPages: model.urls.count)
                     .frame(maxWidth: 0, maxHeight: 0)
                     .padding(.top, 5)
             }
@@ -286,27 +401,6 @@ struct ImageCarousel<Content: View>: View {
     }
 }
 
-// MARK: - Image Modifier
-extension KFOptionSetter {
-    /// Sets a block to get image size
-    ///
-    /// - Parameter block: The block which is used to read the image object.
-    /// - Returns: `Self` value after read size
-    public func imageFill(for size: CGSize, max: CGFloat, fill: CGFloat, block: @escaping (ImageFill) throws -> Void) -> Self {
-        let modifier = AnyImageModifier { image -> KFCrossPlatformImage in
-            let img_size = image.size
-            let geo_size = size
-            let fill = ImageFill.calculate_image_fill(geo_size: geo_size, img_size: img_size, maxHeight: max, fillHeight: fill)
-            DispatchQueue.main.async { [block, fill] in
-                try? block(fill)
-            }
-            return image
-        }
-        options.imageModifier = modifier
-        return self
-    }
-}
-
 
 public struct ImageFill {
     let filling: Bool?
@@ -343,4 +437,3 @@ struct ImageCarousel_Previews: PreviewProvider {
             .environmentObject(OrientationTracker())
     }
 }
-

damus/Components/InvoiceView.swift

@@ -94,8 +94,8 @@ enum OpenWalletError: Error {
 }
 
 func open_with_wallet(wallet: Wallet.Model, invoice: String) throws {
-    if let url = URL(string: "\(wallet.link)\(invoice)"), UIApplication.shared.canOpenURL(url) {
-        UIApplication.shared.open(url)
+    if let url = URL(string: "\(wallet.link)\(invoice)"), this_app.canOpenURL(url) {
+        this_app.open(url)
     } else {
         guard let store_link = wallet.appStoreLink else {
             throw OpenWalletError.no_wallet_to_open
@@ -105,11 +105,11 @@ func open_with_wallet(wallet: Wallet.Model, invoice: String) throws {
             throw OpenWalletError.store_link_invalid
         }
         
-        guard UIApplication.shared.canOpenURL(url) else {
+        guard this_app.canOpenURL(url) else {
             throw OpenWalletError.system_cannot_open_store_link
         }
         
-        UIApplication.shared.open(url)
+        this_app.open(url)
     }
 }
 
@@ -122,8 +122,3 @@ struct InvoiceView_Previews: PreviewProvider {
             .frame(width: 300, height: 200)
     }
 }
-
-
-func present_sheet(_ sheet: Sheets) {
-    notify(.present_sheet(sheet))
-}

damus/Components/Reposted.swift

@@ -10,22 +10,68 @@ import SwiftUI
 struct Reposted: View {
     let damus: DamusState
     let pubkey: Pubkey
+    let target: NostrEvent
+    @State var reposts: Int
+
+    init(damus: DamusState, pubkey: Pubkey, target: NostrEvent) {
+        self.damus = damus
+        self.pubkey = pubkey
+        self.target = target
+        self.reposts = damus.boosts.counts[target.id] ?? 1
+    }
 
     var body: some View {
         HStack(alignment: .center) {
             Image("repost")
                 .foregroundColor(Color.gray)
-            ProfileName(pubkey: pubkey, damus: damus, show_nip5_domain: false)
-                    .foregroundColor(Color.gray)
-            Text("Reposted", comment: "Text indicating that the note was reposted (i.e. re-shared).")
-                .foregroundColor(Color.gray)
+
+            // Show profile picture of the reposter only if the reposter is not the author of the reposted note.
+            if pubkey != target.pubkey {
+                ProfilePicView(pubkey: pubkey, size: eventview_pfp_size(.small), highlight: .none, profiles: damus.profiles, disable_animation: damus.settings.disable_animation)
+                    .onTapGesture {
+                        show_profile_action_sheet_if_enabled(damus_state: damus, pubkey: pubkey)
+                    }
+                    .onLongPressGesture(minimumDuration: 0.1) {
+                        UIImpactFeedbackGenerator(style: .medium).impactOccurred()
+                        damus.nav.push(route: Route.ProfileByKey(pubkey: pubkey))
+                    }
+            }
+
+            NavigationLink(value: Route.Reposts(reposts: .reposts(state: damus, target: target.id))) {
+                Text(people_reposted_text(profiles: damus.profiles, pubkey: pubkey, reposts: reposts))
+                    .font(.subheadline)
+                    .foregroundColor(.gray)
+            }
         }
+        .onReceive(handle_notify(.update_stats), perform: { note_id in
+            guard note_id == target.id else { return }
+            let repost_count = damus.boosts.counts[target.id]
+            if let repost_count, reposts != repost_count {
+                reposts = repost_count
+            }
+        })
+    }
+}
+
+func people_reposted_text(profiles: Profiles, pubkey: Pubkey, reposts: Int, locale: Locale = Locale.current) -> String {
+    guard reposts > 0 else {
+        return ""
+    }
+
+    let bundle = bundleForLocale(locale: locale)
+    let other_reposts = reposts - 1
+    let display_name = event_author_name(profiles: profiles, pubkey: pubkey)
+
+    if other_reposts == 0 {
+        return String(format: NSLocalizedString("%@ reposted", bundle: bundle, comment: "Text indicating that the note was reposted (i.e. re-shared)."), locale: locale, display_name)
+    } else {
+        return String(format: localizedStringFormat(key: "people_reposted_count", locale: locale), locale: locale, other_reposts, display_name)
     }
 }
 
 struct Reposted_Previews: PreviewProvider {
     static var previews: some View {
         let test_state = test_damus_state
-        Reposted(damus: test_state, pubkey: test_state.pubkey)
+        Reposted(damus: test_state, pubkey: test_state.pubkey, target: test_note)
     }
 }

damus/Components/SelectableText.swift

@@ -9,16 +9,19 @@ import UIKit
 import SwiftUI
 
 struct SelectableText: View {
-    
+    let damus_state: DamusState
+    let event: NostrEvent?
     let attributedString: AttributedString
     let textAlignment: NSTextAlignment
-    
+    @State private var selectedTextActionState: SelectedTextActionState = .hide
     @State private var selectedTextHeight: CGFloat = .zero
     @State private var selectedTextWidth: CGFloat = .zero
-    
+
     let size: EventViewKind
-    
-    init(attributedString: AttributedString, textAlignment: NSTextAlignment? = nil, size: EventViewKind) {
+
+    init(damus_state: DamusState, event: NostrEvent?, attributedString: AttributedString, textAlignment: NSTextAlignment? = nil, size: EventViewKind) {
+        self.damus_state = damus_state
+        self.event = event
         self.attributedString = attributedString
         self.textAlignment = textAlignment ?? NSTextAlignment.natural
         self.size = size
@@ -32,6 +35,13 @@ struct SelectableText: View {
                 font: eventviewsize_to_uifont(size),
                 fixedWidth: selectedTextWidth,
                 textAlignment: self.textAlignment,
+                enableHighlighting: self.enableHighlighting(),
+                postHighlight: { selectedText in
+                    self.selectedTextActionState = .show_highlight_post_view(highlighted_text: selectedText)
+                },
+                muteWord: { selectedText in
+                    self.selectedTextActionState = .show_mute_word_view(highlighted_text: selectedText)
+                },
                 height: $selectedTextHeight
             )
             .padding([.leading, .trailing], -1.0)
@@ -46,22 +56,123 @@ struct SelectableText: View {
                 self.selectedTextWidth = newSize.width
             }
         }
+        .sheet(isPresented: Binding(get: {
+            return self.selectedTextActionState.should_show_highlight_post_view()
+        }, set: { newValue in
+            self.selectedTextActionState = newValue ? .show_highlight_post_view(highlighted_text: self.selectedTextActionState.highlighted_text() ?? "") : .hide
+        })) {
+            if let event, case .show_highlight_post_view(let highlighted_text) = self.selectedTextActionState {
+                PostView(
+                    action: .highlighting(.init(selected_text: highlighted_text, source: .event(event.id))),
+                    damus_state: damus_state
+                )
+                .presentationDragIndicator(.visible)
+                .presentationDetents([.height(selectedTextHeight + 450), .medium, .large])
+            }
+        }
+        .sheet(isPresented: Binding(get: {
+            return self.selectedTextActionState.should_show_mute_word_view()
+        }, set: { newValue in
+            self.selectedTextActionState = newValue ? .show_mute_word_view(highlighted_text: self.selectedTextActionState.highlighted_text() ?? "") : .hide
+        })) {
+            if case .show_mute_word_view(let highlighted_text) = selectedTextActionState {
+                AddMuteItemView(state: damus_state, new_text: .constant(highlighted_text))
+                    .presentationDragIndicator(.visible)
+                    .presentationDetents([.height(300), .medium, .large])
+            }
+        }
         .frame(height: selectedTextHeight)
     }
+    
+    func enableHighlighting() -> Bool {
+        self.event != nil
+    }
+    
+    enum SelectedTextActionState {
+        case hide
+        case show_highlight_post_view(highlighted_text: String)
+        case show_mute_word_view(highlighted_text: String)
+        
+        func should_show_highlight_post_view() -> Bool {
+            guard case .show_highlight_post_view(let highlighted_text) = self else { return false }
+            return true
+        }
+        
+        func should_show_mute_word_view() -> Bool {
+            guard case .show_mute_word_view(let highlighted_text) = self else { return false }
+            return true
+        }
+        
+        func highlighted_text() -> String? {
+            switch self {
+                case .hide:
+                    return nil
+                case .show_mute_word_view(highlighted_text: let highlighted_text):
+                    return highlighted_text
+                case .show_highlight_post_view(highlighted_text: let highlighted_text):
+                    return highlighted_text
+            }
+        }
+    }
 }
 
- fileprivate struct TextViewRepresentable: UIViewRepresentable {
+fileprivate class TextView: UITextView {
+    var postHighlight: (String) -> Void
+    var muteWord: (String) -> Void
+
+    init(frame: CGRect, textContainer: NSTextContainer?, postHighlight: @escaping (String) -> Void, muteWord: @escaping (String) -> Void) {
+        self.postHighlight = postHighlight
+        self.muteWord = muteWord
+        super.init(frame: frame, textContainer: textContainer)
+    }
+
+    required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+
+    override func canPerformAction(_ action: Selector, withSender sender: Any?) -> Bool {
+        if action == #selector(highlightText(_:)) {
+            return true
+        }
+        
+        if action == #selector(muteText(_:)) {
+            return true
+        }
+        
+        return super.canPerformAction(action, withSender: sender)
+    }
+    
+    func getSelectedText() -> String? {
+        guard let selectedRange = self.selectedTextRange else { return nil }
+        return self.text(in: selectedRange)
+    }
+
+    @objc public func highlightText(_ sender: Any?) {
+        guard let selectedText = self.getSelectedText() else { return }
+        self.postHighlight(selectedText)
+    }
+    
+    @objc public func muteText(_ sender: Any?) {
+        guard let selectedText = self.getSelectedText() else { return }
+        self.muteWord(selectedText)
+    }
+
+}
+
+fileprivate struct TextViewRepresentable: UIViewRepresentable {
 
     let attributedString: AttributedString
     let textColor: UIColor
     let font: UIFont
     let fixedWidth: CGFloat
     let textAlignment: NSTextAlignment
-
+    let enableHighlighting: Bool
+    let postHighlight: (String) -> Void
+    let muteWord: (String) -> Void
     @Binding var height: CGFloat
 
-    func makeUIView(context: UIViewRepresentableContext<Self>) -> UITextView {
-        let view = UITextView()
+    func makeUIView(context: UIViewRepresentableContext<Self>) -> TextView {
+        let view = TextView(frame: .zero, textContainer: nil, postHighlight: postHighlight, muteWord: muteWord)
         view.isEditable = false
         view.dataDetectorTypes = .all
         view.isSelectable = true
@@ -71,10 +182,16 @@ struct SelectableText: View {
         view.textContainerInset.left = 1.0
         view.textContainerInset.right = 1.0
         view.textAlignment = textAlignment
+
+        let menuController = UIMenuController.shared
+        let highlightItem = UIMenuItem(title: "Highlight", action: #selector(view.highlightText(_:)))
+        let muteItem = UIMenuItem(title: "Mute", action: #selector(view.muteText(_:)))
+        menuController.menuItems = self.enableHighlighting ? [highlightItem, muteItem] : []
+
         return view
     }
 
-    func updateUIView(_ uiView: UITextView, context: UIViewRepresentableContext<Self>) {
+    func updateUIView(_ uiView: TextView, context: UIViewRepresentableContext<Self>) {
         let mutableAttributedString = createNSAttributedString()
         uiView.attributedText = mutableAttributedString
         uiView.textAlignment = self.textAlignment

damus/Components/SupporterBadge.swift

@@ -11,11 +11,21 @@ struct SupporterBadge: View {
     let percent: Int?
     let purple_account: DamusPurple.Account?
     let style: Style
+    let text_color: Color
+    var badge_variant: BadgeVariant {
+        if purple_account?.attributes.contains(.memberForMoreThanOneYear) == true {
+            return .oneYearSpecial
+        }
+        else {
+            return .normal
+        }
+    }
     
-    init(percent: Int?, purple_account: DamusPurple.Account? = nil, style: Style) {
+    init(percent: Int?, purple_account: DamusPurple.Account? = nil, style: Style, text_color: Color = .secondary) {
         self.percent = percent
         self.purple_account = purple_account
         self.style = style
+        self.text_color = text_color
     }
     
     let size: CGFloat = 17
@@ -24,14 +34,19 @@ struct SupporterBadge: View {
         HStack {
             if let purple_account, purple_account.active == true {
                 HStack(spacing: 1) {
-                    Image("star.fill")
-                        .resizable()
-                        .frame(width:size, height:size)
-                        .foregroundStyle(GoldGradient)
-                    if self.style == .full {
-                        let date = format_date(date: purple_account.created_at, time_style: .none)
-                        Text(date)
-                            .foregroundStyle(.secondary)
+                    switch self.badge_variant {
+                    case .normal:
+                        StarShape()
+                            .frame(width:size, height:size)
+                            .foregroundStyle(GoldGradient)
+                    case .oneYearSpecial:
+                        DoubleStar(size: size)
+                    }
+                    
+                    if self.style == .full,
+                       let ordinal = self.purple_account?.ordinal() {
+                        Text(ordinal)
+                            .foregroundStyle(text_color)
                             .font(.caption)
                     }
                 }
@@ -54,8 +69,102 @@ struct SupporterBadge: View {
         case full       // Shows the entire badge with a purple subscriber number if present
         case compact    // Does not show purple subscriber number. Only shows the star (if applicable)
     }
+    
+    enum BadgeVariant {
+        /// A normal badge that people are used to
+        case normal
+        /// A special badge for users who have been members for more than a year
+        case oneYearSpecial
+    }
 }
 
+
+struct StarShape: Shape {
+    func path(in rect: CGRect) -> Path {
+        var path = Path()
+        let center = CGPoint(x: rect.midX, y: rect.midY)
+        let radius: CGFloat = min(rect.width, rect.height) / 2
+        let points = 5
+        let adjustment: CGFloat = .pi / 2
+        
+        for i in 0..<points * 2 {
+            let angle = (CGFloat(i) * .pi / CGFloat(points)) - adjustment
+            let pointRadius = i % 2 == 0 ? radius : radius * 0.4
+            let point = CGPoint(x: center.x + pointRadius * cos(angle), y: center.y + pointRadius * sin(angle))
+            if i == 0 {
+                path.move(to: point)
+            } else {
+                path.addLine(to: point)
+            }
+        }
+        path.closeSubpath()
+        return path
+    }
+}
+
+struct DoubleStar: View {
+    let size: CGFloat
+    var starOffset: CGFloat = 5
+    
+    var body: some View {
+        if #available(iOS 17.0, *) {
+            DoubleStarShape(starOffset: starOffset)
+                .frame(width: size, height: size)
+                .foregroundStyle(GoldGradient)
+                .padding(.trailing, starOffset)
+        } else {
+            Fallback(size: size, starOffset: starOffset)
+        }
+    }
+    
+    @available(iOS 17.0, *)
+    struct DoubleStarShape: Shape {
+        var strokeSize: CGFloat = 3
+        var starOffset: CGFloat
+
+        func path(in rect: CGRect) -> Path {
+            let normalSizedStarPath = StarShape().path(in: rect)
+            let largerStarPath = StarShape().path(in: rect.insetBy(dx: -strokeSize, dy: -strokeSize))
+            
+            let finalPath = normalSizedStarPath
+                .subtracting(
+                    largerStarPath.offsetBy(dx: starOffset, dy: 0)
+                )
+                .union(
+                    normalSizedStarPath.offsetBy(dx: starOffset, dy: 0)
+                )
+            
+            return finalPath
+        }
+    }
+    
+    /// A fallback view for those who cannot run iOS 17
+    struct Fallback: View {
+        var size: CGFloat
+        var starOffset: CGFloat
+        
+        var body: some View {
+            HStack {
+                StarShape()
+                    .frame(width: size, height: size)
+                    .foregroundStyle(GoldGradient)
+                
+                StarShape()
+                    .fill(GoldGradient)
+                    .overlay(
+                        StarShape()
+                            .stroke(Color.damusAdaptableWhite, lineWidth: 1)
+                    )
+                    .frame(width: size + 1, height: size + 1)
+                    .padding(.leading, -size - starOffset)
+            }
+            .padding(.trailing, -3)
+        }
+    }
+}
+
+
+
 func support_level_color(_ percent: Int) -> Color {
     if percent == 0 {
         return .gray
@@ -84,7 +193,7 @@ struct SupporterBadge_Previews: PreviewProvider {
         HStack(alignment: .center) {
             SupporterBadge(
                 percent: nil,
-                purple_account: DamusPurple.Account(pubkey: test_pubkey, created_at: .now, expiry: .now.addingTimeInterval(10000), subscriber_number: subscriber_number, active: true),
+                purple_account: DamusPurple.Account(pubkey: test_pubkey, created_at: .now, expiry: .now.addingTimeInterval(10000), subscriber_number: subscriber_number, active: true, attributes: []),
                 style: .full
             )
                 .frame(width: 100)
@@ -116,4 +225,52 @@ struct SupporterBadge_Previews: PreviewProvider {
     }
 }
 
+#Preview("1 yr badge") {
+    VStack {
+        HStack(alignment: .center) {
+            SupporterBadge(
+                percent: nil,
+                purple_account: DamusPurple.Account(pubkey: test_pubkey, created_at: .now, expiry: .now.addingTimeInterval(10000), subscriber_number: 3, active: true, attributes: []),
+                style: .full
+            )
+                .frame(width: 100)
+        }
+        
+        HStack(alignment: .center) {
+            SupporterBadge(
+                percent: nil,
+                purple_account: DamusPurple.Account(pubkey: test_pubkey, created_at: .now, expiry: .now.addingTimeInterval(10000), subscriber_number: 3, active: true, attributes: [.memberForMoreThanOneYear]),
+                style: .full
+            )
+                .frame(width: 100)
+        }
+        
+        Text(verbatim: "Double star (just shape itself, with alt background color, to show it adapts to background well)")
+            .multilineTextAlignment(.center)
+        
+        if #available(iOS 17.0, *) {
+            HStack(alignment: .center) {
+                DoubleStar.DoubleStarShape(starOffset: 5)
+                    .frame(width: 17, height: 17)
+                    .padding(.trailing, -8)
+            }
+            .background(Color.blue)
+        }
+        
+        Text(verbatim: "Double star (fallback for iOS 16 and below)")
+
+        HStack(alignment: .center) {
+            DoubleStar.Fallback(size: 17, starOffset: 5)
+        }
+        
+        Text(verbatim: "Double star (fallback for iOS 16 and below, with alt color limitation shown)")
+            .multilineTextAlignment(.center)
+        
+        HStack(alignment: .center) {
+            DoubleStar.Fallback(size: 17, starOffset: 5)
+        }
+        .background(Color.blue)
+    }
+}
+
 

damus/Components/TranslateView.swift

@@ -27,19 +27,26 @@ struct TranslateView: View {
     let damus_state: DamusState
     let event: NostrEvent
     let size: EventViewKind
-    
+
+    @Binding var isAppleTranslationPopoverPresented: Bool
+
     @ObservedObject var translations_model: TranslationModel
     
-    init(damus_state: DamusState, event: NostrEvent, size: EventViewKind) {
+    init(damus_state: DamusState, event: NostrEvent, size: EventViewKind, isAppleTranslationPopoverPresented: Binding<Bool>) {
         self.damus_state = damus_state
         self.event = event
         self.size = size
+        self._isAppleTranslationPopoverPresented = isAppleTranslationPopoverPresented
         self._translations_model = ObservedObject(wrappedValue: damus_state.events.get_cache_data(event.id).translations_model)
     }
     
     var TranslateButton: some View {
         Button(NSLocalizedString("Translate Note", comment: "Button to translate note from different language.")) {
-            translate()
+            if damus_state.settings.translation_service == .none {
+                isAppleTranslationPopoverPresented = true
+            } else {
+                translate()
+            }
         }
         .translate_button_style()
     }
@@ -51,9 +58,9 @@ struct TranslateView: View {
                 .foregroundColor(.gray)
                 .font(.footnote)
                 .padding([.top, .bottom], 10)
-            
+
             if self.size == .selected {
-                SelectableText(attributedString: artifacts.content.attributed, size: self.size)
+                SelectableText(damus_state: damus_state, event: event, attributedString: artifacts.content.attributed, size: self.size)
             } else {
                 artifacts.content.text
                     .font(eventviewsize_to_font(self.size, font_size: font_size))
@@ -74,17 +81,25 @@ struct TranslateView: View {
     }
         
     func should_transl(_ note_lang: String) -> Bool {
-        should_translate(event: event, our_keypair: damus_state.keypair, settings: damus_state.settings, note_lang: note_lang)
+        guard should_translate(event: event, our_keypair: damus_state.keypair, note_lang: note_lang) else {
+            return false
+        }
+
+        if TranslationService.isAppleTranslationPopoverSupported {
+            return damus_state.settings.translation_service == .none || damus_state.settings.can_translate
+        } else {
+            return damus_state.settings.can_translate
+        }
     }
     
     var body: some View {
         Group {
             switch self.translations_model.state {
             case .havent_tried:
-                if damus_state.settings.auto_translate {
+                if damus_state.settings.auto_translate && damus_state.settings.translation_service != .none {
                     Text("")
                 } else if let note_lang = translations_model.note_language, should_transl(note_lang)  {
-                        TranslateButton
+                    TranslateButton
                 } else {
                     Text("")
                 }
@@ -114,9 +129,11 @@ extension View {
 }
 
 struct TranslateView_Previews: PreviewProvider {
+    @State static var isAppleTranslationPopoverPresented: Bool = false
+
     static var previews: some View {
         let ds = test_damus_state
-        TranslateView(damus_state: ds, event: test_note, size: .normal)
+        TranslateView(damus_state: ds, event: test_note, size: .normal, isAppleTranslationPopoverPresented: $isAppleTranslationPopoverPresented)
     }
 }
 

damus/ContentParsing.swift

@@ -12,7 +12,7 @@ enum NoteContent {
     case content(String, TagsSequence?)
 
     init(note: NostrEvent, keypair: Keypair) {
-        if note.known_kind == .dm {
+        if note.known_kind == .dm || note.known_kind == .highlight {
             self = .content(note.get_content(keypair), note.tags)
         } else {
             self = .note(note)