chore: bump version

Cargo.toml

@@ -4,7 +4,7 @@ members = ["crates/*"]
 default-members = ["crates/coop"]
 
 [workspace.package]
-version = "0.2.10"
+version = "0.2.7"
 edition = "2021"
 publish = false
 
@@ -58,7 +58,3 @@ opt-level = "z"
 lto = true
 codegen-units = 1
 panic = "abort"
-
-[profile.profiling]
-inherits = "release"
-debug = true

assets/icons/group.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="none" viewBox="0 0 24 24">
-  <path stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M17.75 19.25h2.596c1.163 0 2.106-1.001 1.788-2.12-.733-2.573-2.465-4.38-5.134-4.38-.446 0-.866.05-1.26.147M11.25 7a3.25 3.25 0 1 1-6.5 0 3.25 3.25 0 0 1 6.5 0Zm8.5.5a2.75 2.75 0 1 1-5.5 0 2.75 2.75 0 0 1 5.5 0ZM2.08 18.126c.78-3.14 2.78-5.376 5.92-5.376s5.14 2.237 5.918 5.376c.28 1.128-.658 2.124-1.82 2.124H3.901c-1.162 0-2.1-.996-1.82-2.124Z"/>
-</svg>

assets/icons/server.svg

@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="none" viewBox="0 0 24 24">
-  <path stroke="currentColor" stroke-linecap="square" stroke-linejoin="round" stroke-width="1.5" d="M21.25 12V6.75a2 2 0 0 0-2-2H4.75a2 2 0 0 0-2 2V12m18.5 0H2.75m18.5 0v5.25a2 2 0 0 1-2 2H4.75a2 2 0 0 1-2-2V12"/>
-  <path fill="currentColor" stroke="currentColor" stroke-width=".5" d="M6.5 14.875a.75.75 0 1 1 0 1.5.75.75 0 0 1 0-1.5Zm0-7.25a.75.75 0 1 1 0 1.5.75.75 0 0 1 0-1.5Z"/>
-</svg>

crates/client_keys/src/lib.rs

@@ -1,7 +1,5 @@
-use std::sync::atomic::Ordering;
-
-use global::app_state;
 use global::constants::KEYRING_URL;
+use global::first_run;
 use gpui::{App, AppContext, Context, Entity, Global, Subscription, Window};
 use nostr_sdk::prelude::*;
 use smallvec::{smallvec, SmallVec};
@@ -61,7 +59,6 @@ impl ClientKeys {
             return;
         }
 
-        let app_state = app_state();
         let read_client_keys = cx.read_credentials(KEYRING_URL);
 
         cx.spawn_in(window, async move |this, cx| {
@@ -76,7 +73,7 @@ impl ClientKeys {
                     this.set_keys(Some(keys), false, true, cx);
                 })
                 .ok();
-            } else if app_state.is_first_run.load(Ordering::Acquire) {
+            } else if *first_run() {
                 // If this is the first run, generate new keys and use them for the client keys
                 this.update(cx, |this, cx| {
                     this.new_keys(cx);

crates/common/src/display.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use anyhow::{anyhow, Error};
 use chrono::{Local, TimeZone};
 use global::constants::IMAGE_RESIZE_SERVICE;
-use gpui::{Image, ImageFormat, SharedString, SharedUri};
+use gpui::{Image, ImageFormat};
 use nostr_sdk::prelude::*;
 use qrcode::render::svg;
 use qrcode::QrCode;
@@ -15,92 +15,87 @@ const HOURS_IN_DAY: i64 = 24;
 const DAYS_IN_MONTH: i64 = 30;
 const FALLBACK_IMG: &str = "https://image.nostr.build/c30703b48f511c293a9003be8100cdad37b8798b77a1dc3ec6eb8a20443d5dea.png";
 
-pub trait RenderedProfile {
-    fn avatar(&self, proxy: bool) -> SharedUri;
-    fn display_name(&self) -> SharedString;
+pub trait ReadableProfile {
+    fn avatar_url(&self, proxy: bool) -> String;
+    fn display_name(&self) -> String;
 }
 
-impl RenderedProfile for Profile {
-    fn avatar(&self, proxy: bool) -> SharedUri {
+impl ReadableProfile for Profile {
+    fn avatar_url(&self, proxy: bool) -> String {
         self.metadata()
             .picture
             .as_ref()
             .filter(|picture| !picture.is_empty())
             .map(|picture| {
                 if proxy {
-                    let url = format!(
+                    format!(
                         "{IMAGE_RESIZE_SERVICE}/?url={picture}&w=100&h=100&fit=cover&mask=circle&default={FALLBACK_IMG}&n=-1"
-                    );
-
-                    SharedUri::from(url)
+                    )
                 } else {
-                    SharedUri::from(picture)
+                    picture.into()
                 }
             })
-            .unwrap_or_else(|| SharedUri::from("brand/avatar.png"))
+            .unwrap_or_else(|| "brand/avatar.png".into())
     }
 
-    fn display_name(&self) -> SharedString {
+    fn display_name(&self) -> String {
         if let Some(display_name) = self.metadata().display_name.as_ref() {
             if !display_name.is_empty() {
-                return SharedString::from(display_name);
+                return display_name.into();
             }
         }
 
         if let Some(name) = self.metadata().name.as_ref() {
             if !name.is_empty() {
-                return SharedString::from(name);
+                return name.into();
             }
         }
 
-        SharedString::from(shorten_pubkey(self.public_key(), 4))
+        shorten_pubkey(self.public_key(), 4)
     }
 }
 
-pub trait RenderedTimestamp {
-    fn to_human_time(&self) -> SharedString;
-    fn to_ago(&self) -> SharedString;
+pub trait ReadableTimestamp {
+    fn to_human_time(&self) -> String;
+    fn to_ago(&self) -> String;
 }
 
-impl RenderedTimestamp for Timestamp {
-    fn to_human_time(&self) -> SharedString {
+impl ReadableTimestamp for Timestamp {
+    fn to_human_time(&self) -> String {
         let input_time = match Local.timestamp_opt(self.as_u64() as i64, 0) {
             chrono::LocalResult::Single(time) => time,
-            _ => return SharedString::from("9999"),
+            _ => return "9999".into(),
         };
 
         let now = Local::now();
         let input_date = input_time.date_naive();
         let now_date = now.date_naive();
         let yesterday_date = (now - chrono::Duration::days(1)).date_naive();
+
         let time_format = input_time.format("%H:%M %p");
 
         match input_date {
-            date if date == now_date => SharedString::from(format!("Today at {time_format}")),
-            date if date == yesterday_date => {
-                SharedString::from(format!("Yesterday at {time_format}"))
-            }
-            _ => SharedString::from(format!("{}, {time_format}", input_time.format("%d/%m/%y"))),
+            date if date == now_date => format!("Today at {time_format}"),
+            date if date == yesterday_date => format!("Yesterday at {time_format}"),
+            _ => format!("{}, {time_format}", input_time.format("%d/%m/%y")),
         }
     }
 
-    fn to_ago(&self) -> SharedString {
+    fn to_ago(&self) -> String {
         let input_time = match Local.timestamp_opt(self.as_u64() as i64, 0) {
             chrono::LocalResult::Single(time) => time,
-            _ => return SharedString::from("1m"),
+            _ => return "1m".into(),
         };
 
         let now = Local::now();
         let duration = now.signed_duration_since(input_time);
 
         match duration {
-            d if d.num_seconds() < SECONDS_IN_MINUTE => SharedString::from(NOW),
-            d if d.num_minutes() < MINUTES_IN_HOUR => {
-                SharedString::from(format!("{}m", d.num_minutes()))
-            }
-            d if d.num_hours() < HOURS_IN_DAY => SharedString::from(format!("{}h", d.num_hours())),
-            d if d.num_days() < DAYS_IN_MONTH => SharedString::from(format!("{}d", d.num_days())),
-            _ => SharedString::from(input_time.format("%b %d").to_string()),
+            d if d.num_seconds() < SECONDS_IN_MINUTE => NOW.into(),
+            d if d.num_minutes() < MINUTES_IN_HOUR => format!("{}m", d.num_minutes()),
+            d if d.num_hours() < HOURS_IN_DAY => format!("{}h", d.num_hours()),
+            d if d.num_days() < DAYS_IN_MONTH => format!("{}d", d.num_days()),
+            _ => input_time.format("%b %d").to_string(),
         }
     }
 }

crates/common/src/event.rs

@@ -45,39 +45,3 @@ impl EventUtils for Event {
         a == b
     }
 }
-
-impl EventUtils for UnsignedEvent {
-    fn uniq_id(&self) -> u64 {
-        let mut hasher = DefaultHasher::new();
-        let mut pubkeys: Vec<PublicKey> = vec![];
-
-        // Add all public keys from event
-        pubkeys.push(self.pubkey);
-        pubkeys.extend(self.tags.public_keys().collect::<Vec<_>>());
-
-        // Generate unique hash
-        pubkeys
-            .into_iter()
-            .unique()
-            .sorted()
-            .collect::<Vec<_>>()
-            .hash(&mut hasher);
-
-        hasher.finish()
-    }
-
-    fn all_pubkeys(&self) -> Vec<PublicKey> {
-        let mut public_keys: Vec<PublicKey> = self.tags.public_keys().copied().collect();
-        public_keys.push(self.pubkey);
-
-        public_keys
-    }
-
-    fn compare_pubkeys(&self, other: &[PublicKey]) -> bool {
-        let pubkeys = self.all_pubkeys();
-        let a: HashSet<_> = pubkeys.iter().collect();
-        let b: HashSet<_> = other.iter().collect();
-
-        a == b
-    }
-}

crates/common/src/handle_auth.rs

@@ -0,0 +1,14 @@
+use nostr_connect::prelude::*;
+
+#[derive(Debug, Clone)]
+pub struct CoopAuthUrlHandler;
+
+impl AuthUrlHandler for CoopAuthUrlHandler {
+    fn on_auth_url(&self, auth_url: Url) -> BoxedFuture<Result<()>> {
+        Box::pin(async move {
+            log::info!("Received Auth URL: {auth_url}");
+            webbrowser::open(auth_url.as_str())?;
+            Ok(())
+        })
+    }
+}

crates/common/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod debounced_delay;
 pub mod display;
 pub mod event;
+pub mod handle_auth;
 pub mod nip05;
 pub mod nip96;

crates/coop/Cargo.toml

@@ -14,7 +14,7 @@ product-name = "Coop"
 description = "Chat Freely, Stay Private on Nostr"
 identifier = "su.reya.coop"
 category = "SocialNetworking"
-version = "0.2.10"
+version = "0.2.7"
 out-dir = "../../dist"
 before-packaging-command = "cargo build --release"
 resources = ["Cargo.toml", "src"]
@@ -62,5 +62,5 @@ oneshot.workspace = true
 flume.workspace = true
 webbrowser.workspace = true
 
-indexset = "0.12.3"
 tracing-subscriber = { version = "0.3.18", features = ["fmt"] }
+indexset = "0.12.3"

crates/coop/src/actions.rs

@@ -1,24 +1,10 @@
 use std::sync::Mutex;
 
 use gpui::{actions, App};
-use nostr_connect::prelude::*;
 
 actions!(coop, [ReloadMetadata, DarkMode, Settings, Logout, Quit]);
 actions!(sidebar, [Reload, RelayStatus]);
 
-#[derive(Debug, Clone)]
-pub struct CoopAuthUrlHandler;
-
-impl AuthUrlHandler for CoopAuthUrlHandler {
-    fn on_auth_url(&self, auth_url: Url) -> BoxedFuture<Result<()>> {
-        Box::pin(async move {
-            log::info!("Received Auth URL: {auth_url}");
-            webbrowser::open(auth_url.as_str())?;
-            Ok(())
-        })
-    }
-}
-
 pub fn load_embedded_fonts(cx: &App) {
     let asset_source = cx.asset_source();
     let font_paths = asset_source.list("fonts").unwrap();

crates/coop/src/chatspace.rs

@@ -7,18 +7,19 @@ use std::time::Duration;
 use anyhow::{anyhow, Error};
 use auto_update::AutoUpdater;
 use client_keys::ClientKeys;
-use common::display::RenderedProfile;
+use common::display::ReadableProfile;
 use common::event::EventUtils;
+use flume::{Receiver, Sender};
 use global::constants::{
     ACCOUNT_IDENTIFIER, BOOTSTRAP_RELAYS, DEFAULT_SIDEBAR_WIDTH, METADATA_BATCH_LIMIT,
     METADATA_BATCH_TIMEOUT, SEARCH_RELAYS,
 };
-use global::{app_state, nostr_client, AuthRequest, Notice, SignalKind, UnwrappingStatus};
+use global::{css, ingester, nostr_client, AuthRequest, Notice, Signal, UnwrappingStatus};
 use gpui::prelude::FluentBuilder;
 use gpui::{
-    deferred, div, px, rems, App, AppContext, AsyncWindowContext, Axis, ClipboardItem, Context,
-    Entity, InteractiveElement, IntoElement, ParentElement, Render, SharedString,
-    StatefulInteractiveElement, Styled, Subscription, Task, WeakEntity, Window,
+    div, px, rems, App, AppContext, AsyncWindowContext, Axis, Context, Entity, InteractiveElement,
+    IntoElement, ParentElement, Render, SharedString, StatefulInteractiveElement, Styled,
+    Subscription, Task, WeakEntity, Window,
 };
 use i18n::{shared_t, t};
 use itertools::Itertools;
@@ -30,7 +31,7 @@ use signer_proxy::{BrowserSignerProxy, BrowserSignerProxyOptions};
 use smallvec::{smallvec, SmallVec};
 use theme::{ActiveTheme, Theme, ThemeMode};
 use title_bar::TitleBar;
-use ui::actions::{CopyPublicKey, OpenPublicKey};
+use ui::actions::OpenProfile;
 use ui::avatar::Avatar;
 use ui::button::{Button, ButtonVariants};
 use ui::dock_area::dock::DockPlacement;
@@ -70,13 +71,13 @@ pub struct ChatSpace {
     dock: Entity<DockArea>,
 
     // All authentication requests
-    auth_requests: Entity<HashMap<RelayUrl, AuthRequest>>,
+    auth_requests: HashMap<RelayUrl, AuthRequest>,
 
     // Local state to determine if the user has set up NIP-17 relays
     nip17_relays: bool,
 
     // All subscriptions for observing the app state
-    _subscriptions: SmallVec<[Subscription; 4]>,
+    _subscriptions: SmallVec<[Subscription; 3]>,
 
     // All long running tasks
     _tasks: SmallVec<[Task<()>; 5]>,
@@ -90,18 +91,11 @@ impl ChatSpace {
 
         let title_bar = cx.new(|_| TitleBar::new());
         let dock = cx.new(|cx| DockArea::new(window, cx));
-        let auth_requests = cx.new(|_| HashMap::new());
 
+        let (pubkey_tx, pubkey_rx) = flume::bounded::<PublicKey>(1024);
         let mut subscriptions = smallvec![];
         let mut tasks = smallvec![];
 
-        subscriptions.push(
-            // Automatically sync theme with system appearance
-            window.observe_window_appearance(|window, cx| {
-                Theme::sync_system_appearance(Some(window), cx);
-            }),
-        );
-
         subscriptions.push(
             // Observe the client keys and show an alert modal if they fail to initialize
             cx.observe_in(&client_keys, window, |this, keys, window, cx| {
@@ -153,7 +147,7 @@ impl ChatSpace {
                     .await
                     .expect("Failed connect the bootstrap relays. Please restart the application.");
 
-                Self::process_nostr_events()
+                Self::process_nostr_events(&pubkey_tx)
                     .await
                     .expect("Failed to handle nostr events. Please restart the application.");
             }),
@@ -177,7 +171,7 @@ impl ChatSpace {
         tasks.push(
             // Listen all metadata requests then batch them into single subscription
             cx.background_spawn(async move {
-                Self::process_batching_metadata().await;
+                Self::process_batching_metadata(&pubkey_rx).await;
             }),
         );
 
@@ -191,7 +185,7 @@ impl ChatSpace {
         Self {
             dock,
             title_bar,
-            auth_requests,
+            auth_requests: HashMap::new(),
             nip17_relays: true,
             _subscriptions: subscriptions,
             _tasks: tasks,
@@ -221,7 +215,7 @@ impl ChatSpace {
 
     async fn observe_signer() {
         let client = nostr_client();
-        let app_state = app_state();
+        let ingester = ingester();
         let stream_timeout = Duration::from_secs(5);
         let loop_duration = Duration::from_secs(1);
 
@@ -237,10 +231,7 @@ impl ChatSpace {
             };
 
             // Notify the app that the signer has been set.
-            app_state
-                .signal
-                .send(SignalKind::SignerSet(public_key))
-                .await;
+            ingester.send(Signal::SignerSet(public_key)).await;
 
             // Subscribe to the NIP-65 relays for the public key.
             let filter = Filter::new()
@@ -248,56 +239,44 @@ impl ChatSpace {
                 .author(public_key)
                 .limit(1);
 
-            let mut nip65_found = false;
-
             match client
                 .stream_events_from(BOOTSTRAP_RELAYS, filter, stream_timeout)
                 .await
             {
                 Ok(mut stream) => {
-                    if stream.next().await.is_some() {
-                        nip65_found = true;
+                    let mut processed_ids = HashSet::new();
+
+                    if let Some(event) = stream.next().await {
+                        if processed_ids.insert(event.id) {
+                            // Fetch user's metadata event
+                            Self::fetch_single_event(Kind::Metadata, event.pubkey).await;
+
+                            // Fetch user's contact list event
+                            Self::fetch_single_event(Kind::ContactList, event.pubkey).await;
+
+                            // Fetch user's inbox relays event
+                            Self::fetch_nip17_relays(event.pubkey).await;
+
+                            break;
+                        }
                     } else {
-                        // Timeout
-                        app_state.signal.send(SignalKind::RelaysNotFound).await;
+                        ingester.send(Signal::DmRelayNotFound).await;
                     }
                 }
                 Err(e) => {
-                    log::error!("Error fetching NIP-65 Relay: {e:?}");
-                    app_state.signal.send(SignalKind::RelaysNotFound).await;
+                    log::error!("Error fetching NIP-17 Relay: {e:?}");
+                    ingester.send(Signal::DmRelayNotFound).await;
                 }
             };
 
-            if nip65_found {
-                // Subscribe to the NIP-17 relays for the public key.
-                let filter = Filter::new()
-                    .kind(Kind::InboxRelays)
-                    .author(public_key)
-                    .limit(1);
-
-                match client.stream_events(filter, stream_timeout).await {
-                    Ok(mut stream) => {
-                        if stream.next().await.is_some() {
-                            break;
-                        } else {
-                            // Timeout
-                            app_state.signal.send(SignalKind::RelaysNotFound).await;
-                        }
-                    }
-                    Err(e) => {
-                        log::error!("Error fetching NIP-17 Relay: {e:?}");
-                        app_state.signal.send(SignalKind::RelaysNotFound).await;
-                    }
-                };
-            }
-
             break;
         }
     }
 
     async fn observe_giftwrap() {
         let client = nostr_client();
-        let app_state = app_state();
+        let css = css();
+        let ingester = ingester();
         let loop_duration = Duration::from_secs(20);
         let mut is_start_processing = false;
         let mut total_loops = 0;
@@ -306,25 +285,25 @@ impl ChatSpace {
             if client.has_signer().await {
                 total_loops += 1;
 
-                if app_state.gift_wrap_processing.load(Ordering::Acquire) {
+                if css.gift_wrap_processing.load(Ordering::Acquire) {
                     is_start_processing = true;
 
                     // Reset gift wrap processing flag
-                    let _ = app_state.gift_wrap_processing.compare_exchange(
+                    let _ = css.gift_wrap_processing.compare_exchange(
                         true,
                         false,
                         Ordering::Release,
                         Ordering::Relaxed,
                     );
 
-                    let signal = SignalKind::GiftWrapStatus(UnwrappingStatus::Processing);
-                    app_state.signal.send(signal).await;
+                    let signal = Signal::GiftWrapProcess(UnwrappingStatus::Processing);
+                    ingester.send(signal).await;
                 } else {
                     // Only run further if we are already processing
                     // Wait until after 2 loops to prevent exiting early while events are still being processed
                     if is_start_processing && total_loops >= 2 {
-                        let signal = SignalKind::GiftWrapStatus(UnwrappingStatus::Complete);
-                        app_state.signal.send(signal).await;
+                        let signal = Signal::GiftWrapProcess(UnwrappingStatus::Complete);
+                        ingester.send(signal).await;
 
                         // Reset the counter
                         is_start_processing = false;
@@ -337,8 +316,7 @@ impl ChatSpace {
         }
     }
 
-    async fn process_batching_metadata() {
-        let app_state = app_state();
+    async fn process_batching_metadata(rx: &Receiver<PublicKey>) {
         let timeout = Duration::from_millis(METADATA_BATCH_TIMEOUT);
         let mut processed_pubkeys: HashSet<PublicKey> = HashSet::new();
         let mut batch: HashSet<PublicKey> = HashSet::new();
@@ -353,7 +331,7 @@ impl ChatSpace {
         loop {
             let futs = smol::future::or(
                 async move {
-                    if let Ok(public_key) = app_state.ingester.receiver().recv_async().await {
+                    if let Ok(public_key) = rx.recv_async().await {
                         BatchEvent::PublicKey(public_key)
                     } else {
                         BatchEvent::Closed
@@ -388,9 +366,10 @@ impl ChatSpace {
         }
     }
 
-    async fn process_nostr_events() -> Result<(), Error> {
+    async fn process_nostr_events(pubkey_tx: &Sender<PublicKey>) -> Result<(), Error> {
         let client = nostr_client();
-        let app_state = app_state();
+        let ingester = ingester();
+        let css = css();
 
         let mut processed_events: HashSet<EventId> = HashSet::new();
         let mut challenges: HashSet<Cow<'_, str>> = HashSet::new();
@@ -403,53 +382,12 @@ impl ChatSpace {
 
             match message {
                 RelayMessage::Event { event, .. } => {
-                    // Keep track of which relays have seen this event
-                    app_state
-                        .seen_on_relays
-                        .write()
-                        .await
-                        .entry(event.id)
-                        .or_insert_with(HashSet::new)
-                        .insert(relay_url);
-
                     // Skip events that have already been processed
                     if !processed_events.insert(event.id) {
                         continue;
                     }
 
                     match event.kind {
-                        Kind::RelayList => {
-                            if let Ok(true) = Self::is_self_event(&event).await {
-                                // Fetch user's metadata event
-                                Self::fetch_single_event(Kind::Metadata, event.pubkey).await;
-
-                                // Fetch user's contact list event
-                                Self::fetch_single_event(Kind::ContactList, event.pubkey).await;
-                            }
-                        }
-                        Kind::InboxRelays => {
-                            if let Ok(true) = Self::is_self_event(&event).await {
-                                let relays = nip17::extract_relay_list(&event).collect_vec();
-
-                                if !relays.is_empty() {
-                                    for relay in relays.clone().into_iter() {
-                                        if client.add_relay(relay).await.is_err() {
-                                            let notice = Notice::RelayFailed(relay.clone());
-                                            app_state.signal.send(SignalKind::Notice(notice)).await;
-                                        }
-                                        if client.connect_relay(relay).await.is_err() {
-                                            let notice = Notice::RelayFailed(relay.clone());
-                                            app_state.signal.send(SignalKind::Notice(notice)).await;
-                                        }
-                                    }
-
-                                    // Subscribe to gift wrap events only in the current user's NIP-17 relays
-                                    Self::fetch_gift_wrap(relays, event.pubkey).await;
-                                } else {
-                                    app_state.signal.send(SignalKind::RelaysNotFound).await;
-                                }
-                            }
-                        }
                         Kind::ContactList => {
                             if let Ok(true) = Self::is_self_event(&event).await {
                                 let public_keys = event.tags.public_keys().copied().collect_vec();
@@ -459,54 +397,46 @@ impl ChatSpace {
                                     Filter::new().limit(limit).authors(public_keys).kinds(kinds);
 
                                 client
-                                    .subscribe_to(
-                                        BOOTSTRAP_RELAYS,
-                                        filter,
-                                        app_state.auto_close_opts,
-                                    )
+                                    .subscribe_to(BOOTSTRAP_RELAYS, filter, css.auto_close_opts)
                                     .await
                                     .ok();
                             }
                         }
                         Kind::Metadata => {
-                            let metadata = Metadata::from_json(&event.content).unwrap_or_default();
-                            let profile = Profile::new(event.pubkey, metadata);
-
-                            app_state.signal.send(SignalKind::NewProfile(profile)).await;
+                            if let Ok(metadata) = Metadata::from_json(&event.content) {
+                                let profile = Profile::new(event.pubkey, metadata);
+                                ingester.send(Signal::Metadata(profile)).await;
+                            }
                         }
                         Kind::GiftWrap => {
-                            Self::unwrap_gift_wrap(&event).await;
+                            Self::unwrap_gift_wrap(&event, pubkey_tx).await;
                         }
                         _ => {}
                     }
                 }
                 RelayMessage::EndOfStoredEvents(subscription_id) => {
-                    if *subscription_id == app_state.gift_wrap_sub_id {
-                        let signal = SignalKind::GiftWrapStatus(UnwrappingStatus::Processing);
-                        app_state.signal.send(signal).await;
+                    if *subscription_id == css.gift_wrap_sub_id {
+                        let signal = Signal::GiftWrapProcess(UnwrappingStatus::Processing);
+                        ingester.send(signal).await;
                     }
                 }
                 RelayMessage::Auth { challenge } => {
                     if challenges.insert(challenge.clone()) {
                         let req = AuthRequest::new(challenge, relay_url);
                         // Send a signal to the ingester to handle the auth request
-                        app_state.signal.send(SignalKind::Auth(req)).await;
+                        ingester.send(Signal::Auth(req)).await;
                     }
                 }
                 RelayMessage::Ok {
                     event_id, message, ..
                 } => {
                     // Keep track of events sent by Coop
-                    app_state.sent_ids.write().await.insert(event_id);
+                    css.sent_ids.write().await.insert(event_id);
 
                     // Keep track of events that need to be resent
                     match MachineReadablePrefix::parse(&message) {
                         Some(MachineReadablePrefix::AuthRequired) => {
-                            app_state
-                                .resend_queue
-                                .write()
-                                .await
-                                .insert(event_id, relay_url);
+                            css.resend_queue.write().await.insert(event_id, relay_url);
                         }
                         Some(_) => {}
                         None => {}
@@ -520,16 +450,17 @@ impl ChatSpace {
     }
 
     async fn process_nostr_signals(view: WeakEntity<ChatSpace>, cx: &mut AsyncWindowContext) {
-        let app_state = app_state();
+        let ingester = ingester();
+        let signals = ingester.signals();
         let mut is_open_proxy_modal = false;
 
-        while let Ok(signal) = app_state.signal.receiver().recv_async().await {
+        while let Ok(signal) = signals.recv_async().await {
             cx.update(|window, cx| {
                 let registry = Registry::global(cx);
                 let settings = AppSettings::global(cx);
 
                 match signal {
-                    SignalKind::SignerSet(public_key) => {
+                    Signal::SignerSet(public_key) => {
                         window.close_modal(cx);
 
                         // Setup the default layout for current workspace
@@ -549,7 +480,7 @@ impl ChatSpace {
                             this.load_rooms(window, cx);
                         });
                     }
-                    SignalKind::SignerUnset => {
+                    Signal::SignerUnset => {
                         // Setup the onboarding layout for current workspace
                         view.update(cx, |this, cx| {
                             this.set_onboarding_layout(window, cx);
@@ -561,7 +492,7 @@ impl ChatSpace {
                             this.reset(cx);
                         });
                     }
-                    SignalKind::Auth(req) => {
+                    Signal::Auth(req) => {
                         let url = &req.url;
                         let auto_auth = AppSettings::get_auto_auth(cx);
                         let is_authenticated = AppSettings::read_global(cx).is_authenticated(url);
@@ -579,7 +510,7 @@ impl ChatSpace {
                         })
                         .ok();
                     }
-                    SignalKind::ProxyDown => {
+                    Signal::ProxyDown => {
                         if !is_open_proxy_modal {
                             is_open_proxy_modal = true;
 
@@ -589,28 +520,28 @@ impl ChatSpace {
                             .ok();
                         }
                     }
-                    SignalKind::GiftWrapStatus(status) => {
+                    Signal::GiftWrapProcess(status) => {
                         registry.update(cx, |this, cx| {
                             this.set_unwrapping_status(status, cx);
                         });
                     }
-                    SignalKind::NewProfile(profile) => {
+                    Signal::Metadata(profile) => {
                         registry.update(cx, |this, cx| {
                             this.insert_or_update_person(profile, cx);
                         });
                     }
-                    SignalKind::NewMessage((gift_wrap_id, event)) => {
+                    Signal::Message((gift_wrap_id, event)) => {
                         registry.update(cx, |this, cx| {
                             this.event_to_message(gift_wrap_id, event, window, cx);
                         });
                     }
-                    SignalKind::RelaysNotFound => {
+                    Signal::DmRelayNotFound => {
                         view.update(cx, |this, cx| {
                             this.set_required_relays(cx);
                         })
                         .ok();
                     }
-                    SignalKind::Notice(msg) => {
+                    Signal::Notice(msg) => {
                         window.push_notification(msg.as_str(), cx);
                     }
                 };
@@ -631,22 +562,64 @@ impl ChatSpace {
     /// Fetches a single event by kind and public key
     pub async fn fetch_single_event(kind: Kind, public_key: PublicKey) {
         let client = nostr_client();
-        let app_state = app_state();
+        let css = css();
         let filter = Filter::new().kind(kind).author(public_key).limit(1);
 
-        if let Err(e) = client.subscribe(filter, app_state.auto_close_opts).await {
+        if let Err(e) = client.subscribe(filter, css.auto_close_opts).await {
             log::info!("Failed to subscribe: {e}");
         }
     }
 
-    /// Fetches gift wrap events for a given public key and relays
+    pub async fn fetch_nip17_relays(public_key: PublicKey) {
+        let client = nostr_client();
+        let ingester = ingester();
+        let filter = Filter::new()
+            .kind(Kind::InboxRelays)
+            .author(public_key)
+            .limit(1);
+
+        match client.stream_events(filter, Duration::from_secs(5)).await {
+            Ok(mut stream) => {
+                let mut processed_ids = HashSet::new();
+
+                if let Some(event) = stream.next().await {
+                    if processed_ids.insert(event.id) {
+                        let relays = nip17::extract_relay_list(&event).collect_vec();
+
+                        if !relays.is_empty() {
+                            for relay in relays.clone().into_iter() {
+                                if client.add_relay(relay).await.is_err() {
+                                    let notice = Notice::RelayFailed(relay.clone());
+                                    ingester.send(Signal::Notice(notice)).await;
+                                }
+                                if client.connect_relay(relay).await.is_err() {
+                                    let notice = Notice::RelayFailed(relay.clone());
+                                    ingester.send(Signal::Notice(notice)).await;
+                                }
+                            }
+
+                            // Subscribe to gift wrap events only in the current user's NIP-17 relays
+                            Self::fetch_gift_wrap(relays, event.pubkey).await;
+                        }
+                    }
+                } else {
+                    ingester.send(Signal::DmRelayNotFound).await;
+                }
+            }
+            Err(e) => {
+                log::error!("Error fetching NIP-17 Relay: {e:?}");
+                ingester.send(Signal::DmRelayNotFound).await;
+            }
+        };
+    }
+
     pub async fn fetch_gift_wrap(relays: Vec<&RelayUrl>, public_key: PublicKey) {
         let client = nostr_client();
-        let id = app_state().gift_wrap_sub_id.clone();
+        let sub_id = css().gift_wrap_sub_id.clone();
         let filter = Filter::new().kind(Kind::GiftWrap).pubkey(public_key);
 
         if client
-            .subscribe_with_id_to(relays.clone(), id, filter, None)
+            .subscribe_with_id_to(relays.clone(), sub_id, filter, None)
             .await
             .is_ok()
         {
@@ -661,7 +634,7 @@ impl ChatSpace {
         }
 
         let client = nostr_client();
-        let app_state = app_state();
+        let css = css();
 
         let kinds = vec![Kind::Metadata, Kind::ContactList, Kind::RelayList];
         let limit = public_keys.len() * kinds.len() + 20;
@@ -670,13 +643,13 @@ impl ChatSpace {
         let filter = Filter::new().authors(public_keys).kinds(kinds).limit(limit);
 
         client
-            .subscribe_to(BOOTSTRAP_RELAYS, filter, app_state.auto_close_opts)
+            .subscribe_to(BOOTSTRAP_RELAYS, filter, css.auto_close_opts)
             .await
             .ok();
     }
 
     /// Stores an unwrapped event in local database with reference to original
-    async fn set_unwrapped_event(gift_wrap: EventId, unwrapped: &Event) -> Result<(), Error> {
+    async fn set_unwrapped_event(root: EventId, unwrapped: &Event) -> Result<(), Error> {
         let client = nostr_client();
 
         // Save unwrapped event
@@ -684,7 +657,7 @@ impl ChatSpace {
 
         // Create a reference event pointing to the unwrapped event
         let event = EventBuilder::new(Kind::ApplicationSpecificData, "")
-            .tags(vec![Tag::identifier(gift_wrap), Tag::event(unwrapped.id)])
+            .tags(vec![Tag::identifier(root), Tag::event(unwrapped.id)])
             .sign(&Keys::generate())
             .await?;
 
@@ -716,9 +689,10 @@ impl ChatSpace {
     }
 
     /// Unwraps a gift-wrapped event and processes its contents.
-    async fn unwrap_gift_wrap(target: &Event) {
+    async fn unwrap_gift_wrap(target: &Event, pubkey_tx: &Sender<PublicKey>) {
         let client = nostr_client();
-        let app_state = app_state();
+        let ingester = ingester();
+        let css = css();
         let mut message: Option<Event> = None;
 
         if let Ok(event) = Self::get_unwrapped_event(target.id).await {
@@ -738,22 +712,18 @@ impl ChatSpace {
         if let Some(event) = message {
             // Send all pubkeys to the metadata batch to sync data
             for public_key in event.all_pubkeys() {
-                app_state.ingester.send(public_key).await;
+                pubkey_tx.send_async(public_key).await.ok();
             }
 
-            match event.created_at >= app_state.init_at {
+            match event.created_at >= css.init_at {
                 // New message: send a signal to notify the UI
                 true => {
-                    app_state
-                        .signal
-                        .send(SignalKind::NewMessage((target.id, event)))
-                        .await;
+                    smol::Timer::after(Duration::from_millis(200)).await;
+                    ingester.send(Signal::Message((target.id, event))).await;
                 }
                 // Old message: Coop is probably processing the user's messages during initial load
                 false => {
-                    app_state
-                        .gift_wrap_processing
-                        .store(true, Ordering::Release);
+                    css.gift_wrap_processing.store(true, Ordering::Release);
                 }
             }
         }
@@ -804,7 +774,7 @@ impl ChatSpace {
 
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
             let client = nostr_client();
-            let app_state = app_state();
+            let css = css();
             let signer = client.signer().await?;
 
             // Construct event
@@ -835,7 +805,7 @@ impl ChatSpace {
                             relay.resubscribe().await?;
 
                             // Get all failed events that need to be resent
-                            let mut queue = app_state.resend_queue.write().await;
+                            let mut queue = css.resend_queue.write().await;
 
                             let ids: Vec<EventId> = queue
                                 .iter()
@@ -854,8 +824,8 @@ impl ChatSpace {
                                             success: HashSet::from([relay_url]),
                                         };
 
-                                        app_state.sent_ids.write().await.insert(event_id);
-                                        app_state.resent_ids.write().await.push(output);
+                                        css.sent_ids.write().await.insert(event_id);
+                                        css.resent_ids.write().await.push(output);
                                     }
                                 }
                             }
@@ -960,33 +930,28 @@ impl ChatSpace {
     }
 
     fn reopen_auth_request(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        for (_, request) in self.auth_requests.read(cx).clone() {
+        for (_, request) in self.auth_requests.clone().into_iter() {
             self.open_auth_request(request, window, cx);
         }
     }
 
     fn push_auth_request(&mut self, req: &AuthRequest, cx: &mut Context<Self>) {
-        self.auth_requests.update(cx, |this, cx| {
-            this.insert(req.url.clone(), req.to_owned());
-            cx.notify();
-        });
+        self.auth_requests.insert(req.url.clone(), req.to_owned());
+        cx.notify();
     }
 
     fn sending_auth_request(&mut self, challenge: &str, cx: &mut Context<Self>) {
-        self.auth_requests.update(cx, |this, cx| {
-            for (_, req) in this.iter_mut() {
-                if req.challenge == challenge {
-                    req.sending = true;
-                    cx.notify();
-                }
+        for (_, req) in self.auth_requests.iter_mut() {
+            if req.challenge == challenge {
+                req.sending = true;
+                cx.notify();
             }
-        });
+        }
     }
 
-    fn is_sending_auth_request(&self, challenge: &str, cx: &App) -> bool {
+    fn is_sending_auth_request(&self, challenge: &str, _cx: &App) -> bool {
         if let Some(req) = self
             .auth_requests
-            .read(cx)
             .iter()
             .find(|(_, req)| req.challenge == challenge)
         {
@@ -997,10 +962,8 @@ impl ChatSpace {
     }
 
     fn remove_auth_request(&mut self, challenge: &str, cx: &mut Context<Self>) {
-        self.auth_requests.update(cx, |this, cx| {
-            this.retain(|_, r| r.challenge != challenge);
-            cx.notify();
-        });
+        self.auth_requests.retain(|_, r| r.challenge != challenge);
+        cx.notify();
     }
 
     fn set_onboarding_layout(&mut self, window: &mut Window, cx: &mut Context<Self>) {
@@ -1020,7 +983,7 @@ impl ChatSpace {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let panel = Arc::new(account::init(profile, secret, window, cx));
+        let panel = Arc::new(account::init(secret, profile, window, cx));
         let center = DockItem::panel(panel);
 
         self.dock.update(cx, |this, cx| {
@@ -1120,7 +1083,7 @@ impl ChatSpace {
     ) {
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
             let client = nostr_client();
-            let app_state = app_state();
+            let css = css();
 
             let filter = Filter::new().kind(Kind::PrivateDirectMessage);
 
@@ -1139,7 +1102,7 @@ impl ChatSpace {
                 .authors(pubkeys);
 
             client
-                .subscribe_to(BOOTSTRAP_RELAYS, filter, app_state.auto_close_opts)
+                .subscribe_to(BOOTSTRAP_RELAYS, filter, css.auto_close_opts)
                 .await?;
 
             Ok(())
@@ -1159,7 +1122,7 @@ impl ChatSpace {
     fn on_sign_out(&mut self, _e: &Logout, _window: &mut Window, cx: &mut Context<Self>) {
         cx.background_spawn(async move {
             let client = nostr_client();
-            let app_state = app_state();
+            let ingester = ingester();
 
             let filter = Filter::new()
                 .kind(Kind::ApplicationSpecificData)
@@ -1172,12 +1135,12 @@ impl ChatSpace {
             client.reset().await;
 
             // Notify the channel about the signer being unset
-            app_state.signal.send(SignalKind::SignerUnset).await;
+            ingester.send(Signal::SignerUnset).await;
         })
         .detach();
     }
 
-    fn on_open_pubkey(&mut self, ev: &OpenPublicKey, window: &mut Window, cx: &mut Context<Self>) {
+    fn on_open_profile(&mut self, ev: &OpenProfile, window: &mut Window, cx: &mut Context<Self>) {
         let public_key = ev.0;
         let profile = user_profile::init(public_key, window, cx);
 
@@ -1195,12 +1158,6 @@ impl ChatSpace {
         });
     }
 
-    fn on_copy_pubkey(&mut self, ev: &CopyPublicKey, window: &mut Window, cx: &mut Context<Self>) {
-        let Ok(bech32) = ev.0.to_bech32();
-        cx.write_to_clipboard(ClipboardItem::new_string(bech32));
-        window.push_notification(t!("common.copied"), cx);
-    }
-
     fn render_proxy_modal(&mut self, window: &mut Window, cx: &mut App) {
         window.open_modal(cx, |this, _window, _cx| {
             this.overlay_closable(false)
@@ -1288,7 +1245,7 @@ impl ChatSpace {
             .w_full()
             .child(compose_button())
             .when(status != &UnwrappingStatus::Complete, |this| {
-                this.child(deferred(
+                this.child(
                     h_flex()
                         .px_2()
                         .h_6()
@@ -1297,7 +1254,7 @@ impl ChatSpace {
                         .rounded_full()
                         .bg(cx.theme().surface_background)
                         .child(shared_t!("loading.label")),
-                ))
+                )
             })
     }
 
@@ -1310,7 +1267,7 @@ impl ChatSpace {
         let proxy = AppSettings::get_proxy_user_avatars(cx);
         let updating = AutoUpdater::read_global(cx).status.is_updating();
         let updated = AutoUpdater::read_global(cx).status.is_updated();
-        let auth_requests = self.auth_requests.read(cx).len();
+        let auth_requests = self.auth_requests.len();
 
         h_flex()
             .gap_1()
@@ -1375,7 +1332,7 @@ impl ChatSpace {
                     .reverse()
                     .transparent()
                     .icon(IconName::CaretDown)
-                    .child(Avatar::new(profile.avatar(proxy)).size(rems(1.49)))
+                    .child(Avatar::new(profile.avatar_url(proxy)).size(rems(1.49)))
                     .popup_menu(|this, _window, _cx| {
                         this.menu(t!("user.dark_mode"), Box::new(DarkMode))
                             .menu(t!("user.settings"), Box::new(Settings))
@@ -1402,7 +1359,7 @@ impl ChatSpace {
 
             this._tasks.push(cx.background_spawn(async move {
                 let client = nostr_client();
-                let app_state = app_state();
+                let ingester = ingester();
 
                 if proxy.start().await.is_ok() {
                     webbrowser::open(&url).ok();
@@ -1433,7 +1390,7 @@ impl ChatSpace {
 
                             break;
                         } else {
-                            app_state.signal.send(SignalKind::ProxyDown).await;
+                            ingester.send(Signal::ProxyDown).await;
                         }
                         smol::Timer::after(Duration::from_secs(1)).await;
                     }
@@ -1498,12 +1455,10 @@ impl Render for ChatSpace {
         }
 
         div()
-            .id(SharedString::from("chatspace"))
             .on_action(cx.listener(Self::on_settings))
             .on_action(cx.listener(Self::on_dark_mode))
             .on_action(cx.listener(Self::on_sign_out))
-            .on_action(cx.listener(Self::on_open_pubkey))
-            .on_action(cx.listener(Self::on_copy_pubkey))
+            .on_action(cx.listener(Self::on_open_profile))
             .on_action(cx.listener(Self::on_reload_metadata))
             .relative()
             .size_full()

crates/coop/src/main.rs

@@ -2,12 +2,13 @@ use std::sync::Arc;
 
 use assets::Assets;
 use global::constants::{APP_ID, APP_NAME};
-use global::{app_state, nostr_client};
+use global::{css, ingester, nostr_client};
 use gpui::{
     point, px, size, AppContext, Application, Bounds, KeyBinding, Menu, MenuItem, SharedString,
     TitlebarOptions, WindowBackgroundAppearance, WindowBounds, WindowDecorations, WindowKind,
     WindowOptions,
 };
+use theme::Theme;
 use ui::Root;
 
 use crate::actions::{load_embedded_fonts, quit, Quit};
@@ -25,8 +26,11 @@ fn main() {
     // Initialize the Nostr client
     let _client = nostr_client();
 
+    // Initialize the ingester
+    let _ingester = ingester();
+
     // Initialize the coop simple storage
-    let _app_state = app_state();
+    let _css = css();
 
     // Initialize the Application
     let app = Application::new()
@@ -78,6 +82,13 @@ fn main() {
             // Bring the app to the foreground
             cx.activate(true);
 
+            // Automatically sync theme with system appearance
+            window
+                .observe_window_appearance(|window, cx| {
+                    Theme::sync_system_appearance(Some(window), cx);
+                })
+                .detach();
+
             // Root Entity
             cx.new(|cx| {
                 // Initialize the tokio runtime

crates/coop/src/views/account.rs

@@ -2,15 +2,15 @@ use std::time::Duration;
 
 use anyhow::Error;
 use client_keys::ClientKeys;
-use common::display::RenderedProfile;
+use common::display::ReadableProfile;
+use common::handle_auth::CoopAuthUrlHandler;
 use global::constants::{ACCOUNT_IDENTIFIER, BUNKER_TIMEOUT};
-use global::{app_state, nostr_client, SignalKind};
+use global::{ingester, nostr_client, Signal};
 use gpui::prelude::FluentBuilder;
 use gpui::{
     div, relative, rems, svg, AnyElement, App, AppContext, Context, Entity, EventEmitter,
-    FocusHandle, Focusable, InteractiveElement, IntoElement, ParentElement, Render,
-    RetainAllImageCache, SharedString, StatefulInteractiveElement, Styled, Subscription, Task,
-    WeakEntity, Window,
+    FocusHandle, Focusable, InteractiveElement, IntoElement, ParentElement, Render, SharedString,
+    StatefulInteractiveElement, Styled, Task, WeakEntity, Window,
 };
 use i18n::{shared_t, t};
 use nostr_connect::prelude::*;
@@ -22,20 +22,18 @@ use ui::button::{Button, ButtonVariants};
 use ui::dock_area::panel::{Panel, PanelEvent};
 use ui::indicator::Indicator;
 use ui::input::{InputState, TextInput};
-use ui::notification::Notification;
 use ui::popup_menu::PopupMenu;
-use ui::{h_flex, v_flex, ContextModal, Sizable, StyledExt};
+use ui::{h_flex, v_flex, ContextModal, Disableable, Sizable, StyledExt};
 
-use crate::actions::CoopAuthUrlHandler;
 use crate::chatspace::ChatSpace;
 
 pub fn init(
-    profile: Profile,
     secret: String,
+    profile: Profile,
     window: &mut Window,
     cx: &mut App,
 ) -> Entity<Account> {
-    cx.new(|cx| Account::new(secret, profile, window, cx))
+    Account::new(secret, profile, window, cx)
 }
 
 pub struct Account {
@@ -44,33 +42,18 @@ pub struct Account {
     is_bunker: bool,
     is_extension: bool,
     loading: bool,
-
+    // Panel
     name: SharedString,
     focus_handle: FocusHandle,
-    image_cache: Entity<RetainAllImageCache>,
-
-    _subscriptions: SmallVec<[Subscription; 1]>,
     _tasks: SmallVec<[Task<()>; 1]>,
 }
 
 impl Account {
-    fn new(secret: String, profile: Profile, window: &mut Window, cx: &mut Context<Self>) -> Self {
+    fn new(secret: String, profile: Profile, _window: &mut Window, cx: &mut App) -> Entity<Self> {
         let is_bunker = secret.starts_with("bunker://");
         let is_extension = secret.starts_with("extension");
 
-        let mut subscriptions = smallvec![];
-
-        subscriptions.push(
-            // Clear the local state when user closes the account panel
-            cx.on_release_in(window, move |this, window, cx| {
-                this.stored_secret.clear();
-                this.image_cache.update(cx, |this, cx| {
-                    this.clear(window, cx);
-                });
-            }),
-        );
-
-        Self {
+        cx.new(|cx| Self {
             profile,
             is_bunker,
             is_extension,
@@ -78,10 +61,8 @@ impl Account {
             loading: false,
             name: "Account".into(),
             focus_handle: cx.focus_handle(),
-            image_cache: RetainAllImageCache::new(cx),
-            _subscriptions: subscriptions,
             _tasks: smallvec![],
-        }
+        })
     }
 
     fn login(&mut self, window: &mut Window, cx: &mut Context<Self>) {
@@ -112,8 +93,8 @@ impl Account {
         signer.auth_url_handler(CoopAuthUrlHandler);
 
         self._tasks.push(
-            // Handle connection in the background
-            cx.spawn_in(window, async move |this, cx| {
+            // Handle connection
+            cx.spawn_in(window, async move |_this, cx| {
                 let client = nostr_client();
 
                 match signer.bunker_uri().await {
@@ -122,9 +103,8 @@ impl Account {
                         client.set_signer(signer).await;
                     }
                     Err(e) => {
-                        this.update_in(cx, |this, window, cx| {
-                            this.set_loading(false, cx);
-                            window.push_notification(Notification::error(e.to_string()), cx);
+                        cx.update(|window, cx| {
+                            window.push_notification(e.to_string(), cx);
                         })
                         .ok();
                     }
@@ -268,7 +248,7 @@ impl Account {
             // Reset the nostr client in the background
             cx.background_spawn(async move {
                 let client = nostr_client();
-                let app_state = app_state();
+                let ingester = ingester();
 
                 let filter = Filter::new()
                     .kind(Kind::ApplicationSpecificData)
@@ -281,7 +261,7 @@ impl Account {
                 client.unset_signer().await;
 
                 // Notify the channel about the signer being unset
-                app_state.signal.send(SignalKind::SignerUnset).await;
+                ingester.send(Signal::SignerUnset).await;
             }),
         );
     }
@@ -321,7 +301,6 @@ impl Focusable for Account {
 impl Render for Account {
     fn render(&mut self, _window: &mut gpui::Window, cx: &mut Context<Self>) -> impl IntoElement {
         v_flex()
-            .image_cache(self.image_cache.clone())
             .relative()
             .size_full()
             .gap_10()
@@ -363,72 +342,46 @@ impl Render for Account {
                             .id("account")
                             .h_10()
                             .w_72()
-                            .bg(cx.theme().elevated_surface_background)
+                            .bg(cx.theme().element_background)
+                            .text_color(cx.theme().element_foreground)
                             .rounded_lg()
                             .text_sm()
-                            .when(self.loading, |this| {
-                                this.child(
-                                    div()
-                                        .size_full()
-                                        .flex()
-                                        .items_center()
-                                        .justify_center()
-                                        .child(Indicator::new().small()),
-                                )
-                            })
-                            .when(!self.loading, |this| {
-                                let avatar = self.profile.avatar(true);
-                                let name = self.profile.display_name();
-
-                                this.child(
-                                    h_flex()
-                                        .h_full()
-                                        .justify_center()
-                                        .gap_2()
-                                        .child(
-                                            h_flex()
-                                                .gap_1()
-                                                .child(Avatar::new(avatar).size(rems(1.5)))
-                                                .child(div().pb_px().font_semibold().child(name)),
-                                        )
-                                        .child(
-                                            div()
-                                                .when(self.is_bunker, |this| {
-                                                    let label = SharedString::from("Nostr Connect");
-
-                                                    this.child(
-                                                        div()
-                                                            .py_0p5()
-                                                            .px_2()
-                                                            .text_xs()
-                                                            .bg(cx.theme().secondary_active)
-                                                            .text_color(
-                                                                cx.theme().secondary_foreground,
-                                                            )
-                                                            .rounded_full()
-                                                            .child(label),
+                            .map(|this| {
+                                if self.loading {
+                                    this.child(
+                                        div()
+                                            .size_full()
+                                            .flex()
+                                            .items_center()
+                                            .justify_center()
+                                            .child(Indicator::new().small()),
+                                    )
+                                } else {
+                                    this.child(
+                                        div()
+                                            .h_full()
+                                            .flex()
+                                            .items_center()
+                                            .justify_center()
+                                            .gap_2()
+                                            .child(shared_t!("onboarding.choose_account"))
+                                            .child(
+                                                h_flex()
+                                                    .gap_1()
+                                                    .child(
+                                                        Avatar::new(self.profile.avatar_url(true))
+                                                            .size(rems(1.5)),
                                                     )
-                                                })
-                                                .when(self.is_extension, |this| {
-                                                    let label = SharedString::from("Extension");
-
-                                                    this.child(
+                                                    .child(
                                                         div()
-                                                            .py_0p5()
-                                                            .px_2()
-                                                            .text_xs()
-                                                            .bg(cx.theme().secondary_active)
-                                                            .text_color(
-                                                                cx.theme().secondary_foreground,
-                                                            )
-                                                            .rounded_full()
-                                                            .child(label),
-                                                    )
-                                                }),
-                                        ),
-                                )
+                                                            .pb_px()
+                                                            .font_semibold()
+                                                            .child(self.profile.display_name()),
+                                                    ),
+                                            ),
+                                    )
+                                }
                             })
-                            .active(|this| this.bg(cx.theme().element_active))
                             .hover(|this| this.bg(cx.theme().element_hover))
                             .on_click(cx.listener(move |this, _e, window, cx| {
                                 this.login(window, cx);
@@ -438,6 +391,7 @@ impl Render for Account {
                         Button::new("logout")
                             .label(t!("user.sign_out"))
                             .ghost()
+                            .disabled(self.loading)
                             .on_click(cx.listener(move |this, _e, window, cx| {
                                 this.logout(window, cx);
                             })),

crates/coop/src/views/chat/mod.rs

@@ -1,14 +1,13 @@
-use std::collections::{HashMap, HashSet};
-
-use common::display::{RenderedProfile, RenderedTimestamp};
+use anyhow::anyhow;
+use common::display::{ReadableProfile, ReadableTimestamp};
 use common::nip96::nip96_upload;
-use global::{app_state, nostr_client};
+use global::{css, nostr_client};
 use gpui::prelude::FluentBuilder;
 use gpui::{
     div, img, list, px, red, relative, rems, svg, white, Action, AnyElement, App, AppContext,
     ClipboardItem, Context, Element, Entity, EventEmitter, Flatten, FocusHandle, Focusable,
     InteractiveElement, IntoElement, ListAlignment, ListOffset, ListState, MouseButton, ObjectFit,
-    ParentElement, PathPromptOptions, Render, RetainAllImageCache, SharedString, SharedUri,
+    ParentElement, PathPromptOptions, Render, RetainAllImageCache, SharedString,
     StatefulInteractiveElement, Styled, StyledImage, Subscription, Task, Window,
 };
 use gpui_tokio::Tokio;
@@ -24,16 +23,13 @@ use settings::AppSettings;
 use smallvec::{smallvec, SmallVec};
 use smol::fs;
 use theme::ActiveTheme;
-use ui::actions::{CopyPublicKey, OpenPublicKey};
 use ui::avatar::Avatar;
-use ui::button::{Button, ButtonVariants};
-use ui::context_menu::ContextMenuExt;
+use ui::button::{Button, ButtonRounded, ButtonVariants};
 use ui::dock_area::panel::{Panel, PanelEvent};
 use ui::emoji_picker::EmojiPicker;
 use ui::input::{InputEvent, InputState, TextInput};
 use ui::modal::ModalButtonProps;
-use ui::notification::Notification;
-use ui::popup_menu::{PopupMenu, PopupMenuExt};
+use ui::popup_menu::PopupMenu;
 use ui::text::RenderedText;
 use ui::{
     h_flex, v_flex, ContextModal, Disableable, Icon, IconName, InteractiveElementExt, Sizable,
@@ -44,7 +40,7 @@ mod subject;
 
 #[derive(Action, Clone, PartialEq, Eq, Deserialize)]
 #[action(namespace = chat, no_json)]
-pub struct SeenOn(pub EventId);
+pub struct ChangeSubject(pub String);
 
 pub fn init(room: Entity<Room>, window: &mut Window, cx: &mut App) -> Entity<Chat> {
     cx.new(|cx| Chat::new(room, window, cx))
@@ -53,9 +49,6 @@ pub fn init(room: Entity<Room>, window: &mut Window, cx: &mut App) -> Entity<Cha
 pub struct Chat {
     // Chat Room
     room: Entity<Room>,
-    relays: Entity<HashMap<PublicKey, Vec<RelayUrl>>>,
-
-    // Messages
     list_state: ListState,
     messages: BTreeSet<Message>,
     rendered_texts_by_id: BTreeMap<EventId, RenderedText>,
@@ -63,7 +56,7 @@ pub struct Chat {
 
     // New Message
     input: Entity<InputState>,
-    replies_to: Entity<HashSet<EventId>>,
+    replies_to: Entity<Vec<EventId>>,
 
     // Media Attachment
     attachments: Entity<Vec<Url>>,
@@ -74,60 +67,33 @@ pub struct Chat {
     focus_handle: FocusHandle,
     image_cache: Entity<RetainAllImageCache>,
 
-    _subscriptions: SmallVec<[Subscription; 4]>,
-    _tasks: SmallVec<[Task<()>; 2]>,
+    _subscriptions: SmallVec<[Subscription; 2]>,
+    _tasks: SmallVec<[Task<()>; 1]>,
 }
 
 impl Chat {
     pub fn new(room: Entity<Room>, window: &mut Window, cx: &mut Context<Self>) -> Self {
         let attachments = cx.new(|_| vec![]);
-        let replies_to = cx.new(|_| HashSet::new());
-
-        let relays = cx.new(|_| {
-            let this: HashMap<PublicKey, Vec<RelayUrl>> = HashMap::new();
-            this
-        });
-
+        let replies_to = cx.new(|_| vec![]);
         let input = cx.new(|cx| {
             InputState::new(window, cx)
                 .placeholder(t!("chat.placeholder"))
-                .auto_grow(1, 20)
+                .multi_line()
                 .prevent_new_line_on_enter()
+                .rows(1)
+                .multi_line()
+                .auto_grow(1, 20)
                 .clean_on_escape()
         });
 
         let messages = BTreeSet::from([Message::system()]);
         let list_state = ListState::new(messages.len(), ListAlignment::Bottom, px(1024.));
 
-        let connect_relays = room.read(cx).connect_relays(cx);
         let load_messages = room.read(cx).load_messages(cx);
 
         let mut subscriptions = smallvec![];
         let mut tasks = smallvec![];
 
-        tasks.push(
-            // Load all messages belonging to this room
-            cx.spawn_in(window, async move |this, cx| {
-                match connect_relays.await {
-                    Ok(relays) => {
-                        this.update(cx, |this, cx| {
-                            this.relays.update(cx, |this, cx| {
-                                *this = relays;
-                                cx.notify();
-                            });
-                        })
-                        .ok();
-                    }
-                    Err(e) => {
-                        cx.update(|window, cx| {
-                            window.push_notification(e.to_string(), cx);
-                        })
-                        .ok();
-                    }
-                };
-            }),
-        );
-
         tasks.push(
             // Load all messages belonging to this room
             cx.spawn_in(window, async move |this, cx| {
@@ -154,8 +120,14 @@ impl Chat {
                 &input,
                 window,
                 move |this: &mut Self, _input, event, window, cx| {
-                    if let InputEvent::PressEnter { .. } = event {
-                        this.send_message(window, cx);
+                    match event {
+                        InputEvent::PressEnter { .. } => {
+                            this.send_message(window, cx);
+                        }
+                        InputEvent::Change(_) => {
+                            // this.mention_popup(text, input, cx);
+                        }
+                        _ => {}
                     };
                 },
             ),
@@ -166,21 +138,9 @@ impl Chat {
             cx.subscribe_in(&room, window, move |this, _, signal, window, cx| {
                 match signal {
                     RoomSignal::NewMessage((gift_wrap_id, event)) => {
-                        let gift_wrap_id = gift_wrap_id.to_owned();
-                        let message = Message::user(event);
-
-                        cx.spawn_in(window, async move |this, cx| {
-                            let app_state = app_state();
-                            let sent_ids = app_state.sent_ids.read().await;
-
-                            this.update_in(cx, |this, _window, cx| {
-                                if !sent_ids.contains(&gift_wrap_id) {
-                                    this.insert_message(message, false, cx);
-                                }
-                            })
-                            .ok();
-                        })
-                        .detach();
+                        if !this.is_sent_by_coop(gift_wrap_id) {
+                            this.insert_message(event, false, cx);
+                        }
                     }
                     RoomSignal::Refresh => {
                         this.load_messages(window, cx);
@@ -189,66 +149,24 @@ impl Chat {
             }),
         );
 
-        subscriptions.push(
-            // Observe the messaging relays of the room's members
-            cx.observe_in(&relays, window, |this, entity, _window, cx| {
-                for (public_key, urls) in entity.read(cx).clone().into_iter() {
-                    if urls.is_empty() {
-                        let profile = Registry::read_global(cx).get_person(&public_key, cx);
-                        let content = t!("chat.nip17_not_found", u = profile.name());
-
-                        this.insert_warning(content, cx);
-                    }
-                }
-            }),
-        );
-
-        subscriptions.push(
-            // Observe when user close chat panel
-            cx.on_release_in(window, move |this, window, cx| {
-                this.disconnect_relays(cx);
-                this.messages.clear();
-                this.rendered_texts_by_id.clear();
-                this.reports_by_id.clear();
-                this.image_cache.update(cx, |this, cx| {
-                    this.clear(window, cx);
-                });
-            }),
-        );
-
         Self {
             id: room.read(cx).id.to_string().into(),
             image_cache: RetainAllImageCache::new(cx),
             focus_handle: cx.focus_handle(),
+            uploading: false,
             rendered_texts_by_id: BTreeMap::new(),
             reports_by_id: BTreeMap::new(),
-            relays,
             messages,
             room,
             list_state,
             input,
             replies_to,
             attachments,
-            uploading: false,
             _subscriptions: subscriptions,
             _tasks: tasks,
         }
     }
 
-    /// Disconnect all relays when the user closes the chat panel
-    fn disconnect_relays(&mut self, cx: &mut App) {
-        let relays = self.relays.read(cx).clone();
-
-        cx.background_spawn(async move {
-            let client = nostr_client();
-
-            for relay in relays.values().flatten() {
-                client.disconnect_relay(relay).await.ok();
-            }
-        })
-        .detach();
-    }
-
     /// Load all messages belonging to this room
     fn load_messages(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         let load_messages = self.room.read(cx).load_messages(cx);
@@ -256,19 +174,20 @@ impl Chat {
         self._tasks.push(
             // Run the task in the background
             cx.spawn_in(window, async move |this, cx| {
-                let result = load_messages.await;
-
-                this.update_in(cx, |this, window, cx| {
-                    match result {
-                        Ok(events) => {
+                match load_messages.await {
+                    Ok(events) => {
+                        this.update(cx, |this, cx| {
                             this.insert_messages(events, cx);
-                        }
-                        Err(e) => {
-                            window.push_notification(Notification::error(e.to_string()), cx);
-                        }
-                    };
-                })
-                .ok();
+                        })
+                        .ok();
+                    }
+                    Err(e) => {
+                        cx.update(|window, cx| {
+                            window.push_notification(e.to_string(), cx);
+                        })
+                        .ok();
+                    }
+                };
             }),
         );
     }
@@ -286,22 +205,25 @@ impl Chat {
         let attachments = self.attachments.read(cx);
 
         if !attachments.is_empty() {
-            let urls = attachments
-                .iter()
-                .map(|url| url.to_string())
-                .collect_vec()
-                .join("\n");
-
-            if content.is_empty() {
-                content = urls;
-            } else {
-                content = format!("{content}\n{urls}");
-            }
+            content = format!(
+                "{}\n{}",
+                content,
+                attachments
+                    .iter()
+                    .map(|url| url.to_string())
+                    .collect_vec()
+                    .join("\n")
+            )
         }
 
         content
     }
 
+    /// Check if the event is sent by Coop
+    fn is_sent_by_coop(&self, gift_wrap_id: &EventId) -> bool {
+        css().sent_ids.read_blocking().contains(gift_wrap_id)
+    }
+
     /// Send a message to all members of the chat
     fn send_message(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         // Get the message which includes all attachments
@@ -313,11 +235,17 @@ impl Chat {
             return;
         }
 
+        // Temporary disable input
+        self.input.update(cx, |this, cx| {
+            this.set_loading(true, cx);
+            this.set_disabled(true, cx);
+        });
+
         // Get the backup setting
         let backup = AppSettings::get_backup_messages(cx);
 
         // Get replies_to if it's present
-        let replies = self.replies_to.read(cx).iter().copied().collect_vec();
+        let replies = self.replies_to.read(cx).clone();
 
         // Get the current room entity
         let room = self.room.read(cx);
@@ -330,27 +258,26 @@ impl Chat {
         // Create a task for sending the message in the background
         let send_message = room.send_in_background(&content, replies, backup, cx);
 
-        // Optimistically update message list
-        self.insert_message(Message::user(temp_message), true, cx);
+        cx.defer_in(window, |this, window, cx| {
+            // Optimistically update message list
+            this.insert_message(temp_message, true, cx);
 
-        // Remove all replies
-        self.remove_all_replies(cx);
+            // Remove all replies
+            this.remove_all_replies(cx);
 
-        // remove all attachments
-        self.remove_all_attachments(cx);
-
-        // Reset the input state
-        self.input.update(cx, |this, cx| {
-            this.set_value("", window, cx);
+            // Reset the input state
+            this.input.update(cx, |this, cx| {
+                this.set_loading(false, cx);
+                this.set_disabled(false, cx);
+                this.set_value("", window, cx);
+            });
         });
 
         // Continue sending the message in the background
         cx.spawn_in(window, async move |this, cx| {
-            let result = send_message.await;
-
-            this.update_in(cx, |this, window, cx| {
-                match result {
-                    Ok(reports) => {
+            match send_message.await {
+                Ok(reports) => {
+                    this.update(cx, |this, cx| {
                         this.room.update(cx, |this, cx| {
                             if this.kind != RoomKind::Ongoing {
                                 // Update the room kind to ongoing
@@ -366,13 +293,16 @@ impl Chat {
                         this.reports_by_id.insert(temp_id, reports);
 
                         cx.notify();
-                    }
-                    Err(e) => {
-                        window.push_notification(e.to_string(), cx);
-                    }
+                    })
+                    .ok();
                 }
-            })
-            .ok();
+                Err(e) => {
+                    cx.update(|window, cx| {
+                        window.push_notification(e.to_string(), cx);
+                    })
+                    .ok();
+                }
+            }
         })
         .detach();
     }
@@ -388,15 +318,13 @@ impl Chat {
                 cx.spawn_in(window, async move |this, cx| {
                     match task.await {
                         Ok(reports) => {
-                            if !reports.is_empty() {
-                                this.update(cx, |this, cx| {
-                                    this.reports_by_id.entry(id_clone).and_modify(|this| {
-                                        *this = reports;
-                                    });
-                                    cx.notify();
-                                })
-                                .ok();
-                            }
+                            this.update(cx, |this, cx| {
+                                this.reports_by_id.entry(id_clone).and_modify(|this| {
+                                    *this = reports;
+                                });
+                                cx.notify();
+                            })
+                            .ok();
                         }
                         Err(e) => {
                             cx.update(|window, cx| {
@@ -411,43 +339,6 @@ impl Chat {
         }
     }
 
-    /// Insert a message into the chat panel
-    fn insert_message<E>(&mut self, m: E, scroll: bool, cx: &mut Context<Self>)
-    where
-        E: Into<Message>,
-    {
-        let old_len = self.messages.len();
-
-        // Extend the messages list with the new events
-        if self.messages.insert(m.into()) {
-            self.list_state.splice(old_len..old_len, 1);
-
-            if scroll {
-                self.list_state.scroll_to(ListOffset {
-                    item_ix: self.list_state.item_count(),
-                    offset_in_item: px(0.0),
-                });
-            }
-
-            cx.notify();
-        }
-    }
-
-    /// Convert and insert a vector of nostr events into the chat panel
-    fn insert_messages(&mut self, events: Vec<Event>, cx: &mut Context<Self>) {
-        for event in events.into_iter() {
-            let m = Message::user(event);
-            // Bulk inserting messages, so no need to scroll to the latest message
-            self.insert_message(m, false, cx);
-        }
-    }
-
-    /// Insert a warning message into the chat panel
-    fn insert_warning(&mut self, content: impl Into<String>, cx: &mut Context<Self>) {
-        let m = Message::warning(content.into());
-        self.insert_message(m, true, cx);
-    }
-
     /// Check if a message failed to send by its ID
     fn is_sent_failed(&self, id: &EventId) -> bool {
         self.reports_by_id
@@ -479,6 +370,35 @@ impl Chat {
         })
     }
 
+    /// Convert and insert a nostr event into the chat panel
+    fn insert_message<E>(&mut self, event: E, scroll: bool, cx: &mut Context<Self>)
+    where
+        E: Into<RenderedMessage>,
+    {
+        let old_len = self.messages.len();
+
+        // Extend the messages list with the new events
+        if self.messages.insert(Message::user(event)) {
+            self.list_state.splice(old_len..old_len, 1);
+
+            if scroll {
+                self.list_state.scroll_to(ListOffset {
+                    item_ix: self.list_state.item_count(),
+                    offset_in_item: px(0.0),
+                });
+                cx.notify();
+            }
+        }
+    }
+
+    /// Convert and insert a vector of nostr events into the chat panel
+    fn insert_messages(&mut self, events: Vec<Event>, cx: &mut Context<Self>) {
+        for event in events.into_iter() {
+            self.insert_message(event, false, cx);
+        }
+        cx.notify();
+    }
+
     fn profile(&self, public_key: &PublicKey, cx: &Context<Self>) -> Profile {
         let registry = Registry::read_global(cx);
         registry.get_person(public_key, cx)
@@ -505,7 +425,7 @@ impl Chat {
     fn reply_to(&mut self, id: &EventId, cx: &mut Context<Self>) {
         if let Some(text) = self.message(id) {
             self.replies_to.update(cx, |this, cx| {
-                this.insert(text.id);
+                this.push(text.id);
                 cx.notify();
             });
         }
@@ -513,87 +433,88 @@ impl Chat {
 
     fn remove_reply(&mut self, id: &EventId, cx: &mut Context<Self>) {
         self.replies_to.update(cx, |this, cx| {
-            this.remove(id);
-            cx.notify();
+            if let Some(ix) = this.iter().position(|this| this == id) {
+                this.remove(ix);
+                cx.notify();
+            }
         });
     }
 
     fn remove_all_replies(&mut self, cx: &mut Context<Self>) {
         self.replies_to.update(cx, |this, cx| {
-            this.clear();
+            *this = vec![];
             cx.notify();
         });
     }
 
     fn upload(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        if self.uploading {
+            return;
+        }
+        // Block the upload button to until current task is resolved
+        self.uploading(true, cx);
+
         // Get the user's configured NIP96 server
         let nip96_server = AppSettings::get_media_server(cx);
 
-        let path = cx.prompt_for_paths(PathPromptOptions {
+        // Open native file dialog
+        let paths = cx.prompt_for_paths(PathPromptOptions {
             files: true,
             directories: false,
             multiple: false,
             prompt: None,
         });
 
-        cx.spawn_in(window, async move |this, cx| {
-            let mut paths = path.await.ok()?.ok()??;
-            let path = paths.pop()?;
+        let task = Tokio::spawn(cx, async move {
+            match Flatten::flatten(paths.await.map_err(|e| e.into())) {
+                Ok(Some(mut paths)) => {
+                    if let Some(path) = paths.pop() {
+                        let file = fs::read(path).await?;
+                        let url = nip96_upload(nostr_client(), &nip96_server, file).await?;
 
-            let upload = Tokio::spawn(cx, async move {
-                let client = nostr_client();
-                let file = fs::read(path).await.ok()?;
-                let url = nip96_upload(client, &nip96_server, file).await.ok()?;
-
-                Some(url)
-            });
-
-            if let Ok(task) = upload {
-                this.update(cx, |this, cx| {
-                    this.set_uploading(true, cx);
-                })
-                .ok();
-
-                match Flatten::flatten(task.await.map_err(|e| e.into())) {
-                    Ok(Some(url)) => {
-                        this.update(cx, |this, cx| {
-                            this.add_attachment(url, cx);
-                            this.set_uploading(false, cx);
-                        })
-                        .ok();
-                    }
-                    Ok(None) => {
-                        this.update_in(cx, |this, window, cx| {
-                            window.push_notification("Failed to upload file", cx);
-                            this.set_uploading(false, cx);
-                        })
-                        .ok();
-                    }
-                    Err(e) => {
-                        this.update_in(cx, |this, window, cx| {
-                            window.push_notification(Notification::error(e.to_string()), cx);
-                            this.set_uploading(false, cx);
-                        })
-                        .ok();
+                        Ok(url)
+                    } else {
+                        Err(anyhow!("Path not found"))
                     }
                 }
+                Ok(None) => Err(anyhow!("User cancelled")),
+                Err(e) => Err(anyhow!("File dialog error: {e}")),
             }
+        });
 
-            Some(())
+        cx.spawn_in(window, async move |this, cx| {
+            match Flatten::flatten(task.await.map_err(|e| e.into())) {
+                Ok(Ok(url)) => {
+                    this.update(cx, |this, cx| {
+                        this.add_attachment(url, cx);
+                    })
+                    .ok();
+                }
+                Ok(Err(e)) => {
+                    log::warn!("User cancelled: {e}");
+                    this.update(cx, |this, cx| {
+                        this.uploading(false, cx);
+                    })
+                    .ok();
+                }
+                Err(e) => {
+                    this.update_in(cx, |this, window, cx| {
+                        window.push_notification(e.to_string(), cx);
+                        this.uploading(false, cx);
+                    })
+                    .ok();
+                }
+            }
         })
         .detach();
     }
 
-    fn set_uploading(&mut self, uploading: bool, cx: &mut Context<Self>) {
-        self.uploading = uploading;
-        cx.notify();
-    }
-
     fn add_attachment(&mut self, url: Url, cx: &mut Context<Self>) {
         self.attachments.update(cx, |this, cx| {
             this.push(url);
             cx.notify();
         });
+        self.uploading(false, cx);
     }
 
     fn remove_attachment(&mut self, url: &Url, _window: &mut Window, cx: &mut Context<Self>) {
@@ -605,11 +526,9 @@ impl Chat {
         });
     }
 
-    fn remove_all_attachments(&mut self, cx: &mut Context<Self>) {
-        self.attachments.update(cx, |this, cx| {
-            this.clear();
-            cx.notify();
-        });
+    fn uploading(&mut self, status: bool, cx: &mut Context<Self>) {
+        self.uploading = status;
+        cx.notify();
     }
 
     fn render_announcement(&mut self, ix: usize, cx: &mut Context<Self>) -> AnyElement {
@@ -638,34 +557,6 @@ impl Chat {
             .into_any_element()
     }
 
-    fn render_warning(&mut self, ix: usize, content: String, cx: &mut Context<Self>) -> AnyElement {
-        div()
-            .id(ix)
-            .relative()
-            .w_full()
-            .py_1()
-            .px_3()
-            .bg(cx.theme().warning_background)
-            .child(
-                h_flex()
-                    .gap_3()
-                    .text_sm()
-                    .text_color(cx.theme().warning_foreground)
-                    .child(Avatar::new("brand/system.png").size(rems(2.)))
-                    .child(SharedString::from(content)),
-            )
-            .child(
-                div()
-                    .absolute()
-                    .left_0()
-                    .top_0()
-                    .w(px(2.))
-                    .h_full()
-                    .bg(cx.theme().warning_active),
-            )
-            .into_any_element()
-    }
-
     fn render_message_not_found(&self, ix: usize, cx: &Context<Self>) -> AnyElement {
         div()
             .id(ix)
@@ -695,7 +586,6 @@ impl Chat {
 
         let id = message.id;
         let author = self.profile(&message.author, cx);
-        let public_key = author.public_key();
 
         let replies = message.replies_to.as_slice();
         let has_replies = !replies.is_empty();
@@ -718,18 +608,7 @@ impl Chat {
                     .flex()
                     .gap_3()
                     .when(!hide_avatar, |this| {
-                        this.child(
-                            div()
-                                .id(SharedString::from(format!("{ix}-avatar")))
-                                .child(Avatar::new(author.avatar(proxy)).size(rems(2.)))
-                                .context_menu(move |this, _window, _cx| {
-                                    let view = Box::new(OpenPublicKey(public_key));
-                                    let copy = Box::new(CopyPublicKey(public_key));
-
-                                    this.menu(t!("profile.view"), view)
-                                        .menu(t!("profile.copy"), copy)
-                                }),
-                        )
+                        this.child(Avatar::new(author.avatar_url(proxy)).size(rems(2.)))
                     })
                     .child(
                         v_flex()
@@ -738,7 +617,9 @@ impl Chat {
                             .flex_initial()
                             .overflow_hidden()
                             .child(
-                                h_flex()
+                                div()
+                                    .flex()
+                                    .items_center()
                                     .gap_2()
                                     .text_sm()
                                     .text_color(cx.theme().text_placeholder)
@@ -748,7 +629,7 @@ impl Chat {
                                             .text_color(cx.theme().text)
                                             .child(author.display_name()),
                                     )
-                                    .child(message.created_at.to_human_time())
+                                    .child(div().child(message.created_at.to_human_time()))
                                     .when_some(is_sent_success, |this, status| {
                                         this.when(status, |this| {
                                             this.child(self.render_message_sent(&id, cx))
@@ -769,7 +650,7 @@ impl Chat {
                                                 .label(t!("common.resend"))
                                                 .danger()
                                                 .xsmall()
-                                                .rounded()
+                                                .rounded(ButtonRounded::Full)
                                                 .on_click(cx.listener(
                                                     move |this, _, window, cx| {
                                                         this.resend_message(&id, window, cx);
@@ -784,12 +665,14 @@ impl Chat {
             .child(self.render_actions(&id, cx))
             .on_mouse_down(
                 MouseButton::Middle,
-                cx.listener(move |this, _, _window, cx| {
+                cx.listener(move |this, _event, _window, cx| {
                     this.copy_message(&id, cx);
                 }),
             )
-            .on_double_click(cx.listener(move |this, _, _window, cx| {
-                this.reply_to(&id, cx);
+            .on_double_click(cx.listener({
+                move |this, _event, _window, cx| {
+                    this.reply_to(&id, cx);
+                }
             }))
             .hover(|this| this.bg(cx.theme().surface_background))
             .into_any_element()
@@ -826,7 +709,7 @@ impl Chat {
                             .w_full()
                             .text_ellipsis()
                             .line_clamp(1)
-                            .child(SharedString::from(&message.content)),
+                            .child(message.content.clone()),
                     )
                     .hover(|this| this.bg(cx.theme().elevated_surface_background))
                     .on_click({
@@ -900,7 +783,7 @@ impl Chat {
         let registry = Registry::read_global(cx);
         let profile = registry.get_person(&report.receiver, cx);
         let name = profile.display_name();
-        let avatar = profile.avatar(true);
+        let avatar = profile.avatar_url(true);
 
         v_flex()
             .gap_2()
@@ -1037,6 +920,31 @@ impl Chat {
     }
 
     fn render_actions(&self, id: &EventId, cx: &Context<Self>) -> impl IntoElement {
+        let groups = vec![
+            Button::new("reply")
+                .icon(IconName::Reply)
+                .tooltip(t!("chat.reply_button"))
+                .small()
+                .ghost()
+                .on_click({
+                    let id = id.to_owned();
+                    cx.listener(move |this, _event, _window, cx| {
+                        this.reply_to(&id, cx);
+                    })
+                }),
+            Button::new("copy")
+                .icon(IconName::Copy)
+                .tooltip(t!("chat.copy_message_button"))
+                .small()
+                .ghost()
+                .on_click({
+                    let id = id.to_owned();
+                    cx.listener(move |this, _event, _window, cx| {
+                        this.copy_message(&id, cx);
+                    })
+                }),
+        ];
+
         h_flex()
             .p_0p5()
             .gap_1()
@@ -1049,55 +957,20 @@ impl Chat {
             .border_1()
             .border_color(cx.theme().border)
             .bg(cx.theme().background)
-            .child(
-                Button::new("reply")
-                    .icon(IconName::Reply)
-                    .tooltip(t!("chat.reply_button"))
-                    .small()
-                    .ghost()
-                    .on_click({
-                        let id = id.to_owned();
-                        cx.listener(move |this, _event, _window, cx| {
-                            this.reply_to(&id, cx);
-                        })
-                    }),
-            )
-            .child(
-                Button::new("copy")
-                    .icon(IconName::Copy)
-                    .tooltip(t!("chat.copy_message_button"))
-                    .small()
-                    .ghost()
-                    .on_click({
-                        let id = id.to_owned();
-                        cx.listener(move |this, _event, _window, cx| {
-                            this.copy_message(&id, cx);
-                        })
-                    }),
-            )
-            .child(div().flex_shrink_0().h_4().w_px().bg(cx.theme().border))
-            .child(
-                Button::new("seen-on")
-                    .icon(IconName::Ellipsis)
-                    .small()
-                    .ghost()
-                    .popup_menu({
-                        let id = id.to_owned();
-                        move |this, _window, _cx| {
-                            this.menu(t!("common.seen_on"), Box::new(SeenOn(id)))
-                        }
-                    }),
-            )
+            .children(groups)
             .group_hover("", |this| this.visible())
     }
 
     fn render_attachment(&self, url: &Url, cx: &Context<Self>) -> impl IntoElement {
+        let url = url.clone();
+        let path: SharedString = url.to_string().into();
+
         div()
             .id(SharedString::from(url.to_string()))
             .relative()
             .w_16()
             .child(
-                img(SharedUri::from(url.to_string()))
+                img(path.clone())
                     .size_16()
                     .shadow_lg()
                     .rounded(cx.theme().radius)
@@ -1116,12 +989,9 @@ impl Chat {
                     .bg(red())
                     .child(Icon::new(IconName::Close).size_2().text_color(white())),
             )
-            .on_click({
-                let url = url.clone();
-                cx.listener(move |this, _, window, cx| {
-                    this.remove_attachment(&url, window, cx);
-                })
-            })
+            .on_click(cx.listener(move |this, _, window, cx| {
+                this.remove_attachment(&url, window, cx);
+            }))
     }
 
     fn render_attachment_list(
@@ -1186,7 +1056,7 @@ impl Chat {
                         .text_sm()
                         .text_ellipsis()
                         .line_clamp(1)
-                        .child(SharedString::from(&text.content)),
+                        .child(text.content.clone()),
                 )
         } else {
             div()
@@ -1263,62 +1133,6 @@ impl Chat {
                 .ok();
             })
     }
-
-    fn on_open_seen_on(&mut self, ev: &SeenOn, window: &mut Window, cx: &mut Context<Self>) {
-        let id = ev.0;
-
-        let task: Task<Result<Vec<RelayUrl>, Error>> = cx.background_spawn(async move {
-            let client = nostr_client();
-            let app_state = app_state();
-            let mut relays: Vec<RelayUrl> = vec![];
-
-            let filter = Filter::new()
-                .kind(Kind::ApplicationSpecificData)
-                .event(id)
-                .limit(1);
-
-            if let Some(event) = client.database().query(filter).await?.first_owned() {
-                if let Some(Ok(id)) = event.tags.identifier().map(EventId::parse) {
-                    if let Some(urls) = app_state.seen_on_relays.read().await.get(&id).cloned() {
-                        relays.extend(urls);
-                    }
-                }
-            }
-
-            Ok(relays)
-        });
-
-        cx.spawn_in(window, async move |_, cx| {
-            if let Ok(urls) = task.await {
-                cx.update(|window, cx| {
-                    window.open_modal(cx, move |this, _window, cx| {
-                        this.title(shared_t!("common.seen_on")).child(
-                            v_flex().pb_4().gap_2().children({
-                                let mut items = Vec::with_capacity(urls.len());
-
-                                for url in urls.clone().into_iter() {
-                                    items.push(
-                                        h_flex()
-                                            .h_8()
-                                            .px_2()
-                                            .bg(cx.theme().elevated_surface_background)
-                                            .rounded(cx.theme().radius)
-                                            .font_semibold()
-                                            .text_xs()
-                                            .child(url.to_string()),
-                                    )
-                                }
-
-                                items
-                            }),
-                        )
-                    });
-                })
-                .ok();
-            }
-        })
-        .detach();
-    }
 }
 
 impl Panel for Chat {
@@ -1332,7 +1146,9 @@ impl Panel for Chat {
             let label = this.display_name(cx);
             let url = this.display_image(proxy, cx);
 
-            h_flex()
+            div()
+                .flex()
+                .items_center()
                 .gap_1p5()
                 .child(Avatar::new(url).size(rems(1.25)))
                 .child(label)
@@ -1363,7 +1179,6 @@ impl Focusable for Chat {
 impl Render for Chat {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         v_flex()
-            .on_action(cx.listener(Self::on_open_seen_on))
             .image_cache(self.image_cache.clone())
             .size_full()
             .child(
@@ -1381,9 +1196,6 @@ impl Render for Chat {
 
                                     this.render_message(ix, rendered, text, cx)
                                 }
-                                Message::Warning(content, _) => {
-                                    this.render_warning(ix, content.to_owned(), cx)
-                                }
                                 Message::System(_) => this.render_announcement(ix, cx),
                             }
                         } else {
@@ -1401,7 +1213,9 @@ impl Render for Chat {
                     .px_3()
                     .py_2()
                     .child(
-                        v_flex()
+                        div()
+                            .flex()
+                            .flex_col()
                             .gap_1p5()
                             .children(self.render_attachment_list(window, cx))
                             .children(self.render_reply_list(window, cx))
@@ -1420,10 +1234,10 @@ impl Render for Chat {
                                             .child(
                                                 Button::new("upload")
                                                     .icon(IconName::Upload)
-                                                    .loading(self.uploading)
-                                                    .disabled(self.uploading)
                                                     .ghost()
                                                     .large()
+                                                    .disabled(self.uploading)
+                                                    .loading(self.uploading)
                                                     .on_click(cx.listener(
                                                         move |this, _, window, cx| {
                                                             this.upload(window, cx);

crates/coop/src/views/chat/subject.rs

@@ -2,7 +2,7 @@ use gpui::{
     div, App, AppContext, Context, Entity, IntoElement, ParentElement, Render, SharedString,
     Styled, Window,
 };
-use i18n::{shared_t, t};
+use i18n::t;
 use theme::ActiveTheme;
 use ui::input::{InputState, TextInput};
 use ui::{v_flex, Sizable};
@@ -41,7 +41,7 @@ impl Render for Subject {
                 div()
                     .text_sm()
                     .text_color(cx.theme().text_muted)
-                    .child(shared_t!("subject.title")),
+                    .child(SharedString::new(t!("subject.title"))),
             )
             .child(TextInput::new(&self.input).small())
             .child(
@@ -49,7 +49,7 @@ impl Render for Subject {
                     .text_xs()
                     .italic()
                     .text_color(cx.theme().text_placeholder)
-                    .child(shared_t!("subject.help_text")),
+                    .child(SharedString::new(t!("subject.help_text"))),
             )
     }
 }

crates/coop/src/views/compose.rs

@@ -2,29 +2,28 @@ use std::ops::Range;
 use std::time::Duration;
 
 use anyhow::{anyhow, Error};
-use common::display::{RenderedProfile, TextUtils};
+use common::display::{ReadableProfile, TextUtils};
 use common::nip05::nip05_profile;
 use global::constants::BOOTSTRAP_RELAYS;
-use global::{app_state, nostr_client};
+use global::nostr_client;
 use gpui::prelude::FluentBuilder;
 use gpui::{
-    div, px, relative, rems, uniform_list, App, AppContext, Context, Entity, InteractiveElement,
-    IntoElement, ParentElement, Render, RetainAllImageCache, SharedString,
-    StatefulInteractiveElement, Styled, Subscription, Task, Window,
+    div, px, relative, rems, uniform_list, AppContext, Context, Entity, InteractiveElement,
+    IntoElement, ParentElement, Render, SharedString, StatefulInteractiveElement, Styled,
+    Subscription, Task, Window,
 };
-use gpui_tokio::Tokio;
-use i18n::{shared_t, t};
+use i18n::t;
+use itertools::Itertools;
 use nostr_sdk::prelude::*;
-use registry::room::Room;
+use registry::room::{Room, RoomKind};
 use registry::Registry;
 use settings::AppSettings;
 use smallvec::{smallvec, SmallVec};
 use smol::Timer;
 use theme::ActiveTheme;
 use ui::avatar::Avatar;
-use ui::button::{Button, ButtonVariants};
+use ui::button::{Button, ButtonRounded, ButtonVariants};
 use ui::input::{InputEvent, InputState, TextInput};
-use ui::modal::ModalButtonProps;
 use ui::notification::Notification;
 use ui::{h_flex, v_flex, ContextModal, Disableable, Icon, IconName, Sizable, StyledExt};
 
@@ -35,46 +34,22 @@ pub fn compose_button() -> impl IntoElement {
             .ghost_alt()
             .cta()
             .small()
-            .rounded()
+            .rounded(ButtonRounded::Full)
             .on_click(move |_, window, cx| {
                 let compose = cx.new(|cx| Compose::new(window, cx));
-                let weak_view = compose.downgrade();
+                let title = SharedString::new(t!("sidebar.direct_messages"));
 
-                window.open_modal(cx, move |modal, _window, cx| {
-                    let weak_view = weak_view.clone();
-                    let label = if compose.read(cx).selected(cx).len() > 1 {
-                        shared_t!("compose.create_group_dm_button")
-                    } else {
-                        shared_t!("compose.create_dm_button")
-                    };
-
-                    modal
-                        .alert()
-                        .overlay_closable(true)
-                        .keyboard(true)
-                        .show_close(true)
-                        .button_props(ModalButtonProps::default().ok_text(label))
-                        .title(shared_t!("sidebar.direct_messages"))
-                        .child(compose.clone())
-                        .on_ok(move |_, window, cx| {
-                            weak_view
-                                .update(cx, |this, cx| {
-                                    this.submit(window, cx);
-                                })
-                                .ok();
-
-                            // false to prevent the modal from closing
-                            false
-                        })
+                window.open_modal(cx, move |modal, _window, _cx| {
+                    modal.title(title.clone()).child(compose.clone())
                 })
             }),
     )
 }
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug)]
 struct Contact {
     public_key: PublicKey,
-    selected: bool,
+    select: bool,
 }
 
 impl AsRef<PublicKey> for Contact {
@@ -87,12 +62,12 @@ impl Contact {
     pub fn new(public_key: PublicKey) -> Self {
         Self {
             public_key,
-            selected: false,
+            select: false,
         }
     }
 
-    pub fn selected(mut self) -> Self {
-        self.selected = true;
+    pub fn select(mut self) -> Self {
+        self.select = true;
         self
     }
 }
@@ -100,209 +75,188 @@ impl Contact {
 pub struct Compose {
     /// Input for the room's subject
     title_input: Entity<InputState>,
-
     /// Input for the room's members
     user_input: Entity<InputState>,
-
-    /// User's contacts
-    contacts: Entity<Vec<Contact>>,
-
-    /// Error message
+    /// The current user's contacts
+    contacts: Vec<Entity<Contact>>,
+    /// Input error message
     error_message: Entity<Option<SharedString>>,
-
-    image_cache: Entity<RetainAllImageCache>,
-    _subscriptions: SmallVec<[Subscription; 2]>,
-    _tasks: SmallVec<[Task<()>; 1]>,
+    adding: bool,
+    submitting: bool,
+    #[allow(dead_code)]
+    subscriptions: SmallVec<[Subscription; 1]>,
 }
 
 impl Compose {
     pub fn new(window: &mut Window, cx: &mut Context<'_, Self>) -> Self {
-        let contacts = cx.new(|_| vec![]);
-        let error_message = cx.new(|_| None);
-
         let user_input =
-            cx.new(|cx| InputState::new(window, cx).placeholder("npub or nprofile..."));
+            cx.new(|cx| InputState::new(window, cx).placeholder(t!("compose.placeholder_npub")));
 
         let title_input =
-            cx.new(|cx| InputState::new(window, cx).placeholder("Family...(Optional)"));
+            cx.new(|cx| InputState::new(window, cx).placeholder(t!("compose.placeholder_title")));
 
+        let error_message = cx.new(|_| None);
         let mut subscriptions = smallvec![];
-        let mut tasks = smallvec![];
+
+        // Handle Enter event for user input
+        subscriptions.push(cx.subscribe_in(
+            &user_input,
+            window,
+            move |this, _input, event, window, cx| {
+                if let InputEvent::PressEnter { .. } = event {
+                    this.add_and_select_contact(window, cx)
+                };
+            },
+        ));
 
         let get_contacts: Task<Result<Vec<Contact>, Error>> = cx.background_spawn(async move {
             let client = nostr_client();
             let signer = client.signer().await?;
             let public_key = signer.get_public_key().await?;
             let profiles = client.database().contacts(public_key).await?;
-            let contacts: Vec<Contact> = profiles
+            let contacts = profiles
                 .into_iter()
                 .map(|profile| Contact::new(profile.public_key()))
-                .collect();
+                .collect_vec();
 
             Ok(contacts)
         });
 
-        tasks.push(
-            // Load all contacts
-            cx.spawn_in(window, async move |this, cx| {
-                match get_contacts.await {
-                    Ok(contacts) => {
-                        this.update(cx, |this, cx| {
-                            this.extend_contacts(contacts, cx);
-                        })
-                        .ok();
-                    }
-                    Err(e) => {
-                        cx.update(|window, cx| {
-                            window.push_notification(Notification::error(e.to_string()), cx);
-                        })
-                        .ok();
-                    }
-                };
-            }),
-        );
-
-        subscriptions.push(
-            // Clear the image cache when sidebar is closed
-            cx.on_release_in(window, move |this, window, cx| {
-                this.image_cache.update(cx, |this, cx| {
-                    this.clear(window, cx);
-                })
-            }),
-        );
-
-        subscriptions.push(
-            // Handle Enter event for user input
-            cx.subscribe_in(
-                &user_input,
-                window,
-                move |this, _input, event, window, cx| {
-                    if let InputEvent::PressEnter { .. } = event {
-                        this.add_and_select_contact(window, cx)
-                    };
-                },
-            ),
-        );
+        cx.spawn_in(window, async move |this, cx| {
+            match get_contacts.await {
+                Ok(contacts) => {
+                    this.update(cx, |this, cx| {
+                        this.extend_contacts(contacts, cx);
+                    })
+                    .ok();
+                }
+                Err(e) => {
+                    cx.update(|window, cx| {
+                        window.push_notification(Notification::error(e.to_string()), cx);
+                    })
+                    .ok();
+                }
+            };
+        })
+        .detach();
 
         Self {
+            adding: false,
+            submitting: false,
+            contacts: vec![],
             title_input,
             user_input,
             error_message,
-            contacts,
-            image_cache: RetainAllImageCache::new(cx),
-            _subscriptions: subscriptions,
-            _tasks: tasks,
+            subscriptions,
         }
     }
 
-    async fn request_metadata(public_key: PublicKey) -> Result<(), Error> {
-        let client = nostr_client();
-        let app_state = app_state();
+    async fn request_metadata(client: &Client, public_key: PublicKey) -> Result<(), Error> {
+        let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
         let kinds = vec![Kind::Metadata, Kind::ContactList, Kind::RelayList];
         let filter = Filter::new().author(public_key).kinds(kinds).limit(10);
 
         client
-            .subscribe_to(BOOTSTRAP_RELAYS, filter, app_state.auto_close_opts)
+            .subscribe_to(BOOTSTRAP_RELAYS, filter, Some(opts))
             .await?;
 
         Ok(())
     }
 
+    pub fn submit(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let public_keys: Vec<PublicKey> = self.selected(cx);
+
+        if public_keys.is_empty() {
+            self.set_error(Some(t!("compose.receiver_required").into()), cx);
+            return;
+        };
+
+        // Show loading spinner
+        self.set_submitting(true, cx);
+
+        // Convert selected pubkeys into Nostr tags
+        let mut tag_list: Vec<Tag> = public_keys.iter().map(|pk| Tag::public_key(*pk)).collect();
+
+        // Add subject if it is present
+        if !self.title_input.read(cx).value().is_empty() {
+            tag_list.push(Tag::custom(
+                TagKind::Subject,
+                vec![self.title_input.read(cx).value().to_string()],
+            ));
+        }
+
+        let event: Task<Result<Room, Error>> = cx.background_spawn(async move {
+            let signer = nostr_client().signer().await?;
+            let public_key = signer.get_public_key().await?;
+
+            let room = EventBuilder::private_msg_rumor(public_keys[0], "")
+                .tags(Tags::from_list(tag_list))
+                .build(public_key)
+                .sign(&Keys::generate())
+                .await
+                .map(|event| Room::new(&event).kind(RoomKind::Ongoing))?;
+
+            Ok(room)
+        });
+
+        cx.spawn_in(window, async move |this, cx| {
+            match event.await {
+                Ok(room) => {
+                    cx.update(|window, cx| {
+                        let registry = Registry::global(cx);
+                        // Reset local state
+                        this.update(cx, |this, cx| {
+                            this.set_submitting(false, cx);
+                        })
+                        .ok();
+                        // Create and insert the new room into the registry
+                        registry.update(cx, |this, cx| {
+                            this.push_room(cx.new(|_| room), cx);
+                        });
+                        // Close the current modal
+                        window.close_modal(cx);
+                    })
+                    .ok();
+                }
+                Err(e) => {
+                    this.update(cx, |this, cx| {
+                        this.set_error(Some(e.to_string().into()), cx);
+                    })
+                    .ok();
+                }
+            };
+        })
+        .detach();
+    }
+
     fn extend_contacts<I>(&mut self, contacts: I, cx: &mut Context<Self>)
     where
         I: IntoIterator<Item = Contact>,
     {
-        self.contacts.update(cx, |this, cx| {
-            this.extend(contacts);
-            cx.notify();
-        });
+        self.contacts
+            .extend(contacts.into_iter().map(|contact| cx.new(|_| contact)));
+        cx.notify();
     }
 
-    fn push_contact(&mut self, contact: Contact, window: &mut Window, cx: &mut Context<Self>) {
-        let pk = contact.public_key;
-
-        if !self.contacts.read(cx).iter().any(|c| c.public_key == pk) {
-            self._tasks.push(cx.background_spawn(async move {
-                Self::request_metadata(pk).await.ok();
-            }));
-
-            cx.defer_in(window, |this, window, cx| {
-                this.contacts.update(cx, |this, cx| {
-                    this.insert(0, contact);
-                    cx.notify();
-                });
-                this.user_input.update(cx, |this, cx| {
-                    this.set_value("", window, cx);
-                    this.set_loading(false, cx);
-                });
-            });
+    fn push_contact(&mut self, contact: Contact, cx: &mut Context<Self>) {
+        if !self
+            .contacts
+            .iter()
+            .any(|e| e.read(cx).public_key == contact.public_key)
+        {
+            self.contacts.insert(0, cx.new(|_| contact));
+            cx.notify();
         } else {
             self.set_error(Some(t!("compose.contact_existed").into()), cx);
         }
     }
 
-    fn select_contact(&mut self, public_key: PublicKey, cx: &mut Context<Self>) {
-        self.contacts.update(cx, |this, cx| {
-            if let Some(contact) = this.iter_mut().find(|c| c.public_key == public_key) {
-                contact.selected = true;
-            }
-            cx.notify();
-        });
-    }
-
-    fn add_and_select_contact(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let content = self.user_input.read(cx).value().to_string();
-
-        // Show loading indicator in the input
-        self.user_input.update(cx, |this, cx| {
-            this.set_loading(true, cx);
-        });
-
-        if let Ok(public_key) = content.to_public_key() {
-            let contact = Contact::new(public_key).selected();
-            self.push_contact(contact, window, cx);
-        } else if content.contains("@") {
-            let task = Tokio::spawn(cx, async move {
-                if let Ok(profile) = nip05_profile(&content).await {
-                    let public_key = profile.public_key;
-                    let contact = Contact::new(public_key).selected();
-
-                    Ok(contact)
-                } else {
-                    Err(anyhow!("Not found"))
-                }
-            });
-
-            cx.spawn_in(window, async move |this, cx| {
-                match task.await {
-                    Ok(Ok(contact)) => {
-                        this.update_in(cx, |this, window, cx| {
-                            this.push_contact(contact, window, cx);
-                        })
-                        .ok();
-                    }
-                    Ok(Err(e)) => {
-                        this.update(cx, |this, cx| {
-                            this.set_error(Some(e.to_string().into()), cx);
-                        })
-                        .ok();
-                    }
-                    Err(e) => {
-                        log::error!("Tokio error: {e}");
-                    }
-                };
-            })
-            .detach();
-        }
-    }
-
-    fn selected(&self, cx: &App) -> Vec<PublicKey> {
+    fn selected(&self, cx: &Context<Self>) -> Vec<PublicKey> {
         self.contacts
-            .read(cx)
             .iter()
             .filter_map(|contact| {
-                if contact.selected {
-                    Some(contact.public_key)
+                if contact.read(cx).select {
+                    Some(contact.read(cx).public_key)
                 } else {
                     None
                 }
@@ -310,49 +264,84 @@ impl Compose {
             .collect()
     }
 
-    fn submit(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let registry = Registry::global(cx);
-        let public_keys: Vec<PublicKey> = self.selected(cx);
+    fn add_and_select_contact(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let content = self.user_input.read(cx).value().to_string();
 
-        if !self.user_input.read(cx).value().is_empty() {
-            self.add_and_select_contact(window, cx);
-            return;
-        };
+        // Prevent multiple requests
+        self.set_adding(true, cx);
 
-        if public_keys.is_empty() {
-            self.set_error(Some(t!("compose.receiver_required").into()), cx);
-            return;
-        };
-
-        // Convert selected pubkeys into Nostr tags
-        let mut tags: Tags = Tags::from_list(
-            public_keys
-                .iter()
-                .map(|pubkey| Tag::public_key(pubkey.to_owned()))
-                .collect(),
-        );
-
-        // Add subject if it is present
-        if !self.title_input.read(cx).value().is_empty() {
-            tags.push(Tag::custom(
-                TagKind::Subject,
-                vec![self.title_input.read(cx).value().to_string()],
-            ));
-        }
-
-        // Create a new room
-        let room = Room::new(public_keys[0], tags, cx);
-
-        // Insert the new room into the registry
-        registry.update(cx, |this, cx| {
-            this.push_room(cx.new(|_| room), cx);
+        // Show loading indicator in the input
+        self.user_input.update(cx, |this, cx| {
+            this.set_loading(true, cx);
         });
 
-        // Close the current modal
-        window.close_modal(cx);
+        let task: Task<Result<Contact, Error>> = if content.contains("@") {
+            cx.background_spawn(async move {
+                let (tx, rx) = oneshot::channel::<Option<Nip05Profile>>();
+
+                nostr_sdk::async_utility::task::spawn(async move {
+                    let profile = nip05_profile(&content).await.ok();
+                    tx.send(profile).ok();
+                });
+
+                if let Ok(Some(profile)) = rx.await {
+                    let client = nostr_client();
+                    let public_key = profile.public_key;
+                    let contact = Contact::new(public_key).select();
+
+                    Self::request_metadata(client, public_key).await?;
+
+                    Ok(contact)
+                } else {
+                    Err(anyhow!(t!("common.not_found")))
+                }
+            })
+        } else if let Ok(public_key) = content.to_public_key() {
+            cx.background_spawn(async move {
+                let client = nostr_client();
+                let contact = Contact::new(public_key).select();
+
+                Self::request_metadata(client, public_key).await?;
+
+                Ok(contact)
+            })
+        } else {
+            self.set_error(Some(t!("common.pubkey_invalid").into()), cx);
+            return;
+        };
+
+        cx.spawn_in(window, async move |this, cx| {
+            match task.await {
+                Ok(contact) => {
+                    cx.update(|window, cx| {
+                        this.update(cx, |this, cx| {
+                            this.push_contact(contact, cx);
+                            this.set_adding(false, cx);
+                            this.user_input.update(cx, |this, cx| {
+                                this.set_value("", window, cx);
+                                this.set_loading(false, cx);
+                            });
+                        })
+                        .ok();
+                    })
+                    .ok();
+                }
+                Err(e) => {
+                    this.update(cx, |this, cx| {
+                        this.set_error(Some(e.to_string().into()), cx);
+                    })
+                    .ok();
+                }
+            };
+        })
+        .detach();
     }
 
     fn set_error(&mut self, error: impl Into<Option<SharedString>>, cx: &mut Context<Self>) {
+        if self.adding {
+            self.set_adding(false, cx);
+        }
+
         // Unlock the user input
         self.user_input.update(cx, |this, cx| {
             this.set_loading(false, cx);
@@ -375,35 +364,48 @@ impl Compose {
         .detach();
     }
 
+    fn set_adding(&mut self, status: bool, cx: &mut Context<Self>) {
+        self.adding = status;
+        cx.notify();
+    }
+
+    fn set_submitting(&mut self, status: bool, cx: &mut Context<Self>) {
+        self.submitting = status;
+        cx.notify();
+    }
+
     fn list_items(&self, range: Range<usize>, cx: &Context<Self>) -> Vec<impl IntoElement> {
         let proxy = AppSettings::get_proxy_user_avatars(cx);
         let registry = Registry::read_global(cx);
-        let mut items = Vec::with_capacity(self.contacts.read(cx).len());
+        let mut items = Vec::with_capacity(self.contacts.len());
 
         for ix in range {
-            let Some(contact) = self.contacts.read(cx).get(ix) else {
+            let Some(entity) = self.contacts.get(ix).cloned() else {
                 continue;
             };
 
-            let public_key = contact.public_key;
-            let profile = registry.get_person(&public_key, cx);
+            let public_key = entity.read(cx).as_ref();
+            let profile = registry.get_person(public_key, cx);
+            let selected = entity.read(cx).select;
 
             items.push(
                 h_flex()
                     .id(ix)
-                    .px_2()
-                    .h_11()
+                    .px_1()
+                    .h_9()
                     .w_full()
                     .justify_between()
                     .rounded(cx.theme().radius)
                     .child(
-                        h_flex()
+                        div()
+                            .flex()
+                            .items_center()
                             .gap_1p5()
                             .text_sm()
-                            .child(Avatar::new(profile.avatar(proxy)).size(rems(1.75)))
+                            .child(Avatar::new(profile.avatar_url(proxy)).size(rems(1.75)))
                             .child(profile.display_name()),
                     )
-                    .when(contact.selected, |this| {
+                    .when(selected, |this| {
                         this.child(
                             Icon::new(IconName::CheckCircleFill)
                                 .small()
@@ -411,8 +413,11 @@ impl Compose {
                         )
                     })
                     .hover(|this| this.bg(cx.theme().elevated_surface_background))
-                    .on_click(cx.listener(move |this, _, _window, cx| {
-                        this.select_contact(public_key, cx);
+                    .on_click(cx.listener(move |_this, _event, _window, cx| {
+                        entity.update(cx, |this, cx| {
+                            this.select = !this.select;
+                            cx.notify();
+                        });
                     })),
             );
         }
@@ -423,18 +428,24 @@ impl Compose {
 
 impl Render for Compose {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let label = if self.submitting {
+            t!("compose.creating_dm_button")
+        } else if self.selected(cx).len() > 1 {
+            t!("compose.create_group_dm_button")
+        } else {
+            t!("compose.create_dm_button")
+        };
+
         let error = self.error_message.read(cx).as_ref();
-        let loading = self.user_input.read(cx).loading;
-        let contacts = self.contacts.read(cx);
 
         v_flex()
-            .image_cache(self.image_cache.clone())
+            .mb_4()
             .gap_2()
             .child(
                 div()
                     .text_sm()
                     .text_color(cx.theme().text_muted)
-                    .child(shared_t!("compose.description")),
+                    .child(SharedString::new(t!("compose.description"))),
             )
             .when_some(error, |this, msg| {
                 this.child(
@@ -455,13 +466,13 @@ impl Render for Compose {
                         div()
                             .text_sm()
                             .font_semibold()
-                            .child(shared_t!("compose.subject_label")),
+                            .child(SharedString::new(t!("compose.subject_label"))),
                     )
                     .child(TextInput::new(&self.title_input).small().appearance(false)),
             )
             .child(
                 v_flex()
-                    .pt_1()
+                    .my_1()
                     .gap_2()
                     .child(
                         v_flex()
@@ -470,18 +481,22 @@ impl Render for Compose {
                                 div()
                                     .text_sm()
                                     .font_semibold()
-                                    .child(shared_t!("compose.to_label")),
+                                    .child(SharedString::new(t!("compose.to_label"))),
                             )
                             .child(
-                                TextInput::new(&self.user_input)
-                                    .small()
-                                    .disabled(loading)
-                                    .suffix(
+                                h_flex()
+                                    .gap_1()
+                                    .child(
+                                        TextInput::new(&self.user_input)
+                                            .small()
+                                            .disabled(self.adding),
+                                    )
+                                    .child(
                                         Button::new("add")
                                             .icon(IconName::PlusCircleFill)
-                                            .transparent()
-                                            .small()
-                                            .disabled(loading)
+                                            .ghost()
+                                            .loading(self.adding)
+                                            .disabled(self.adding)
                                             .on_click(cx.listener(move |this, _, window, cx| {
                                                 this.add_and_select_contact(window, cx);
                                             })),
@@ -489,7 +504,7 @@ impl Render for Compose {
                             ),
                     )
                     .map(|this| {
-                        if contacts.is_empty() {
+                        if self.contacts.is_empty() {
                             this.child(
                                 v_flex()
                                     .h_24()
@@ -497,32 +512,48 @@ impl Render for Compose {
                                     .items_center()
                                     .justify_center()
                                     .text_center()
-                                    .text_xs()
                                     .child(
                                         div()
+                                            .text_xs()
                                             .font_semibold()
                                             .line_height(relative(1.2))
-                                            .child(shared_t!("compose.no_contacts_message")),
+                                            .child(SharedString::new(t!(
+                                                "compose.no_contacts_message"
+                                            ))),
                                     )
                                     .child(
-                                        div()
-                                            .text_color(cx.theme().text_muted)
-                                            .child(shared_t!("compose.no_contacts_description")),
+                                        div().text_xs().text_color(cx.theme().text_muted).child(
+                                            SharedString::new(t!(
+                                                "compose.no_contacts_description"
+                                            )),
+                                        ),
                                     ),
                             )
                         } else {
                             this.child(
                                 uniform_list(
                                     "contacts",
-                                    contacts.len(),
+                                    self.contacts.len(),
                                     cx.processor(move |this, range, _window, cx| {
                                         this.list_items(range, cx)
                                     }),
                                 )
-                                .h(px(300.)),
+                                .min_h(px(300.)),
                             )
                         }
                     }),
             )
+            .child(
+                Button::new("create_dm_btn")
+                    .label(label)
+                    .primary()
+                    .small()
+                    .w_full()
+                    .loading(self.submitting)
+                    .disabled(self.submitting || self.adding)
+                    .on_click(cx.listener(move |this, _event, window, cx| {
+                        this.submit(window, cx);
+                    })),
+            )
     }
 }

crates/coop/src/views/edit_profile.rs

@@ -8,7 +8,7 @@ use gpui::{
     div, img, App, AppContext, Context, Entity, Flatten, IntoElement, ParentElement,
     PathPromptOptions, Render, SharedString, Styled, Task, Window,
 };
-use i18n::{shared_t, t};
+use i18n::t;
 use nostr_sdk::prelude::*;
 use settings::AppSettings;
 use smol::fs;
@@ -260,7 +260,7 @@ impl Render for EditProfile {
                     .flex_col()
                     .gap_1()
                     .text_sm()
-                    .child(shared_t!("profile.label_name"))
+                    .child(SharedString::new(t!("profile.label_name")))
                     .child(TextInput::new(&self.name_input).small()),
             )
             .child(
@@ -269,7 +269,7 @@ impl Render for EditProfile {
                     .flex_col()
                     .gap_1()
                     .text_sm()
-                    .child(shared_t!("profile.label_website"))
+                    .child(SharedString::new(t!("profile.label_website")))
                     .child(TextInput::new(&self.website_input).small()),
             )
             .child(
@@ -278,7 +278,7 @@ impl Render for EditProfile {
                     .flex_col()
                     .gap_1()
                     .text_sm()
-                    .child(shared_t!("profile.label_bio"))
+                    .child(SharedString::new(t!("profile.label_bio")))
                     .child(TextInput::new(&self.bio_input).small()),
             )
     }

crates/coop/src/views/login.rs

@@ -1,13 +1,13 @@
 use std::time::Duration;
 
 use client_keys::ClientKeys;
+use common::handle_auth::CoopAuthUrlHandler;
 use global::constants::{ACCOUNT_IDENTIFIER, BUNKER_TIMEOUT};
 use global::nostr_client;
 use gpui::prelude::FluentBuilder;
 use gpui::{
     div, relative, AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle,
-    Focusable, IntoElement, ParentElement, Render, SharedString, Styled, Subscription, Task,
-    Window,
+    Focusable, IntoElement, ParentElement, Render, SharedString, Styled, Subscription, Window,
 };
 use i18n::{shared_t, t};
 use nostr_connect::prelude::*;
@@ -19,8 +19,6 @@ use ui::input::{InputEvent, InputState, TextInput};
 use ui::popup_menu::PopupMenu;
 use ui::{v_flex, ContextModal, Disableable, Sizable, StyledExt};
 
-use crate::actions::CoopAuthUrlHandler;
-
 pub fn init(window: &mut Window, cx: &mut App) -> Entity<Login> {
     Login::new(window, cx)
 }
@@ -293,22 +291,30 @@ impl Login {
 
         // Handle connection
         cx.spawn_in(window, async move |this, cx| {
+            let client = nostr_client();
+
             match signer.bunker_uri().await {
                 Ok(uri) => {
                     this.update(cx, |this, cx| {
-                        this.write_uri_to_disk(signer, uri, cx);
+                        this.write_uri_to_disk(&uri, cx);
                     })
                     .ok();
+
+                    // Set the client's signer with the current nostr connect instance
+                    client.set_signer(signer).await;
                 }
                 Err(error) => {
-                    this.update_in(cx, |this, window, cx| {
-                        this.set_error(error.to_string(), window, cx);
-                        // Force reset the client keys
-                        //
-                        // This step is necessary to ensure that user can retry the connection
-                        client_keys.update(cx, |this, cx| {
-                            this.force_new_keys(cx);
-                        });
+                    cx.update(|window, cx| {
+                        this.update(cx, |this, cx| {
+                            this.set_error(error.to_string(), window, cx);
+                            // Force reset the client keys
+                            //
+                            // This step is necessary to ensure that user can retry the connection
+                            client_keys.update(cx, |this, cx| {
+                                this.force_new_keys(cx);
+                            });
+                        })
+                        .ok();
                     })
                     .ok();
                 }
@@ -317,41 +323,38 @@ impl Login {
         .detach();
     }
 
-    fn write_uri_to_disk(
-        &mut self,
-        signer: NostrConnect,
-        uri: NostrConnectURI,
-        cx: &mut Context<Self>,
-    ) {
-        let mut uri_without_secret = uri.to_string();
+    fn write_uri_to_disk(&mut self, uri: &NostrConnectURI, cx: &mut Context<Self>) {
+        let Some(public_key) = uri.remote_signer_public_key().cloned() else {
+            log::error!("Remote Signer's public key not found");
+            return;
+        };
 
-        // Clear the secret parameter in the URI if it exists
+        let mut value = uri.to_string();
+
+        // Clear the secret param if it exists
         if let Some(secret) = uri.secret() {
-            uri_without_secret = uri_without_secret.replace(secret, "");
+            value = value.replace(secret, "");
         }
 
-        let task: Task<Result<(), anyhow::Error>> = cx.background_spawn(async move {
+        cx.background_spawn(async move {
             let client = nostr_client();
+            let keys = Keys::generate();
+            let tags = vec![Tag::identifier(ACCOUNT_IDENTIFIER)];
+            let kind = Kind::ApplicationSpecificData;
 
-            // Update the client's signer
-            client.set_signer(signer).await;
-
-            let signer = client.signer().await?;
-            let public_key = signer.get_public_key().await?;
-
-            let event = EventBuilder::new(Kind::ApplicationSpecificData, uri_without_secret)
-                .tags(vec![Tag::identifier(ACCOUNT_IDENTIFIER)])
+            let builder = EventBuilder::new(kind, value)
+                .tags(tags)
                 .build(public_key)
-                .sign(&Keys::generate())
-                .await?;
+                .sign(&keys)
+                .await;
 
-            // Save the event to the database
-            client.database().save_event(&event).await?;
-
-            Ok(())
-        });
-
-        task.detach();
+            if let Ok(event) = builder {
+                if let Err(e) = client.database().save_event(&event).await {
+                    log::error!("Failed to save event: {e}");
+                };
+            }
+        })
+        .detach();
     }
 
     pub fn write_keys_to_disk(&self, keys: &Keys, password: String, cx: &mut Context<Self>) {

crates/coop/src/views/new_account.rs

@@ -14,7 +14,7 @@ use settings::AppSettings;
 use smol::fs;
 use theme::ActiveTheme;
 use ui::avatar::Avatar;
-use ui::button::{Button, ButtonVariants};
+use ui::button::{Button, ButtonRounded, ButtonVariants};
 use ui::dock_area::panel::{Panel, PanelEvent};
 use ui::input::{InputState, TextInput};
 use ui::modal::ModalButtonProps;
@@ -352,7 +352,7 @@ impl Render for NewAccount {
                                             .label(t!("common.upload"))
                                             .ghost()
                                             .small()
-                                            .rounded()
+                                            .rounded(ButtonRounded::Full)
                                             .disabled(self.submitting || self.uploading)
                                             .loading(self.uploading)
                                             .on_click(cx.listener(move |this, _, window, cx| {

crates/coop/src/views/onboarding.rs

@@ -135,6 +135,7 @@ impl Onboarding {
         self._tasks.push(
             // Wait for Nostr Connect approval
             cx.spawn_in(window, async move |this, cx| {
+                let client = nostr_client();
                 let connect = this.read_with(cx, |this, cx| this.nostr_connect.read(cx).clone());
 
                 if let Ok(Some(signer)) = connect {
@@ -142,9 +143,12 @@ impl Onboarding {
                         Ok(uri) => {
                             this.update(cx, |this, cx| {
                                 this.set_connecting(cx);
-                                this.write_uri_to_disk(signer, uri, cx);
+                                this.write_uri_to_disk(&uri, cx);
                             })
                             .ok();
+
+                            // Set the client's signer with the current nostr connect instance
+                            client.set_signer(signer).await;
                         }
                         Err(e) => {
                             this.update_in(cx, |_, window, cx| {
@@ -165,41 +169,38 @@ impl Onboarding {
         ChatSpace::proxy_signer(window, cx);
     }
 
-    fn write_uri_to_disk(
-        &mut self,
-        signer: NostrConnect,
-        uri: NostrConnectURI,
-        cx: &mut Context<Self>,
-    ) {
-        let mut uri_without_secret = uri.to_string();
+    fn write_uri_to_disk(&mut self, uri: &NostrConnectURI, cx: &mut Context<Self>) {
+        let Some(public_key) = uri.remote_signer_public_key().cloned() else {
+            log::error!("Remote Signer's public key not found");
+            return;
+        };
 
-        // Clear the secret parameter in the URI if it exists
+        let mut value = uri.to_string();
+
+        // Clear the secret param if it exists
         if let Some(secret) = uri.secret() {
-            uri_without_secret = uri_without_secret.replace(secret, "");
+            value = value.replace(secret, "");
         }
 
-        let task: Task<Result<(), anyhow::Error>> = cx.background_spawn(async move {
+        cx.background_spawn(async move {
             let client = nostr_client();
+            let keys = Keys::generate();
+            let tags = vec![Tag::identifier(ACCOUNT_IDENTIFIER)];
+            let kind = Kind::ApplicationSpecificData;
 
-            // Update the client's signer
-            client.set_signer(signer).await;
-
-            let signer = client.signer().await?;
-            let public_key = signer.get_public_key().await?;
-
-            let event = EventBuilder::new(Kind::ApplicationSpecificData, uri_without_secret)
-                .tags(vec![Tag::identifier(ACCOUNT_IDENTIFIER)])
+            let builder = EventBuilder::new(kind, value)
+                .tags(tags)
                 .build(public_key)
-                .sign(&Keys::generate())
-                .await?;
+                .sign(&keys)
+                .await;
 
-            // Save the event to the database
-            client.database().save_event(&event).await?;
-
-            Ok(())
-        });
-
-        task.detach();
+            if let Ok(event) = builder {
+                if let Err(e) = client.database().save_event(&event).await {
+                    log::error!("Failed to save event: {e}");
+                };
+            }
+        })
+        .detach();
     }
 
     fn copy_uri(&mut self, window: &mut Window, cx: &mut Context<Self>) {

crates/coop/src/views/preferences.rs

@@ -1,4 +1,4 @@
-use common::display::RenderedProfile;
+use common::display::ReadableProfile;
 use gpui::http_client::Url;
 use gpui::{
     div, px, relative, rems, App, AppContext, Context, Entity, InteractiveElement, IntoElement,
@@ -10,7 +10,7 @@ use registry::Registry;
 use settings::AppSettings;
 use theme::ActiveTheme;
 use ui::avatar::Avatar;
-use ui::button::{Button, ButtonVariants};
+use ui::button::{Button, ButtonRounded, ButtonVariants};
 use ui::input::{InputState, TextInput};
 use ui::modal::ModalButtonProps;
 use ui::switch::Switch;
@@ -141,7 +141,7 @@ impl Render for Preferences {
                                 h_flex()
                                     .id("user")
                                     .gap_2()
-                                    .child(Avatar::new(profile.avatar(proxy)).size(rems(2.4)))
+                                    .child(Avatar::new(profile.avatar_url(proxy)).size(rems(2.4)))
                                     .child(
                                         div()
                                             .flex_1()
@@ -169,7 +169,7 @@ impl Render for Preferences {
                                     .label("Messaging Relays")
                                     .xsmall()
                                     .ghost_alt()
-                                    .rounded()
+                                    .rounded(ButtonRounded::Full)
                                     .on_click(cx.listener(move |this, _e, window, cx| {
                                         this.open_relays(window, cx);
                                     })),
@@ -204,7 +204,7 @@ impl Render for Preferences {
                                             .on_click(move |_, _window, cx| {
                                                 if let Some(input) = input_state.upgrade() {
                                                     let Ok(url) =
-                                                        Url::parse(&input.read(cx).value())
+                                                        Url::parse(input.read(cx).value())
                                                     else {
                                                         return;
                                                     };

crates/coop/src/views/screening.rs

@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use common::display::{shorten_pubkey, RenderedProfile, RenderedTimestamp};
+use common::display::{shorten_pubkey, ReadableProfile, ReadableTimestamp};
 use common::nip05::nip05_verify;
 use global::constants::BOOTSTRAP_RELAYS;
 use global::nostr_client;
@@ -17,7 +17,7 @@ use settings::AppSettings;
 use smallvec::{smallvec, SmallVec};
 use theme::ActiveTheme;
 use ui::avatar::Avatar;
-use ui::button::{Button, ButtonVariants};
+use ui::button::{Button, ButtonRounded, ButtonVariants};
 use ui::indicator::Indicator;
 use ui::{h_flex, v_flex, ContextModal, Icon, IconName, Sizable, StyledExt};
 
@@ -29,9 +29,10 @@ pub struct Screening {
     profile: Profile,
     verified: bool,
     followed: bool,
+    dm_relays: Option<bool>,
     last_active: Option<Timestamp>,
     mutual_contacts: Vec<Profile>,
-    _tasks: SmallVec<[Task<()>; 3]>,
+    _tasks: SmallVec<[Task<()>; 4]>,
 }
 
 impl Screening {
@@ -82,6 +83,24 @@ impl Screening {
             activity
         });
 
+        let relay_check = cx.background_spawn(async move {
+            let client = nostr_client();
+            let mut relay = false;
+
+            let filter = Filter::new()
+                .kind(Kind::InboxRelays)
+                .author(public_key)
+                .limit(1);
+
+            if let Ok(mut stream) = client.stream_events(filter, Duration::from_secs(2)).await {
+                while stream.next().await.is_some() {
+                    relay = true
+                }
+            }
+
+            relay
+        });
+
         let addr_check = if let Some(address) = profile.metadata().nip05 {
             Some(Tokio::spawn(cx, async move {
                 nip05_verify(public_key, &address).await.unwrap_or(false)
@@ -117,6 +136,19 @@ impl Screening {
             }),
         );
 
+        tasks.push(
+            // Run the relay check in the background
+            cx.spawn_in(window, async move |this, cx| {
+                let relay = relay_check.await;
+
+                this.update(cx, |this, cx| {
+                    this.dm_relays = Some(relay);
+                    cx.notify();
+                })
+                .ok();
+            }),
+        );
+
         tasks.push(
             // Run the NIP-05 verification in the background
             cx.spawn_in(window, async move |this, cx| {
@@ -136,6 +168,7 @@ impl Screening {
             profile,
             verified: false,
             followed: false,
+            dm_relays: None,
             last_active: None,
             mutual_contacts: vec![],
             _tasks: tasks,
@@ -202,7 +235,9 @@ impl Screening {
                                         .hover(|this| {
                                             this.bg(cx.theme().elevated_surface_background)
                                         })
-                                        .child(Avatar::new(contact.avatar(true)).size(rems(1.75)))
+                                        .child(
+                                            Avatar::new(contact.avatar_url(true)).size(rems(1.75)),
+                                        )
                                         .child(contact.display_name()),
                                 );
                             }
@@ -232,7 +267,7 @@ impl Render for Screening {
                     .items_center()
                     .justify_center()
                     .text_center()
-                    .child(Avatar::new(self.profile.avatar(proxy)).size(rems(4.)))
+                    .child(Avatar::new(self.profile.avatar_url(proxy)).size(rems(4.)))
                     .child(
                         div()
                             .font_semibold()
@@ -266,7 +301,7 @@ impl Render for Screening {
                                     .label(t!("profile.njump"))
                                     .secondary()
                                     .small()
-                                    .rounded()
+                                    .rounded(ButtonRounded::Full)
                                     .on_click(cx.listener(move |this, _e, window, cx| {
                                         this.open_njump(window, cx);
                                     })),
@@ -276,7 +311,7 @@ impl Render for Screening {
                                     .tooltip(t!("screening.report"))
                                     .icon(IconName::Report)
                                     .danger()
-                                    .rounded()
+                                    .rounded(ButtonRounded::Full)
                                     .on_click(cx.listener(move |this, _e, window, cx| {
                                         this.report(window, cx);
                                     })),
@@ -328,7 +363,7 @@ impl Render for Screening {
                                                     .icon(IconName::Info)
                                                     .xsmall()
                                                     .ghost()
-                                                    .rounded()
+                                                    .rounded(ButtonRounded::Full)
                                                     .tooltip(t!("screening.active_tooltip")),
                                             ),
                                     )
@@ -400,7 +435,7 @@ impl Render for Screening {
                                                     .icon(IconName::Info)
                                                     .xsmall()
                                                     .ghost()
-                                                    .rounded()
+                                                    .rounded(ButtonRounded::Full)
                                                     .on_click(cx.listener(
                                                         move |this, _, window, cx| {
                                                             this.mutual_contacts(window, cx);
@@ -421,6 +456,37 @@ impl Render for Screening {
                                             }),
                                     ),
                             ),
+                    )
+                    .child(
+                        h_flex()
+                            .items_start()
+                            .gap_2()
+                            .child(status_badge(self.dm_relays, cx))
+                            .child(
+                                v_flex()
+                                    .w_full()
+                                    .text_sm()
+                                    .child({
+                                        if self.dm_relays == Some(true) {
+                                            shared_t!("screening.relay_found")
+                                        } else {
+                                            shared_t!("screening.relay_empty")
+                                        }
+                                    })
+                                    .child(
+                                        div()
+                                            .w_full()
+                                            .line_clamp(1)
+                                            .text_color(cx.theme().text_muted)
+                                            .child({
+                                                if self.dm_relays == Some(true) {
+                                                    shared_t!("screening.relay_found_desc")
+                                                } else {
+                                                    shared_t!("screening.relay_empty_desc")
+                                                }
+                                            }),
+                                    ),
+                            ),
                     ),
             )
     }

crates/coop/src/views/setup_relay.rs

@@ -2,7 +2,7 @@ use std::time::Duration;
 
 use anyhow::{anyhow, Error};
 use global::constants::NIP17_RELAYS;
-use global::{app_state, nostr_client};
+use global::{css, nostr_client};
 use gpui::prelude::FluentBuilder;
 use gpui::{
     div, px, uniform_list, App, AppContext, Context, Entity, InteractiveElement, IntoElement,
@@ -14,7 +14,7 @@ use nostr_sdk::prelude::*;
 use registry::Registry;
 use smallvec::{smallvec, SmallVec};
 use theme::ActiveTheme;
-use ui::button::{Button, ButtonVariants};
+use ui::button::{Button, ButtonRounded, ButtonVariants};
 use ui::input::{InputEvent, InputState, TextInput};
 use ui::modal::ModalButtonProps;
 use ui::{h_flex, v_flex, ContextModal, IconName, Sizable, StyledExt};
@@ -33,7 +33,7 @@ where
             .label(label)
             .warning()
             .xsmall()
-            .rounded()
+            .rounded(ButtonRounded::Full)
             .on_click(move |_, window, cx| {
                 let view = cx.new(|cx| SetupRelay::new(Kind::InboxRelays, window, cx));
                 let weak_view = view.downgrade();
@@ -218,7 +218,7 @@ impl SetupRelay {
             }
 
             // Fetch gift wrap events
-            let sub_id = app_state().gift_wrap_sub_id.clone();
+            let sub_id = css().gift_wrap_sub_id.clone();
             let filter = Filter::new().kind(Kind::GiftWrap).pubkey(public_key);
 
             if client

crates/coop/src/views/sidebar/list_item.rs

@@ -3,7 +3,7 @@ use std::rc::Rc;
 use gpui::prelude::FluentBuilder;
 use gpui::{
     div, rems, App, ClickEvent, InteractiveElement, IntoElement, ParentElement as _, RenderOnce,
-    SharedString, SharedUri, StatefulInteractiveElement, Styled, Window,
+    SharedString, StatefulInteractiveElement, Styled, Window,
 };
 use i18n::t;
 use nostr_sdk::prelude::*;
@@ -11,9 +11,7 @@ use registry::room::RoomKind;
 use registry::Registry;
 use settings::AppSettings;
 use theme::ActiveTheme;
-use ui::actions::{CopyPublicKey, OpenPublicKey};
 use ui::avatar::Avatar;
-use ui::context_menu::ContextMenuExt;
 use ui::modal::ModalButtonProps;
 use ui::skeleton::Skeleton;
 use ui::{h_flex, ContextModal, StyledExt};
@@ -26,7 +24,7 @@ pub struct RoomListItem {
     room_id: Option<u64>,
     public_key: Option<PublicKey>,
     name: Option<SharedString>,
-    avatar: Option<SharedUri>,
+    avatar: Option<SharedString>,
     created_at: Option<SharedString>,
     kind: Option<RoomKind>,
     #[allow(clippy::type_complexity)]
@@ -62,7 +60,7 @@ impl RoomListItem {
         self
     }
 
-    pub fn avatar(mut self, avatar: impl Into<SharedUri>) -> Self {
+    pub fn avatar(mut self, avatar: impl Into<SharedString>) -> Self {
         self.avatar = Some(avatar.into());
         self
     }
@@ -168,10 +166,6 @@ impl RenderOnce for RoomListItem {
                     ),
             )
             .hover(|this| this.bg(cx.theme().elevated_surface_background))
-            .context_menu(move |this, _window, _cx| {
-                this.menu(t!("profile.view"), Box::new(OpenPublicKey(public_key)))
-                    .menu(t!("profile.copy"), Box::new(CopyPublicKey(public_key)))
-            })
             .on_click(move |event, window, cx| {
                 handler(event, window, cx);
 

crates/coop/src/views/sidebar/mod.rs

@@ -4,14 +4,14 @@ use std::time::Duration;
 
 use anyhow::{anyhow, Error};
 use common::debounced_delay::DebouncedDelay;
-use common::display::{RenderedTimestamp, TextUtils};
+use common::display::{ReadableTimestamp, TextUtils};
 use global::constants::{BOOTSTRAP_RELAYS, SEARCH_RELAYS};
-use global::{app_state, nostr_client, UnwrappingStatus};
+use global::{css, nostr_client, UnwrappingStatus};
 use gpui::prelude::FluentBuilder;
 use gpui::{
-    deferred, div, relative, uniform_list, AnyElement, App, AppContext, Context, Entity,
-    EventEmitter, FocusHandle, Focusable, InteractiveElement, IntoElement, ParentElement, Render,
-    RetainAllImageCache, SharedString, Styled, Subscription, Task, Window,
+    div, uniform_list, AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle,
+    Focusable, InteractiveElement, IntoElement, ParentElement, Render, RetainAllImageCache,
+    SharedString, Styled, Subscription, Task, Window,
 };
 use gpui_tokio::Tokio;
 use i18n::{shared_t, t};
@@ -23,7 +23,7 @@ use registry::{Registry, RegistryEvent};
 use settings::AppSettings;
 use smallvec::{smallvec, SmallVec};
 use theme::ActiveTheme;
-use ui::button::{Button, ButtonVariants};
+use ui::button::{Button, ButtonRounded, ButtonVariants};
 use ui::dock_area::panel::{Panel, PanelEvent};
 use ui::input::{InputEvent, InputState, TextInput};
 use ui::popup_menu::{PopupMenu, PopupMenuExt};
@@ -56,7 +56,7 @@ pub struct Sidebar {
     focus_handle: FocusHandle,
     image_cache: Entity<RetainAllImageCache>,
     #[allow(dead_code)]
-    subscriptions: SmallVec<[Subscription; 3]>,
+    subscriptions: SmallVec<[Subscription; 2]>,
 }
 
 impl Sidebar {
@@ -77,35 +77,28 @@ impl Sidebar {
         let registry = Registry::global(cx);
         let mut subscriptions = smallvec![];
 
-        subscriptions.push(
-            // Clear the image cache when sidebar is closed
-            cx.on_release_in(window, move |this, window, cx| {
-                this.image_cache.update(cx, |this, cx| {
-                    this.clear(window, cx);
-                })
-            }),
-        );
-
-        subscriptions.push(
-            // Subscribe for registry new events
-            cx.subscribe_in(&registry, window, move |this, _, event, _window, cx| {
+        subscriptions.push(cx.subscribe_in(
+            &registry,
+            window,
+            move |this, _, event, _window, cx| {
                 if let RegistryEvent::NewRequest(kind) = event {
                     this.indicator.update(cx, |this, cx| {
                         *this = Some(kind.to_owned());
                         cx.notify();
                     });
                 }
-            }),
-        );
+            },
+        ));
 
-        subscriptions.push(
-            // Subscribe for find input events
-            cx.subscribe_in(&find_input, window, |this, state, event, window, cx| {
+        subscriptions.push(cx.subscribe_in(
+            &find_input,
+            window,
+            |this, _state, event, window, cx| {
                 match event {
                     InputEvent::PressEnter { .. } => this.search(window, cx),
-                    InputEvent::Change => {
+                    InputEvent::Change(text) => {
                         // Clear the result when input is empty
-                        if state.read(cx).value().is_empty() {
+                        if text.is_empty() {
                             this.clear_search_results(window, cx);
                         } else {
                             // Run debounced search
@@ -119,8 +112,8 @@ impl Sidebar {
                     }
                     _ => {}
                 }
-            }),
-        );
+            },
+        ));
 
         Self {
             name: "Sidebar".into(),
@@ -162,7 +155,7 @@ impl Sidebar {
         Self::request_metadata(client, public_key).await?;
 
         // Create a temporary room
-        let room = Room::from(&event).current_user(identity);
+        let room = Room::new(&event).rearrange_by(identity);
 
         Ok(room)
     }
@@ -537,8 +530,8 @@ impl Sidebar {
     fn on_manage(&mut self, _ev: &RelayStatus, window: &mut Window, cx: &mut Context<Self>) {
         let task: Task<Result<Vec<Relay>, Error>> = cx.background_spawn(async move {
             let client = nostr_client();
-            let app_state = app_state();
-            let subscription = client.subscription(&app_state.gift_wrap_sub_id).await;
+            let css = css();
+            let subscription = client.subscription(&css.gift_wrap_sub_id).await;
             let mut relays: Vec<Relay> = vec![];
 
             for (url, _filter) in subscription.into_iter() {
@@ -676,7 +669,6 @@ impl Focusable for Sidebar {
 impl Render for Sidebar {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let registry = Registry::read_global(cx);
-        let loading = registry.unwrapping_status.read(cx) != &UnwrappingStatus::Complete;
 
         // Get rooms from either search results or the chat registry
         let rooms = if let Some(results) = self.local_result.read(cx).as_ref() {
@@ -696,7 +688,7 @@ impl Render for Sidebar {
         let mut total_rooms = rooms.len();
 
         // Add 3 dummy rooms to display as skeletons
-        if loading {
+        if registry.unwrapping_status.read(cx) != &UnwrappingStatus::Complete {
             total_rooms += 3
         }
 
@@ -722,7 +714,6 @@ impl Render for Sidebar {
                             .small()
                             .cleanable()
                             .appearance(true)
-                            .text_xs()
                             .suffix(
                                 Button::new("find")
                                     .icon(IconName::Search)
@@ -752,16 +743,16 @@ impl Render for Sidebar {
                                     .tooltip(t!("sidebar.all_conversations_tooltip"))
                                     .when_some(self.indicator.read(cx).as_ref(), |this, kind| {
                                         this.when(kind == &RoomKind::Ongoing, |this| {
-                                            this.child(deferred(
+                                            this.child(
                                                 div().size_1().rounded_full().bg(cx.theme().cursor),
-                                            ))
+                                            )
                                         })
                                     })
                                     .small()
                                     .cta()
                                     .bold()
                                     .secondary()
-                                    .rounded()
+                                    .rounded(ButtonRounded::Full)
                                     .selected(self.filter(&RoomKind::Ongoing, cx))
                                     .on_click(cx.listener(|this, _, _, cx| {
                                         this.set_filter(RoomKind::Ongoing, cx);
@@ -773,16 +764,16 @@ impl Render for Sidebar {
                                     .tooltip(t!("sidebar.requests_tooltip"))
                                     .when_some(self.indicator.read(cx).as_ref(), |this, kind| {
                                         this.when(kind != &RoomKind::Ongoing, |this| {
-                                            this.child(deferred(
+                                            this.child(
                                                 div().size_1().rounded_full().bg(cx.theme().cursor),
-                                            ))
+                                            )
                                         })
                                     })
                                     .small()
                                     .cta()
                                     .bold()
                                     .secondary()
-                                    .rounded()
+                                    .rounded(ButtonRounded::Full)
                                     .selected(!self.filter(&RoomKind::Ongoing, cx))
                                     .on_click(cx.listener(|this, _, _, cx| {
                                         this.set_filter(RoomKind::default(), cx);
@@ -800,7 +791,7 @@ impl Render for Sidebar {
                                             .icon(IconName::Ellipsis)
                                             .xsmall()
                                             .ghost()
-                                            .rounded()
+                                            .rounded(ButtonRounded::Full)
                                             .popup_menu(move |this, _window, _cx| {
                                                 this.menu(
                                                     t!("sidebar.reload_menu"),
@@ -814,57 +805,6 @@ impl Render for Sidebar {
                                     ),
                             ),
                     )
-                    .when(!loading && total_rooms == 0, |this| {
-                        this.map(|this| {
-                            if self.filter(&RoomKind::Ongoing, cx) {
-                                this.child(deferred(
-                                    v_flex()
-                                        .py_2()
-                                        .gap_1p5()
-                                        .items_center()
-                                        .justify_center()
-                                        .text_center()
-                                        .child(
-                                            div()
-                                                .text_sm()
-                                                .font_semibold()
-                                                .line_height(relative(1.25))
-                                                .child(shared_t!("sidebar.no_conversations")),
-                                        )
-                                        .child(
-                                            div()
-                                                .text_xs()
-                                                .text_color(cx.theme().text_muted)
-                                                .line_height(relative(1.25))
-                                                .child(shared_t!("sidebar.no_conversations_label")),
-                                        ),
-                                ))
-                            } else {
-                                this.child(deferred(
-                                    v_flex()
-                                        .py_2()
-                                        .gap_1p5()
-                                        .items_center()
-                                        .justify_center()
-                                        .text_center()
-                                        .child(
-                                            div()
-                                                .text_sm()
-                                                .font_semibold()
-                                                .line_height(relative(1.25))
-                                                .child(shared_t!("sidebar.no_requests")),
-                                        )
-                                        .child(
-                                            div()
-                                                .text_xs()
-                                                .text_color(cx.theme().text_muted)
-                                                .line_height(relative(1.25))
-                                                .child(shared_t!("sidebar.no_requests_label")),
-                                        ),
-                                ))
-                            }
-                        })
-                    })
                     .child(
                         uniform_list(
                             "rooms",

crates/coop/src/views/user_profile.rs

@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use common::display::RenderedProfile;
+use common::display::ReadableProfile;
 use common::nip05::nip05_verify;
 use global::nostr_client;
 use gpui::prelude::FluentBuilder;
@@ -17,7 +17,7 @@ use smallvec::{smallvec, SmallVec};
 use theme::ActiveTheme;
 use ui::avatar::Avatar;
 use ui::button::{Button, ButtonVariants};
-use ui::{h_flex, v_flex, Icon, IconName, Sizable, StyledExt};
+use ui::{h_flex, v_flex, Disableable, Icon, IconName, Sizable, StyledExt};
 
 pub fn init(public_key: PublicKey, window: &mut Window, cx: &mut App) -> Entity<UserProfile> {
     cx.new(|cx| UserProfile::new(public_key, window, cx))
@@ -32,24 +32,27 @@ pub struct UserProfile {
 }
 
 impl UserProfile {
-    pub fn new(target: PublicKey, window: &mut Window, cx: &mut Context<Self>) -> Self {
+    pub fn new(public_key: PublicKey, window: &mut Window, cx: &mut Context<Self>) -> Self {
         let registry = Registry::read_global(cx);
-        let profile = registry.get_person(&target, cx);
+        let identity = registry.identity(cx).public_key();
+        let profile = registry.get_person(&public_key, cx);
 
         let mut tasks = smallvec![];
 
-        let check_follow: Task<Result<bool, Error>> = cx.background_spawn(async move {
+        let check_follow: Task<bool> = cx.background_spawn(async move {
             let client = nostr_client();
-            let signer = client.signer().await?;
-            let public_key = signer.get_public_key().await?;
-            let contact_list = client.database().contacts_public_keys(public_key).await?;
+            let filter = Filter::new()
+                .kind(Kind::ContactList)
+                .author(identity)
+                .pubkey(public_key)
+                .limit(1);
 
-            Ok(contact_list.contains(&target))
+            client.database().count(filter).await.unwrap_or(0) >= 1
         });
 
         let verify_nip05 = if let Some(address) = profile.metadata().nip05 {
             Some(Tokio::spawn(cx, async move {
-                nip05_verify(target, &address).await.unwrap_or(false)
+                nip05_verify(public_key, &address).await.unwrap_or(false)
             }))
         } else {
             None
@@ -58,7 +61,7 @@ impl UserProfile {
         tasks.push(
             // Load user profile data
             cx.spawn_in(window, async move |this, cx| {
-                let followed = check_follow.await.unwrap_or(false);
+                let followed = check_follow.await;
 
                 // Update the followed status
                 this.update(cx, |this, cx| {
@@ -125,19 +128,19 @@ impl UserProfile {
 impl Render for UserProfile {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let proxy = AppSettings::get_proxy_user_avatars(cx);
-        let bech32 = self.profile.public_key().to_bech32().unwrap();
-        let shared_bech32 = SharedString::from(bech32);
+
+        let Ok(bech32) = self.profile.public_key().to_bech32();
+        let shared_bech32 = SharedString::new(bech32);
 
         v_flex()
             .gap_4()
-            .text_sm()
             .child(
                 v_flex()
                     .gap_3()
                     .items_center()
                     .justify_center()
                     .text_center()
-                    .child(Avatar::new(self.profile.avatar(proxy)).size(rems(4.)))
+                    .child(Avatar::new(self.profile.avatar_url(proxy)).size(rems(4.)))
                     .child(
                         v_flex()
                             .child(
@@ -186,10 +189,12 @@ impl Render for UserProfile {
             .child(
                 v_flex()
                     .gap_1()
+                    .text_sm()
                     .child(
                         div()
+                            .block()
                             .text_color(cx.theme().text_muted)
-                            .child(SharedString::from("Public Key:")),
+                            .child("Public Key:"),
                     )
                     .child(
                         h_flex()
@@ -197,13 +202,12 @@ impl Render for UserProfile {
                             .child(
                                 div()
                                     .p_2()
-                                    .h_7()
+                                    .h_9()
                                     .rounded_md()
                                     .bg(cx.theme().elevated_surface_background)
                                     .truncate()
                                     .text_ellipsis()
                                     .line_clamp(1)
-                                    .line_height(relative(1.))
                                     .child(shared_bech32),
                             )
                             .child(
@@ -215,8 +219,8 @@ impl Render for UserProfile {
                                             IconName::Copy
                                         }
                                     })
-                                    .cta()
-                                    .ghost_alt()
+                                    .ghost()
+                                    .disabled(self.copied)
                                     .on_click(cx.listener(move |this, _e, window, cx| {
                                         this.copy_pubkey(window, cx);
                                     })),
@@ -226,6 +230,7 @@ impl Render for UserProfile {
             .child(
                 v_flex()
                     .gap_1()
+                    .text_sm()
                     .child(
                         div()
                             .text_color(cx.theme().text_muted)
@@ -240,8 +245,7 @@ impl Render for UserProfile {
                                 self.profile
                                     .metadata()
                                     .about
-                                    .map(SharedString::from)
-                                    .unwrap_or(shared_t!("profile.no_bio")),
+                                    .unwrap_or(t!("profile.no_bio").to_string()),
                             ),
                     ),
             )

crates/coop/src/views/welcome.rs

@@ -1,13 +1,12 @@
 use gpui::{
     div, svg, AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable,
-    InteractiveElement, IntoElement, ParentElement, Render, SharedString,
-    StatefulInteractiveElement, Styled, Window,
+    IntoElement, ParentElement, Render, SharedString, Styled, Window,
 };
 use theme::ActiveTheme;
 use ui::button::Button;
 use ui::dock_area::panel::{Panel, PanelEvent};
 use ui::popup_menu::PopupMenu;
-use ui::{v_flex, StyledExt};
+use ui::StyledExt;
 
 pub fn init(window: &mut Window, cx: &mut App) -> Entity<Welcome> {
     Welcome::new(window, cx)
@@ -15,7 +14,8 @@ pub fn init(window: &mut Window, cx: &mut App) -> Entity<Welcome> {
 
 pub struct Welcome {
     name: SharedString,
-    version: SharedString,
+    closable: bool,
+    zoomable: bool,
     focus_handle: FocusHandle,
 }
 
@@ -25,11 +25,10 @@ impl Welcome {
     }
 
     fn view(_window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let version = SharedString::from(format!("Version: {}", env!("CARGO_PKG_VERSION")));
-
         Self {
-            version,
             name: "Welcome".into(),
+            closable: true,
+            zoomable: true,
             focus_handle: cx.focus_handle(),
         }
     }
@@ -40,15 +39,16 @@ impl Panel for Welcome {
         self.name.clone()
     }
 
-    fn title(&self, cx: &App) -> AnyElement {
-        div()
-            .child(
-                svg()
-                    .path("brand/coop.svg")
-                    .size_4()
-                    .text_color(cx.theme().element_background),
-            )
-            .into_any_element()
+    fn title(&self, _cx: &App) -> AnyElement {
+        "👋".into_any_element()
+    }
+
+    fn closable(&self, _cx: &App) -> bool {
+        self.closable
+    }
+
+    fn zoomable(&self, _cx: &App) -> bool {
+        self.zoomable
     }
 
     fn popup_menu(&self, menu: PopupMenu, _cx: &App) -> PopupMenu {
@@ -76,10 +76,11 @@ impl Render for Welcome {
             .items_center()
             .justify_center()
             .child(
-                v_flex()
-                    .gap_2()
+                div()
+                    .flex()
+                    .flex_col()
                     .items_center()
-                    .justify_center()
+                    .gap_1()
                     .child(
                         svg()
                             .path("brand/coop.svg")
@@ -87,26 +88,11 @@ impl Render for Welcome {
                             .text_color(cx.theme().elevated_surface_background),
                     )
                     .child(
-                        v_flex()
-                            .items_center()
-                            .justify_center()
-                            .text_center()
-                            .child(
-                                div()
-                                    .font_semibold()
-                                    .text_color(cx.theme().text_muted)
-                                    .child(SharedString::from("coop on nostr")),
-                            )
-                            .child(
-                                div()
-                                    .id("version")
-                                    .text_color(cx.theme().text_placeholder)
-                                    .text_xs()
-                                    .child(self.version.clone())
-                                    .on_click(|_, _window, cx| {
-                                        cx.open_url("https://github.com/lumehq/coop/releases");
-                                    }),
-                            ),
+                        div()
+                            .child("coop on nostr")
+                            .text_color(cx.theme().text_placeholder)
+                            .font_semibold()
+                            .text_sm(),
                     ),
             )
     }

crates/global/src/lib.rs

@@ -57,7 +57,7 @@ pub enum UnwrappingStatus {
 
 /// Signals sent through the global event channel to notify UI
 #[derive(Debug)]
-pub enum SignalKind {
+pub enum Signal {
     /// A signal to notify UI that the client's signer has been set
     SignerSet(PublicKey),
 
@@ -71,54 +71,25 @@ pub enum SignalKind {
     ProxyDown,
 
     /// A signal to notify UI that a new profile has been received
-    NewProfile(Profile),
+    Metadata(Profile),
 
     /// A signal to notify UI that a new gift wrap event has been received
-    NewMessage((EventId, Event)),
+    Message((EventId, Event)),
 
-    /// A signal to notify UI that no DM relays for current user was found
-    RelaysNotFound,
+    /// A signal to notify UI that gift wrap process status has changed
+    GiftWrapProcess(UnwrappingStatus),
 
-    /// A signal to notify UI that gift wrap status has changed
-    GiftWrapStatus(UnwrappingStatus),
+    /// A signal to notify UI that no DM relay for current user was found
+    DmRelayNotFound,
 
     /// A signal to notify UI that there are errors or notices occurred
     Notice(Notice),
 }
 
-#[derive(Debug)]
-pub struct Signal {
-    rx: Receiver<SignalKind>,
-    tx: Sender<SignalKind>,
-}
-
-impl Default for Signal {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Signal {
-    pub fn new() -> Self {
-        let (tx, rx) = flume::bounded::<SignalKind>(2048);
-        Self { rx, tx }
-    }
-
-    pub fn receiver(&self) -> &Receiver<SignalKind> {
-        &self.rx
-    }
-
-    pub async fn send(&self, kind: SignalKind) {
-        if let Err(e) = self.tx.send_async(kind).await {
-            log::error!("Failed to send signal: {e}");
-        }
-    }
-}
-
 #[derive(Debug)]
 pub struct Ingester {
-    rx: Receiver<PublicKey>,
-    tx: Sender<PublicKey>,
+    rx: Receiver<Signal>,
+    tx: Sender<Signal>,
 }
 
 impl Default for Ingester {
@@ -129,75 +100,49 @@ impl Default for Ingester {
 
 impl Ingester {
     pub fn new() -> Self {
-        let (tx, rx) = flume::bounded::<PublicKey>(1024);
+        let (tx, rx) = flume::bounded::<Signal>(2048);
         Self { rx, tx }
     }
 
-    pub fn receiver(&self) -> &Receiver<PublicKey> {
+    pub fn signals(&self) -> &Receiver<Signal> {
         &self.rx
     }
 
-    pub async fn send(&self, public_key: PublicKey) {
-        if let Err(e) = self.tx.send_async(public_key).await {
-            log::error!("Failed to send public key: {e}");
+    pub async fn send(&self, signal: Signal) {
+        if let Err(e) = self.tx.send_async(signal).await {
+            log::error!("Failed to send signal: {e}");
         }
     }
 }
 
-/// A simple storage to store all states that using across the application.
+/// A simple storage to store all runtime states that using across the application.
 #[derive(Debug)]
-pub struct AppState {
+pub struct CoopSimpleStorage {
     pub init_at: Timestamp,
-
-    pub last_used_at: Option<Timestamp>,
-
-    pub is_first_run: AtomicBool,
-
     pub gift_wrap_sub_id: SubscriptionId,
-
     pub gift_wrap_processing: AtomicBool,
-
     pub auto_close_opts: Option<SubscribeAutoCloseOptions>,
-
     pub sent_ids: RwLock<HashSet<EventId>>,
-
-    pub seen_on_relays: RwLock<HashMap<EventId, HashSet<RelayUrl>>>,
-
     pub resent_ids: RwLock<Vec<Output<EventId>>>,
-
     pub resend_queue: RwLock<HashMap<EventId, RelayUrl>>,
-
-    pub signal: Signal,
-
-    pub ingester: Ingester,
 }
 
-impl Default for AppState {
+impl Default for CoopSimpleStorage {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl AppState {
+impl CoopSimpleStorage {
     pub fn new() -> Self {
-        let init_at = Timestamp::now();
-        let first_run = first_run();
-        let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
-
-        let signal = Signal::default();
-        let ingester = Ingester::default();
-
         Self {
-            init_at,
-            signal,
-            ingester,
-            last_used_at: None,
-            is_first_run: AtomicBool::new(first_run),
+            init_at: Timestamp::now(),
             gift_wrap_sub_id: SubscriptionId::new("inbox"),
             gift_wrap_processing: AtomicBool::new(false),
-            auto_close_opts: Some(opts),
+            auto_close_opts: Some(
+                SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE),
+            ),
             sent_ids: RwLock::new(HashSet::new()),
-            seen_on_relays: RwLock::new(HashMap::new()),
             resent_ids: RwLock::new(Vec::new()),
             resend_queue: RwLock::new(HashMap::new()),
         }
@@ -205,7 +150,9 @@ impl AppState {
 }
 
 static NOSTR_CLIENT: OnceLock<Client> = OnceLock::new();
-static APP_STATE: OnceLock<AppState> = OnceLock::new();
+static INGESTER: OnceLock<Ingester> = OnceLock::new();
+static COOP_SIMPLE_STORAGE: OnceLock<CoopSimpleStorage> = OnceLock::new();
+static FIRST_RUN: OnceLock<bool> = OnceLock::new();
 
 pub fn nostr_client() -> &'static Client {
     NOSTR_CLIENT.get_or_init(|| {
@@ -223,26 +170,32 @@ pub fn nostr_client() -> &'static Client {
             .automatic_authentication(false)
             .verify_subscriptions(false)
             .sleep_when_idle(SleepWhenIdle::Enabled {
-                timeout: Duration::from_secs(300),
+                timeout: Duration::from_secs(30),
             });
 
         ClientBuilder::default().database(lmdb).opts(opts).build()
     })
 }
 
-pub fn app_state() -> &'static AppState {
-    APP_STATE.get_or_init(AppState::new)
+pub fn ingester() -> &'static Ingester {
+    INGESTER.get_or_init(Ingester::new)
 }
 
-fn first_run() -> bool {
-    let flag = support_dir().join(format!(".{}-first_run", env!("CARGO_PKG_VERSION")));
+pub fn css() -> &'static CoopSimpleStorage {
+    COOP_SIMPLE_STORAGE.get_or_init(CoopSimpleStorage::new)
+}
 
-    if !flag.exists() {
-        if std::fs::write(&flag, "").is_err() {
-            return false;
+pub fn first_run() -> &'static bool {
+    FIRST_RUN.get_or_init(|| {
+        let flag = support_dir().join(format!(".{}-first_run", env!("CARGO_PKG_VERSION")));
+
+        if !flag.exists() {
+            if std::fs::write(&flag, "").is_err() {
+                return false;
+            }
+            true // First run
+        } else {
+            false // Not first run
         }
-        true // First run
-    } else {
-        false // Not first run
-    }
+    })
 }

crates/i18n/src/lib.rs

@@ -29,10 +29,10 @@ macro_rules! init {
 #[macro_export]
 macro_rules! shared_t {
     ($key:expr) => {
-        SharedString::from(t!($key))
+        SharedString::new(t!($key))
     };
     ($key:expr, $($param:ident = $value:expr),+) => {
-        SharedString::from(t!($key, $($param = $value),+))
+        SharedString::new(t!($key, $($param = $value),+))
     };
 }
 

crates/registry/src/lib.rs

@@ -324,7 +324,7 @@ impl Registry {
                 let is_ongoing = client.database().count(filter).await.unwrap_or(1) >= 1;
 
                 // Create a new room
-                let room = Room::from(&event).current_user(public_key);
+                let room = Room::new(&event).rearrange_by(public_key);
 
                 if is_ongoing || bypassed {
                     rooms.insert(room.kind(RoomKind::Ongoing));
@@ -458,7 +458,9 @@ impl Registry {
                 });
             }
         } else {
-            let room = Room::from(&event).current_user(identity);
+            let room = Room::new(&event)
+                .kind(RoomKind::default())
+                .rearrange_by(identity);
 
             // Push the new room to the front of the list
             self.add_room(cx.new(|_| room), cx);

crates/registry/src/message.rs

@@ -5,7 +5,6 @@ use nostr_sdk::prelude::*;
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub enum Message {
     User(RenderedMessage),
-    Warning(String, Timestamp),
     System(Timestamp),
 }
 
@@ -14,33 +13,18 @@ impl Message {
         Self::User(user.into())
     }
 
-    pub fn warning(content: String) -> Self {
-        Self::Warning(content, Timestamp::now())
-    }
-
     pub fn system() -> Self {
         Self::System(Timestamp::default())
     }
-
-    fn timestamp(&self) -> &Timestamp {
-        match self {
-            Message::User(msg) => &msg.created_at,
-            Message::Warning(_, ts) => ts,
-            Message::System(ts) => ts,
-        }
-    }
 }
 
 impl Ord for Message {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         match (self, other) {
-            // System always comes first
-            (Message::System(_), Message::System(_)) => self.timestamp().cmp(other.timestamp()),
-            (Message::System(_), _) => std::cmp::Ordering::Less,
-            (_, Message::System(_)) => std::cmp::Ordering::Greater,
-
-            // For non-system messages, compare by timestamp
-            _ => self.timestamp().cmp(other.timestamp()),
+            (Message::User(a), Message::User(b)) => a.cmp(b),
+            (Message::System(a), Message::System(b)) => a.cmp(b),
+            (Message::User(a), Message::System(b)) => a.created_at.cmp(b),
+            (Message::System(a), Message::User(b)) => a.cmp(&b.created_at),
         }
     }
 }
@@ -157,14 +141,18 @@ fn extract_reply_ids(inner: &Tags) -> Vec<EventId> {
     let mut replies_to = vec![];
 
     for tag in inner.filter(TagKind::e()) {
-        if let Some(id) = tag.content().and_then(|id| EventId::parse(id).ok()) {
-            replies_to.push(id);
+        if let Some(content) = tag.content() {
+            if let Ok(id) = EventId::from_hex(content) {
+                replies_to.push(id);
+            }
         }
     }
 
     for tag in inner.filter(TagKind::q()) {
-        if let Some(id) = tag.content().and_then(|id| EventId::parse(id).ok()) {
-            replies_to.push(id);
+        if let Some(content) = tag.content() {
+            if let Ok(id) = EventId::from_hex(content) {
+                replies_to.push(id);
+            }
         }
     }
 

crates/registry/src/room.rs

@@ -4,11 +4,11 @@ use std::hash::{Hash, Hasher};
 use std::time::Duration;
 
 use anyhow::Error;
-use common::display::RenderedProfile;
+use common::display::ReadableProfile;
 use common::event::EventUtils;
 use global::constants::SEND_RETRY;
-use global::{app_state, nostr_client};
-use gpui::{App, AppContext, Context, EventEmitter, SharedString, SharedUri, Task};
+use global::{css, nostr_client};
+use gpui::{App, AppContext, Context, EventEmitter, SharedString, Task};
 use itertools::Itertools;
 use nostr_sdk::prelude::*;
 
@@ -124,118 +124,83 @@ impl Eq for Room {}
 
 impl EventEmitter<RoomSignal> for Room {}
 
-impl From<&Event> for Room {
-    fn from(val: &Event) -> Self {
-        let id = val.uniq_id();
-        let created_at = val.created_at;
-
-        // Get the members from the event's tags and event's pubkey
-        let members = val
-            .all_pubkeys()
-            .into_iter()
-            .unique()
-            .sorted()
-            .collect_vec();
-
-        // Get the subject from the event's tags
-        let subject = if let Some(tag) = val.tags.find(TagKind::Subject) {
-            tag.content().map(|s| s.to_owned())
-        } else {
-            None
-        };
-
-        // Get the picture from the event's tags
-        let picture = if let Some(tag) = val.tags.find(TagKind::custom("picture")) {
-            tag.content().map(|s| s.to_owned())
-        } else {
-            None
-        };
-
-        Room {
-            id,
-            created_at,
-            subject,
-            picture,
-            members,
-            kind: RoomKind::default(),
-        }
-    }
-}
-
-impl From<&UnsignedEvent> for Room {
-    fn from(val: &UnsignedEvent) -> Self {
-        let id = val.uniq_id();
-        let created_at = val.created_at;
-
-        // Get the members from the event's tags and event's pubkey
-        let members = val
-            .all_pubkeys()
-            .into_iter()
-            .unique()
-            .sorted()
-            .collect_vec();
-
-        // Get the subject from the event's tags
-        let subject = if let Some(tag) = val.tags.find(TagKind::Subject) {
-            tag.content().map(|s| s.to_owned())
-        } else {
-            None
-        };
-
-        // Get the picture from the event's tags
-        let picture = if let Some(tag) = val.tags.find(TagKind::custom("picture")) {
-            tag.content().map(|s| s.to_owned())
-        } else {
-            None
-        };
-
-        Room {
-            id,
-            created_at,
-            subject,
-            picture,
-            members,
-            kind: RoomKind::default(),
-        }
-    }
-}
-
 impl Room {
-    /// Constructs a new room instance with a given receiver.
-    pub fn new(receiver: PublicKey, tags: Tags, cx: &App) -> Self {
-        let identity = Registry::read_global(cx).identity(cx);
+    pub fn new(event: &Event) -> Self {
+        let id = event.uniq_id();
+        let created_at = event.created_at;
 
-        let mut event = EventBuilder::private_msg_rumor(receiver, "")
-            .tags(tags)
-            .build(identity.public_key());
+        // Get the members from the event's tags and event's pubkey
+        let members = event
+            .all_pubkeys()
+            .into_iter()
+            .unique()
+            .sorted()
+            .collect_vec();
 
-        // Ensure event ID is generated
-        event.ensure_id();
+        // Get the subject from the event's tags
+        let subject = if let Some(tag) = event.tags.find(TagKind::Subject) {
+            tag.content().map(|s| s.to_owned())
+        } else {
+            None
+        };
 
-        Room::from(&event).current_user(identity.public_key())
-    }
+        // Get the picture from the event's tags
+        let picture = if let Some(tag) = event.tags.find(TagKind::custom("picture")) {
+            tag.content().map(|s| s.to_owned())
+        } else {
+            None
+        };
 
-    /// Constructs a new room instance from an nostr event.
-    pub fn from(event: impl Into<Room>) -> Self {
-        event.into()
-    }
-
-    /// Call this function to ensure the current user is always at the bottom of the members list
-    pub fn current_user(mut self, public_key: PublicKey) -> Self {
-        let (not_match, matches): (Vec<PublicKey>, Vec<PublicKey>) =
-            self.members.iter().partition(|&key| key != &public_key);
-        self.members = not_match;
-        self.members.extend(matches);
-        self
+        Self {
+            id,
+            created_at,
+            subject,
+            picture,
+            members,
+            kind: RoomKind::default(),
+        }
     }
 
     /// Sets the kind of the room and returns the modified room
+    ///
+    /// This is a builder-style method that allows chaining room modifications.
+    ///
+    /// # Arguments
+    ///
+    /// * `kind` - The RoomKind to set for this room
+    ///
+    /// # Returns
+    ///
+    /// The modified Room instance with the new kind
     pub fn kind(mut self, kind: RoomKind) -> Self {
         self.kind = kind;
         self
     }
 
+    /// Sets the rearrange_by field of the room and returns the modified room
+    ///
+    /// This is a builder-style method that allows chaining room modifications.
+    ///
+    /// # Arguments
+    ///
+    /// * `rearrange_by` - The PublicKey to set for rearranging the member list
+    ///
+    /// # Returns
+    ///
+    /// The modified Room instance with the new member list after rearrangement
+    pub fn rearrange_by(mut self, rearrange_by: PublicKey) -> Self {
+        let (not_match, matches): (Vec<PublicKey>, Vec<PublicKey>) =
+            self.members.iter().partition(|&key| key != &rearrange_by);
+        self.members = not_match;
+        self.members.extend(matches);
+        self
+    }
+
     /// Set the room kind to ongoing
+    ///
+    /// # Arguments
+    ///
+    /// * `cx` - The context to notify about the update
     pub fn set_ongoing(&mut self, cx: &mut Context<Self>) {
         if self.kind != RoomKind::Ongoing {
             self.kind = RoomKind::Ongoing;
@@ -244,45 +209,89 @@ impl Room {
     }
 
     /// Checks if the room is a group chat
+    ///
+    /// # Returns
+    ///
+    /// true if the room has more than 2 members, false otherwise
     pub fn is_group(&self) -> bool {
         self.members.len() > 2
     }
 
     /// Updates the creation timestamp of the room
+    ///
+    /// # Arguments
+    ///
+    /// * `created_at` - The new Timestamp to set
+    /// * `cx` - The context to notify about the update
     pub fn created_at(&mut self, created_at: impl Into<Timestamp>, cx: &mut Context<Self>) {
         self.created_at = created_at.into();
         cx.notify();
     }
 
     /// Updates the subject of the room
+    ///
+    /// # Arguments
+    ///
+    /// * `subject` - The new subject to set
+    /// * `cx` - The context to notify about the update
     pub fn subject(&mut self, subject: String, cx: &mut Context<Self>) {
         self.subject = Some(subject);
         cx.notify();
     }
 
     /// Updates the picture of the room
+    ///
+    /// # Arguments
+    ///
+    /// * `picture` - The new subject to set
+    /// * `cx` - The context to notify about the update
     pub fn picture(&mut self, picture: String, cx: &mut Context<Self>) {
         self.picture = Some(picture);
         cx.notify();
     }
 
     /// Gets the display name for the room
-    pub fn display_name(&self, cx: &App) -> SharedString {
+    ///
+    /// If the room has a subject set, that will be used as the display name.
+    /// Otherwise, it will generate a name based on the room members.
+    ///
+    /// # Arguments
+    ///
+    /// * `cx` - The application context
+    ///
+    /// # Returns
+    ///
+    /// A string containing the display name
+    pub fn display_name(&self, cx: &App) -> String {
         if let Some(subject) = self.subject.clone() {
-            SharedString::from(subject)
+            subject
         } else {
-            self.merged_name(cx)
+            self.merge_name(cx)
         }
     }
 
     /// Gets the display image for the room
-    pub fn display_image(&self, proxy: bool, cx: &App) -> SharedUri {
+    ///
+    /// The image is determined by:
+    /// - The room's picture if set
+    /// - The first member's avatar for 1:1 chats
+    /// - A default group image for group chats
+    ///
+    /// # Arguments
+    ///
+    /// * `proxy` - Whether to use the proxy for the avatar URL
+    /// * `cx` - The application context
+    ///
+    /// # Returns
+    ///
+    /// A string containing the image path or URL
+    pub fn display_image(&self, proxy: bool, cx: &App) -> String {
         if let Some(picture) = self.picture.as_ref() {
-            SharedUri::from(picture)
+            picture.clone()
         } else if !self.is_group() {
-            self.first_member(cx).avatar(proxy)
+            self.first_member(cx).avatar_url(proxy)
         } else {
-            SharedUri::from("brand/group.png")
+            "brand/group.png".into()
         }
     }
 
@@ -295,7 +304,7 @@ impl Room {
     }
 
     /// Merge the names of the first two members of the room.
-    pub(crate) fn merged_name(&self, cx: &App) -> SharedString {
+    pub(crate) fn merge_name(&self, cx: &App) -> String {
         let registry = Registry::read_global(cx);
 
         if self.is_group() {
@@ -308,7 +317,7 @@ impl Room {
             let mut name = profiles
                 .iter()
                 .take(2)
-                .map(|p| p.name())
+                .map(|p| p.display_name())
                 .collect::<Vec<_>>()
                 .join(", ");
 
@@ -316,105 +325,56 @@ impl Room {
                 name = format!("{}, +{}", name, profiles.len() - 2);
             }
 
-            SharedString::from(name)
+            name
         } else {
             self.first_member(cx).display_name()
         }
     }
 
-    /// Connects to all members' messaging relays
-    pub fn connect_relays(
-        &self,
-        cx: &App,
-    ) -> Task<Result<HashMap<PublicKey, Vec<RelayUrl>>, Error>> {
-        let members = self.members.clone();
-
-        cx.background_spawn(async move {
-            let client = nostr_client();
-            let timeout = Duration::from_secs(3);
-            let mut processed = HashSet::new();
-            let mut relays: HashMap<PublicKey, Vec<RelayUrl>> = HashMap::new();
-
-            if let Some((_, members)) = members.split_last() {
-                for member in members.iter() {
-                    relays.insert(member.to_owned(), vec![]);
-
-                    let filter = Filter::new()
-                        .kind(Kind::InboxRelays)
-                        .author(member.to_owned())
-                        .limit(1);
-
-                    if let Ok(mut stream) = client.stream_events(filter, timeout).await {
-                        if let Some(event) = stream.next().await {
-                            if processed.insert(event.id) {
-                                let urls = nip17::extract_owned_relay_list(event).collect_vec();
-                                relays.entry(member.to_owned()).or_default().extend(urls);
-                            }
-                        }
-                    }
-                }
-            };
-
-            Ok(relays)
-        })
-    }
-
     /// Loads all messages for this room from the database
+    ///
+    /// # Arguments
+    ///
+    /// * `cx` - The App context
+    ///
+    /// # Returns
+    ///
+    /// A Task that resolves to Result<Vec<Event>, Error> containing all messages for this room
     pub fn load_messages(&self, cx: &App) -> Task<Result<Vec<Event>, Error>> {
         let members = self.members.clone();
 
         cx.background_spawn(async move {
             let client = nostr_client();
-            let signer = client.signer().await?;
-            let public_key = signer.get_public_key().await?;
-            let sent_ids = app_state()
-                .sent_ids
-                .read()
-                .await
-                .iter()
-                .copied()
-                .collect_vec();
+            let public_key = members[members.len() - 1];
 
-            // Get seen events from database
-            let filter = Filter::new()
-                .kind(Kind::ApplicationSpecificData)
-                .identifiers(sent_ids);
-
-            let seen_events = client.database().query(filter).await?;
-
-            // Extract seen event IDs
-            let seen_ids: Vec<EventId> = seen_events
-                .into_iter()
-                .filter_map(|event| event.tags.event_ids().next().copied())
-                .collect();
-
-            // Get events that sent by current user
-            let filter = Filter::new()
+            let sent = Filter::new()
                 .kind(Kind::PrivateDirectMessage)
                 .author(public_key)
                 .pubkeys(members.clone());
 
-            let sent_events = client.database().query(filter).await?;
-
-            // Get events that received by current user
-            let filter = Filter::new()
+            let recv = Filter::new()
                 .kind(Kind::PrivateDirectMessage)
                 .authors(members)
                 .pubkey(public_key);
 
-            let recv_events = client.database().query(filter).await?;
-
-            // Merge events
-            let events: Vec<Event> = sent_events
-                .merge(recv_events)
-                .into_iter()
-                .filter(|event| !seen_ids.contains(&event.id))
-                .collect();
+            let sent_events = client.database().query(sent).await?;
+            let recv_events = client.database().query(recv).await?;
+            let events: Vec<Event> = sent_events.merge(recv_events).into_iter().collect();
 
             Ok(events)
         })
     }
 
+    /// Emits a new message signal to the current room
+    pub fn emit_message(&self, gift_wrap_id: EventId, event: Event, cx: &mut Context<Self>) {
+        cx.emit(RoomSignal::NewMessage((gift_wrap_id, Box::new(event))));
+    }
+
+    /// Emits a signal to refresh the current room's messages.
+    pub fn emit_refresh(&mut self, cx: &mut Context<Self>) {
+        cx.emit(RoomSignal::Refresh);
+    }
+
     /// Creates a temporary message for optimistic updates
     ///
     /// The event must not been published to relays.
@@ -441,7 +401,6 @@ impl Room {
         }
 
         let mut event = builder.tags(tags).build(receiver);
-
         // Ensure event ID is set
         event.ensure_id();
 
@@ -462,7 +421,7 @@ impl Room {
         let mut public_keys = self.members.clone();
 
         cx.background_spawn(async move {
-            let app_state = app_state();
+            let css = css();
             let client = nostr_client();
             let signer = client.signer().await?;
             let public_key = signer.get_public_key().await?;
@@ -522,10 +481,15 @@ impl Room {
                         if auth_required {
                             // Wait for authenticated and resent event successfully
                             for attempt in 0..=SEND_RETRY {
-                                let ids = app_state.resent_ids.read().await;
-
                                 // Check if event was successfully resent
-                                if let Some(output) = ids.iter().find(|e| e.id() == &id).cloned() {
+                                if let Some(output) = css
+                                    .resent_ids
+                                    .read()
+                                    .await
+                                    .iter()
+                                    .find(|e| e.id() == &id)
+                                    .cloned()
+                                {
                                     let output = SendReport::new(pubkey).status(output).tags(&tags);
                                     reports.push(output);
                                     break;
@@ -629,14 +593,4 @@ impl Room {
             Ok(resend_reports)
         })
     }
-
-    /// Emits a new message signal to the current room
-    pub fn emit_message(&self, gift_wrap_id: EventId, event: Event, cx: &mut Context<Self>) {
-        cx.emit(RoomSignal::NewMessage((gift_wrap_id, Box::new(event))));
-    }
-
-    /// Emits a signal to refresh the current room's messages.
-    pub fn emit_refresh(&mut self, cx: &mut Context<Self>) {
-        cx.emit(RoomSignal::Refresh);
-    }
 }

crates/title_bar/src/platforms/mac.rs

@@ -3,4 +3,4 @@
 ///
 /// Magic number: There is one extra pixel of padding on the left side due to
 /// the 1px border around the window on macOS apps.
-pub const TRAFFIC_LIGHT_PADDING: f32 = 80.;
+pub const TRAFFIC_LIGHT_PADDING: f32 = 71.;

crates/ui/Cargo.toml

@@ -28,6 +28,3 @@ uuid = "1.10"
 once_cell = "1.19.0"
 image = "0.25.1"
 linkify = "0.10.0"
-lsp-types = "0.97.0"
-rope = { git = "https://github.com/zed-industries/zed.git" }
-sum_tree = { git = "https://github.com/zed-industries/zed.git" }

crates/ui/src/actions.rs

@@ -2,15 +2,10 @@ use gpui::{actions, Action};
 use nostr_sdk::prelude::PublicKey;
 use serde::Deserialize;
 
-/// Define a open public key action
+/// Define a open profile action
 #[derive(Action, Clone, PartialEq, Eq, Deserialize, Debug)]
-#[action(namespace = pubkey, no_json)]
-pub struct OpenPublicKey(pub PublicKey);
-
-/// Define a copy inline public key action
-#[derive(Action, Clone, PartialEq, Eq, Deserialize, Debug)]
-#[action(namespace = pubkey, no_json)]
-pub struct CopyPublicKey(pub PublicKey);
+#[action(namespace = profile, no_json)]
+pub struct OpenProfile(pub PublicKey);
 
 /// Define a custom confirm action
 #[derive(Clone, Action, PartialEq, Eq, Deserialize)]

crates/ui/src/button.rs

@@ -10,6 +10,11 @@ use crate::indicator::Indicator;
 use crate::tooltip::Tooltip;
 use crate::{h_flex, Disableable, Icon, Selectable, Sizable, Size, StyledExt};
 
+pub enum ButtonRounded {
+    Normal,
+    Full,
+}
+
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct ButtonCustomVariant {
     color: Hsla,
@@ -125,7 +130,7 @@ pub struct Button {
     children: Vec<AnyElement>,
 
     variant: ButtonVariant,
-    rounded: bool,
+    rounded: ButtonRounded,
     size: Size,
 
     disabled: bool,
@@ -158,7 +163,7 @@ impl Button {
             disabled: false,
             selected: false,
             variant: ButtonVariant::default(),
-            rounded: false,
+            rounded: ButtonRounded::Normal,
             size: Size::Medium,
             tooltip: None,
             on_click: None,
@@ -172,9 +177,9 @@ impl Button {
         }
     }
 
-    /// Make the button rounded.
-    pub fn rounded(mut self) -> Self {
-        self.rounded = true;
+    /// Set the border radius of the Button.
+    pub fn rounded(mut self, rounded: impl Into<ButtonRounded>) -> Self {
+        self.rounded = rounded.into();
         self
     }
 
@@ -310,8 +315,8 @@ impl RenderOnce for Button {
             .cursor_default()
             .overflow_hidden()
             .map(|this| match self.rounded {
-                false => this.rounded(cx.theme().radius),
-                true => this.rounded_full(),
+                ButtonRounded::Normal => this.rounded(cx.theme().radius),
+                ButtonRounded::Full => this.rounded_full(),
             })
             .map(|this| {
                 if self.label.is_none() && self.children.is_empty() {

crates/ui/src/dock_area/tab_panel.rs

@@ -412,15 +412,16 @@ impl TabPanel {
         let is_zoomed = self.is_zoomed && state.zoomable;
         let view = cx.entity().clone();
         let build_popup_menu = move |this, cx: &App| view.read(cx).popup_menu(this, cx);
-        let toolbar = self.toolbar_buttons(window, cx);
-        let has_toolbar = !toolbar.is_empty();
 
         h_flex()
-            .p_0p5()
             .gap_1()
             .occlude()
-            .rounded_full()
-            .children(toolbar.into_iter().map(|btn| btn.small().ghost().rounded()))
+            .items_center()
+            .children(
+                self.toolbar_buttons(window, cx)
+                    .into_iter()
+                    .map(|btn| btn.small().ghost()),
+            )
             .when(self.is_zoomed, |this| {
                 this.child(
                     Button::new("zoom")
@@ -433,16 +434,11 @@ impl TabPanel {
                         })),
                 )
             })
-            .when(has_toolbar, |this| {
-                this.bg(cx.theme().surface_background)
-                    .child(div().flex_shrink_0().h_4().w_px().bg(cx.theme().border))
-            })
             .child(
                 Button::new("menu")
                     .icon(IconName::Ellipsis)
                     .small()
                     .ghost()
-                    .rounded()
                     .popup_menu({
                         let zoomable = state.zoomable;
                         let closable = state.closable;
@@ -651,7 +647,7 @@ impl TabPanel {
             .child(
                 div()
                     .size_full()
-                    .rounded_xl()
+                    .rounded_lg()
                     .shadow_sm()
                     .when(cx.theme().mode.is_dark(), |this| this.shadow_lg())
                     .bg(cx.theme().panel_background)
@@ -671,7 +667,7 @@ impl TabPanel {
                             .p_1()
                             .child(
                                 div()
-                                    .rounded_xl()
+                                    .rounded_lg()
                                     .border_1()
                                     .border_color(cx.theme().element_disabled)
                                     .bg(cx.theme().drop_target_background)

crates/ui/src/history.rs

@@ -22,10 +22,10 @@ pub struct History<I: HistoryItem> {
     redos: Vec<I>,
     last_changed_at: Instant,
     version: usize,
+    pub(crate) ignore: bool,
     max_undo: usize,
     group_interval: Option<Duration>,
     unique: bool,
-    pub ignore: bool,
 }
 
 impl<I> History<I>

crates/ui/src/icon.rs

@@ -45,7 +45,6 @@ pub enum IconName {
     Plus,
     PlusFill,
     PlusCircleFill,
-    Group,
     ResizeCorner,
     Reply,
     Report,
@@ -53,7 +52,6 @@ pub enum IconName {
     Signal,
     Search,
     Settings,
-    Server,
     SortAscending,
     SortDescending,
     Sun,
@@ -107,7 +105,6 @@ impl IconName {
             Self::Plus => "icons/plus.svg",
             Self::PlusFill => "icons/plus-fill.svg",
             Self::PlusCircleFill => "icons/plus-circle-fill.svg",
-            Self::Group => "icons/group.svg",
             Self::ResizeCorner => "icons/resize-corner.svg",
             Self::Reply => "icons/reply.svg",
             Self::Report => "icons/report.svg",
@@ -115,7 +112,6 @@ impl IconName {
             Self::Signal => "icons/signal.svg",
             Self::Search => "icons/search.svg",
             Self::Settings => "icons/settings.svg",
-            Self::Server => "icons/server.svg",
             Self::SortAscending => "icons/sort-ascending.svg",
             Self::SortDescending => "icons/sort-descending.svg",
             Self::Sun => "icons/sun.svg",

crates/ui/src/input/blink_cursor.rs

@@ -1,10 +1,9 @@
 use std::time::Duration;
 
-use gpui::{px, Context, Pixels, Timer};
+use gpui::{Context, Timer};
 
 static INTERVAL: Duration = Duration::from_millis(500);
 static PAUSE_DELAY: Duration = Duration::from_millis(300);
-pub(super) const CURSOR_WIDTH: Pixels = px(1.5);
 
 /// To manage the Input cursor blinking.
 ///
@@ -12,7 +11,7 @@ pub(super) const CURSOR_WIDTH: Pixels = px(1.5);
 /// Every loop will notify the view to update the `visible`, and Input will observe this update to touch repaint.
 ///
 /// The input painter will check if this in visible state, then it will draw the cursor.
-pub struct BlinkCursor {
+pub(crate) struct BlinkCursor {
     visible: bool,
     paused: bool,
     epoch: usize,
@@ -53,8 +52,10 @@ impl BlinkCursor {
 
         // Schedule the next blink
         let epoch = self.next_epoch();
+
         cx.spawn(async move |this, cx| {
             Timer::after(INTERVAL).await;
+
             if let Some(this) = this.upgrade() {
                 this.update(cx, |this, cx| this.blink(epoch, cx)).ok();
             }
@@ -70,11 +71,11 @@ impl BlinkCursor {
     /// Pause the blinking, and delay 500ms to resume the blinking.
     pub fn pause(&mut self, cx: &mut Context<Self>) {
         self.paused = true;
-        self.visible = true;
         cx.notify();
 
         // delay 500ms to start the blinking
         let epoch = self.next_epoch();
+
         cx.spawn(async move |this, cx| {
             Timer::after(PAUSE_DELAY).await;
 
@@ -89,9 +90,3 @@ impl BlinkCursor {
         .detach();
     }
 }
-
-impl Default for BlinkCursor {
-    fn default() -> Self {
-        Self::new()
-    }
-}

crates/ui/src/input/change.rs

@@ -1,28 +1,28 @@
 use std::fmt::Debug;
+use std::ops::Range;
 
 use crate::history::HistoryItem;
-use crate::input::cursor::Selection;
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct Change {
-    pub(crate) old_range: Selection,
+    pub(crate) old_range: Range<usize>,
     pub(crate) old_text: String,
-    pub(crate) new_range: Selection,
+    pub(crate) new_range: Range<usize>,
     pub(crate) new_text: String,
     version: usize,
 }
 
 impl Change {
     pub fn new(
-        old_range: impl Into<Selection>,
+        old_range: Range<usize>,
         old_text: &str,
-        new_range: impl Into<Selection>,
+        new_range: Range<usize>,
         new_text: &str,
     ) -> Self {
         Self {
-            old_range: old_range.into(),
+            old_range,
             old_text: old_text.to_string(),
-            new_range: new_range.into(),
+            new_range,
             new_text: new_text.to_string(),
             version: 0,
         }

crates/ui/src/input/clear_button.rs

@@ -1,15 +1,16 @@
 use gpui::{App, Styled};
+use i18n::t;
 use theme::ActiveTheme;
 
-use crate::button::{Button, ButtonVariants};
-use crate::{Icon, IconName, Sizable};
+use crate::button::{Button, ButtonVariants as _};
+use crate::{Icon, IconName, Sizable as _};
 
 #[inline]
 pub(crate) fn clear_button(cx: &App) -> Button {
     Button::new("clean")
         .icon(Icon::new(IconName::CloseCircle))
-        .tooltip("Clear")
+        .tooltip(t!("common.clear"))
         .small()
-        .transparent()
         .text_color(cx.theme().text_muted)
+        .transparent()
 }

crates/ui/src/input/cursor.rs

@@ -1,46 +0,0 @@
-use std::ops::Range;
-
-/// A selection in the text, represented by start and end byte indices.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
-pub struct Selection {
-    pub start: usize,
-    pub end: usize,
-}
-
-impl Selection {
-    pub fn new(start: usize, end: usize) -> Self {
-        Self { start, end }
-    }
-
-    pub fn len(&self) -> usize {
-        self.end.saturating_sub(self.start)
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.start == self.end
-    }
-
-    /// Clears the selection, setting start and end to 0.
-    pub fn clear(&mut self) {
-        self.start = 0;
-        self.end = 0;
-    }
-
-    /// Checks if the given offset is within the selection range.
-    pub fn contains(&self, offset: usize) -> bool {
-        offset >= self.start && offset < self.end
-    }
-}
-
-impl From<Range<usize>> for Selection {
-    fn from(value: Range<usize>) -> Self {
-        Self::new(value.start, value.end)
-    }
-}
-impl From<Selection> for Range<usize> {
-    fn from(value: Selection) -> Self {
-        value.start..value.end
-    }
-}
-
-pub type Position = lsp_types::Position;

crates/ui/src/input/element.rs

@@ -1,34 +1,29 @@
-use std::ops::Range;
-use std::rc::Rc;
+use std::{ops::Range, rc::Rc};
 
 use gpui::{
     fill, point, px, relative, size, App, Bounds, Corners, Element, ElementId, ElementInputHandler,
-    Entity, GlobalElementId, Half, Hitbox, IntoElement, LayoutId, MouseButton, MouseMoveEvent,
-    Path, Pixels, Point, ShapedLine, SharedString, Size, Style, TextAlign, TextRun, UnderlineStyle,
-    Window,
+    Entity, GlobalElementId, IntoElement, LayoutId, MouseButton, MouseMoveEvent, Path, Pixels,
+    Point, SharedString, Size, Style, TextAlign, TextRun, UnderlineStyle, Window, WrappedLine,
 };
-use rope::Rope;
 use smallvec::SmallVec;
 use theme::ActiveTheme;
 
-use super::blink_cursor::CURSOR_WIDTH;
-use super::rope_ext::RopeExt;
-use super::state::{InputState, LastLayout};
+use super::{InputState, LastLayout};
 use crate::Root;
 
-const BOTTOM_MARGIN_ROWS: usize = 3;
-pub(super) const RIGHT_MARGIN: Pixels = px(10.);
-pub(super) const LINE_NUMBER_RIGHT_MARGIN: Pixels = px(10.);
+const CURSOR_THICKNESS: Pixels = px(2.);
+const RIGHT_MARGIN: Pixels = px(5.);
+const BOTTOM_MARGIN_ROWS: usize = 1;
 
 pub(super) struct TextElement {
-    pub(crate) state: Entity<InputState>,
+    input: Entity<InputState>,
     placeholder: SharedString,
 }
 
 impl TextElement {
-    pub(super) fn new(state: Entity<InputState>) -> Self {
+    pub(super) fn new(input: Entity<InputState>) -> Self {
         Self {
-            state,
+            input,
             placeholder: SharedString::default(),
         }
     }
@@ -41,12 +36,12 @@ impl TextElement {
 
     fn paint_mouse_listeners(&mut self, window: &mut Window, _: &mut App) {
         window.on_mouse_event({
-            let state = self.state.clone();
+            let input = self.input.clone();
 
             move |event: &MouseMoveEvent, _, window, cx| {
                 if event.pressed_button == Some(MouseButton::Left) {
-                    state.update(cx, |state, cx| {
-                        state.on_drag_move(event, window, cx);
+                    input.update(cx, |input, cx| {
+                        input.on_drag_move(event, window, cx);
                     });
                 }
             }
@@ -57,44 +52,33 @@ impl TextElement {
     ///
     /// - cursor bounds
     /// - scroll offset
-    /// - current row index (No only the visible lines, but all lines)
-    ///
-    /// This method also will update for track scroll to cursor.
+    /// - current line index
     fn layout_cursor(
         &self,
-        last_layout: &LastLayout,
+        lines: &[WrappedLine],
+        line_height: Pixels,
         bounds: &mut Bounds<Pixels>,
-        _: &mut Window,
+        line_number_width: Pixels,
+        window: &mut Window,
         cx: &mut App,
     ) -> (Option<Bounds<Pixels>>, Point<Pixels>, Option<usize>) {
-        let state = self.state.read(cx);
-
-        let line_height = last_layout.line_height;
-        let visible_range = &last_layout.visible_range;
-        let lines = &last_layout.lines;
-        let text_wrapper = &state.text_wrapper;
-        let line_number_width = last_layout.line_number_width;
-
-        let mut selected_range = state.selected_range;
-        if let Some(ime_marked_range) = &state.ime_marked_range {
-            selected_range = (ime_marked_range.end..ime_marked_range.end).into();
+        let input = self.input.read(cx);
+        let mut selected_range = input.selected_range.clone();
+        if let Some(marked_range) = &input.marked_range {
+            selected_range = marked_range.end..marked_range.end;
         }
 
-        let cursor = state.cursor();
-        let mut current_row = None;
-        let mut scroll_offset = state.scroll_handle.offset();
+        let cursor_offset = input.cursor_offset();
+        let mut current_line_index = None;
+        let mut scroll_offset = input.scroll_handle.offset();
         let mut cursor_bounds = None;
 
         // If the input has a fixed height (Otherwise is auto-grow), we need to add a bottom margin to the input.
-        let top_bottom_margin = if state.mode.is_auto_grow() {
-            #[allow(clippy::if_same_then_else)]
-            line_height
-        } else if visible_range.len() < BOTTOM_MARGIN_ROWS * 8 {
-            line_height
+        let bottom_margin = if input.is_auto_grow() {
+            px(0.) + line_height
         } else {
-            BOTTOM_MARGIN_ROWS * line_height
+            BOTTOM_MARGIN_ROWS * line_height + line_height
         };
-
         // The cursor corresponds to the current cursor position in the text no only the line.
         let mut cursor_pos = None;
         let mut cursor_start = None;
@@ -102,98 +86,68 @@ impl TextElement {
 
         let mut prev_lines_offset = 0;
         let mut offset_y = px(0.);
-
-        for (ix, wrap_line) in text_wrapper.lines.iter().enumerate() {
-            let row = ix;
-            let line_origin = point(px(0.), offset_y);
-
+        for (line_ix, line) in lines.iter().enumerate() {
             // break loop if all cursor positions are found
             if cursor_pos.is_some() && cursor_start.is_some() && cursor_end.is_some() {
                 break;
             }
 
-            let in_visible_range = ix >= visible_range.start;
-            if let Some(line) = in_visible_range
-                .then(|| lines.get(ix.saturating_sub(visible_range.start)))
-                .flatten()
-            {
-                // If in visible range lines
-                if cursor_pos.is_none() {
-                    let offset = cursor.saturating_sub(prev_lines_offset);
-                    if let Some(pos) = line.position_for_index(offset, line_height) {
-                        current_row = Some(row);
-                        cursor_pos = Some(line_origin + pos);
-                    }
+            let line_origin = point(px(0.), offset_y);
+            if cursor_pos.is_none() {
+                let offset = cursor_offset.saturating_sub(prev_lines_offset);
+                if let Some(pos) = line.position_for_index(offset, line_height) {
+                    current_line_index = Some(line_ix);
+                    cursor_pos = Some(line_origin + pos);
                 }
-                if cursor_start.is_none() {
-                    let offset = selected_range.start.saturating_sub(prev_lines_offset);
-                    if let Some(pos) = line.position_for_index(offset, line_height) {
-                        cursor_start = Some(line_origin + pos);
-                    }
-                }
-                if cursor_end.is_none() {
-                    let offset = selected_range.end.saturating_sub(prev_lines_offset);
-                    if let Some(pos) = line.position_for_index(offset, line_height) {
-                        cursor_end = Some(line_origin + pos);
-                    }
-                }
-
-                offset_y += line.size(line_height).height;
-                // +1 for the last `\n`
-                prev_lines_offset += line.len() + 1;
-            } else {
-                // If not in the visible range.
-
-                // Just increase the offset_y and prev_lines_offset.
-                // This will let the scroll_offset to track the cursor position correctly.
-                if prev_lines_offset >= cursor && cursor_pos.is_none() {
-                    current_row = Some(row);
-                    cursor_pos = Some(line_origin);
-                }
-                if prev_lines_offset >= selected_range.start && cursor_start.is_none() {
-                    cursor_start = Some(line_origin);
-                }
-                if prev_lines_offset >= selected_range.end && cursor_end.is_none() {
-                    cursor_end = Some(line_origin);
-                }
-
-                offset_y += wrap_line.height(line_height);
-                // +1 for the last `\n`
-                prev_lines_offset += wrap_line.len() + 1;
             }
+            if cursor_start.is_none() {
+                let offset = selected_range.start.saturating_sub(prev_lines_offset);
+                if let Some(pos) = line.position_for_index(offset, line_height) {
+                    cursor_start = Some(line_origin + pos);
+                }
+            }
+            if cursor_end.is_none() {
+                let offset = selected_range.end.saturating_sub(prev_lines_offset);
+                if let Some(pos) = line.position_for_index(offset, line_height) {
+                    cursor_end = Some(line_origin + pos);
+                }
+            }
+
+            offset_y += line.size(line_height).height;
+            // +1 for skip the last `\n`
+            prev_lines_offset += line.len() + 1;
         }
 
         if let (Some(cursor_pos), Some(cursor_start), Some(cursor_end)) =
             (cursor_pos, cursor_start, cursor_end)
         {
-            let selection_changed = state.last_selected_range != Some(selected_range);
-            if selection_changed {
-                scroll_offset.x = if scroll_offset.x + cursor_pos.x
-                    > (bounds.size.width - line_number_width - RIGHT_MARGIN)
+            let cursor_moved = input.last_cursor_offset != Some(cursor_offset);
+            let selection_changed = input.last_selected_range != Some(selected_range.clone());
+
+            if cursor_moved || selection_changed {
+                scroll_offset.x =
+                    if scroll_offset.x + cursor_pos.x > (bounds.size.width - RIGHT_MARGIN) {
+                        // cursor is out of right
+                        bounds.size.width - RIGHT_MARGIN - cursor_pos.x
+                    } else if scroll_offset.x + cursor_pos.x < px(0.) {
+                        // cursor is out of left
+                        scroll_offset.x - cursor_pos.x
+                    } else {
+                        scroll_offset.x
+                    };
+                scroll_offset.y = if scroll_offset.y + cursor_pos.y + line_height
+                    > bounds.size.height - bottom_margin
                 {
-                    // cursor is out of right
-                    bounds.size.width - line_number_width - RIGHT_MARGIN - cursor_pos.x
-                } else if scroll_offset.x + cursor_pos.x < px(0.) {
-                    // cursor is out of left
-                    scroll_offset.x - cursor_pos.x
+                    // cursor is out of bottom
+                    bounds.size.height - bottom_margin - cursor_pos.y
+                } else if scroll_offset.y + cursor_pos.y < px(0.) {
+                    // cursor is out of top
+                    scroll_offset.y - cursor_pos.y
                 } else {
-                    scroll_offset.x
+                    scroll_offset.y
                 };
 
-                // If we change the scroll_offset.y, GPUI will render and trigger the next run loop.
-                // So, here we just adjust offset by `line_height` for move smooth.
-                scroll_offset.y =
-                    if scroll_offset.y + cursor_pos.y > bounds.size.height - top_bottom_margin {
-                        // cursor is out of bottom
-                        scroll_offset.y - line_height
-                    } else if scroll_offset.y + cursor_pos.y < top_bottom_margin {
-                        // cursor is out of top
-                        (scroll_offset.y + line_height).min(px(0.))
-                    } else {
-                        scroll_offset.y
-                    };
-
-                if state.selection_reversed {
+                if input.selection_reversed {
                     if scroll_offset.x + cursor_start.x < px(0.) {
                         // selection start is out of left
                         scroll_offset.x = -cursor_start.x;
@@ -214,55 +168,54 @@ impl TextElement {
                 }
             }
 
-            // cursor bounds
-            let cursor_height = line_height;
-            cursor_bounds = Some(Bounds::new(
-                point(
-                    bounds.left() + cursor_pos.x + line_number_width + scroll_offset.x,
-                    bounds.top() + cursor_pos.y + ((line_height - cursor_height) / 2.),
-                ),
-                size(CURSOR_WIDTH, cursor_height),
-            ));
-        }
-
-        if let Some(deferred_scroll_offset) = state.deferred_scroll_offset {
-            scroll_offset = deferred_scroll_offset;
+            if input.show_cursor(window, cx) {
+                // cursor blink
+                let cursor_height = line_height;
+                cursor_bounds = Some(Bounds::new(
+                    point(
+                        bounds.left() + cursor_pos.x + line_number_width + scroll_offset.x,
+                        bounds.top() + cursor_pos.y + ((line_height - cursor_height) / 2.),
+                    ),
+                    size(CURSOR_THICKNESS, cursor_height),
+                ));
+            };
         }
 
         bounds.origin += scroll_offset;
 
-        (cursor_bounds, scroll_offset, current_row)
+        (cursor_bounds, scroll_offset, current_line_index)
     }
 
-    /// Layout the match range to a Path.
-    pub(crate) fn layout_match_range(
-        range: Range<usize>,
-        last_layout: &LastLayout,
+    fn layout_selections(
+        &self,
+        lines: &[WrappedLine],
+        line_height: Pixels,
         bounds: &mut Bounds<Pixels>,
+        line_number_width: Pixels,
+        _: &mut Window,
+        cx: &mut App,
     ) -> Option<Path<Pixels>> {
-        if range.is_empty() {
+        let input = self.input.read(cx);
+        let mut selected_range = input.selected_range.clone();
+        if let Some(marked_range) = &input.marked_range {
+            if !marked_range.is_empty() {
+                selected_range = marked_range.end..marked_range.end;
+            }
+        }
+        if selected_range.is_empty() {
             return None;
         }
 
-        if range.start < last_layout.visible_range_offset.start
-            || range.end > last_layout.visible_range_offset.end
-        {
-            return None;
-        }
+        let (start_ix, end_ix) = if selected_range.start < selected_range.end {
+            (selected_range.start, selected_range.end)
+        } else {
+            (selected_range.end, selected_range.start)
+        };
 
-        let line_height = last_layout.line_height;
-        let visible_top = last_layout.visible_top;
-        let visible_start_offset = last_layout.visible_range_offset.start;
-        let lines = &last_layout.lines;
-        let line_number_width = last_layout.line_number_width;
-
-        let start_ix = range.start;
-        let end_ix = range.end;
-
-        let mut prev_lines_offset = visible_start_offset;
-        let mut offset_y = visible_top;
+        let mut prev_lines_offset = 0;
         let mut line_corners = vec![];
 
+        let mut offset_y = px(0.);
         for line in lines.iter() {
             let line_size = line.size(line_height);
             let line_wrap_width = line_size.width;
@@ -286,6 +239,7 @@ impl TextElement {
                     (end.y / line_height).ceil() as usize - (start.y / line_height).ceil() as usize;
 
                 let mut end_x = end.x;
+
                 if wrapped_lines > 0 {
                     end_x = line_wrap_width;
                 }
@@ -368,79 +322,39 @@ impl TextElement {
         builder.build().ok()
     }
 
-    fn layout_selections(
-        &self,
-        last_layout: &LastLayout,
-        bounds: &mut Bounds<Pixels>,
-        cx: &mut App,
-    ) -> Option<Path<Pixels>> {
-        let state = self.state.read(cx);
-        let mut selected_range = state.selected_range;
-        if let Some(ime_marked_range) = &state.ime_marked_range {
-            if !ime_marked_range.is_empty() {
-                selected_range = (ime_marked_range.end..ime_marked_range.end).into();
-            }
-        }
-        if selected_range.is_empty() {
-            return None;
-        }
-
-        let (start_ix, end_ix) = if selected_range.start < selected_range.end {
-            (selected_range.start, selected_range.end)
-        } else {
-            (selected_range.end, selected_range.start)
-        };
-
-        let range = start_ix.max(last_layout.visible_range_offset.start)
-            ..end_ix.min(last_layout.visible_range_offset.end);
-
-        Self::layout_match_range(range, last_layout, bounds)
-    }
-
     /// Calculate the visible range of lines in the viewport.
     ///
-    /// Returns
-    ///
-    /// - visible_range: The visible range is based on unwrapped lines (Zero based).
-    /// - visible_top: The top position of the first visible line in the scroll viewport.
+    /// The visible range is based on unwrapped lines (Zero based).
     fn calculate_visible_range(
         &self,
         state: &InputState,
         line_height: Pixels,
         input_height: Pixels,
-    ) -> (Range<usize>, Pixels) {
-        // Add extra rows to avoid showing empty space when scroll to bottom.
-        let extra_rows = 1;
-        let mut visible_top = px(0.);
-        if state.mode.is_single_line() {
-            return (0..1, visible_top);
+    ) -> Range<usize> {
+        if state.is_single_line() {
+            return 0..1;
         }
 
-        let total_lines = state.text_wrapper.len();
-        let scroll_top = if let Some(deferred_scroll_offset) = state.deferred_scroll_offset {
-            deferred_scroll_offset.y
-        } else {
-            state.scroll_handle.offset().y
-        };
+        let scroll_top = -state.scroll_handle.offset().y;
+        let total_lines = state.text_wrapper.lines.len();
 
         let mut visible_range = 0..total_lines;
-        let mut line_bottom = px(0.);
-        for (ix, line) in state.text_wrapper.lines.iter().enumerate() {
-            let wrapped_height = line.height(line_height);
-            line_bottom += wrapped_height;
+        let mut line_top = px(0.);
 
-            if line_bottom < -scroll_top {
-                visible_top = line_bottom - wrapped_height;
+        for (ix, line) in state.text_wrapper.lines.iter().enumerate() {
+            line_top += line.height(line_height);
+
+            if line_top < scroll_top {
                 visible_range.start = ix;
             }
 
-            if line_bottom + scroll_top >= input_height {
-                visible_range.end = (ix + extra_rows).min(total_lines);
+            if line_top > scroll_top + input_height {
+                visible_range.end = (ix + 1).min(total_lines);
                 break;
             }
         }
 
-        (visible_range, visible_top)
+        visible_range
     }
 }
 
@@ -448,17 +362,13 @@ pub(super) struct PrepaintState {
     /// The lines of entire lines.
     last_layout: LastLayout,
     /// The lines only contains the visible lines in the viewport, based on `visible_range`.
-    ///
-    /// The child is the soft lines.
-    line_numbers: Option<Vec<SmallVec<[ShapedLine; 1]>>>,
+    line_numbers: Option<Vec<SmallVec<[WrappedLine; 1]>>>,
+    line_number_width: Pixels,
     /// Size of the scrollable area by entire lines.
     scroll_size: Size<Pixels>,
     cursor_bounds: Option<Bounds<Pixels>>,
     cursor_scroll_offset: Point<Pixels>,
     selection_path: Option<Path<Pixels>>,
-    hover_highlight_path: Option<Path<Pixels>>,
-    search_match_paths: Vec<(Path<Pixels>, bool)>,
-    hover_definition_hitbox: Option<Hitbox>,
     bounds: Bounds<Pixels>,
 }
 
@@ -470,9 +380,34 @@ impl IntoElement for TextElement {
     }
 }
 
+/// A debug function to print points as SVG path.
+#[allow(unused)]
+fn print_points_as_svg_path(line_corners: &Vec<Corners<Point<Pixels>>>, points: &[Point<Pixels>]) {
+    for corners in line_corners {
+        println!(
+            "tl: ({}, {}), tr: ({}, {}), bl: ({}, {}), br: ({}, {})",
+            corners.top_left.x.0 as i32,
+            corners.top_left.y.0 as i32,
+            corners.top_right.x.0 as i32,
+            corners.top_right.y.0 as i32,
+            corners.bottom_left.x.0 as i32,
+            corners.bottom_left.y.0 as i32,
+            corners.bottom_right.x.0 as i32,
+            corners.bottom_right.y.0 as i32,
+        );
+    }
+
+    if !points.is_empty() {
+        println!("M{},{}", points[0].x.0 as i32, points[0].y.0 as i32);
+        for p in points.iter().skip(1) {
+            println!("L{},{}", p.x.0 as i32, p.y.0 as i32);
+        }
+    }
+}
+
 impl Element for TextElement {
-    type PrepaintState = PrepaintState;
     type RequestLayoutState = ();
+    type PrepaintState = PrepaintState;
 
     fn id(&self) -> Option<ElementId> {
         None
@@ -489,20 +424,19 @@ impl Element for TextElement {
         window: &mut Window,
         cx: &mut App,
     ) -> (LayoutId, Self::RequestLayoutState) {
-        let state = self.state.read(cx);
+        let input = self.input.read(cx);
         let line_height = window.line_height();
 
         let mut style = Style::default();
         style.size.width = relative(1.).into();
-        if state.mode.is_multi_line() {
+        if self.input.read(cx).is_multi_line() {
             style.flex_grow = 1.0;
-            style.size.height = relative(1.).into();
-            if state.mode.is_auto_grow() {
-                // Auto grow to let height match to rows, but not exceed max rows.
-                let rows = state.mode.max_rows().min(state.mode.rows());
-                style.min_size.height = (rows * line_height).into();
-            } else {
+            if let Some(h) = input.mode.height() {
+                style.size.height = h.into();
                 style.min_size.height = line_height.into();
+            } else {
+                style.size.height = relative(1.).into();
+                style.min_size.height = (input.mode.rows() * line_height).into();
             }
         } else {
             // For single-line inputs, the minimum height should be the line height
@@ -521,19 +455,11 @@ impl Element for TextElement {
         window: &mut Window,
         cx: &mut App,
     ) -> Self::PrepaintState {
-        let state = self.state.read(cx);
         let line_height = window.line_height();
-
-        let (visible_range, visible_top) =
-            self.calculate_visible_range(state, line_height, bounds.size.height);
-        let visible_start_offset = state.text.line_start_offset(visible_range.start);
-        let visible_end_offset = state
-            .text
-            .line_end_offset(visible_range.end.saturating_sub(1));
-
-        let state = self.state.read(cx);
-        let multi_line = state.mode.is_multi_line();
-        let text = state.text.clone();
+        let input = self.input.read(cx);
+        let multi_line = input.is_multi_line();
+        let visible_range = self.calculate_visible_range(input, line_height, bounds.size.height);
+        let text = input.text.clone();
         let is_empty = text.is_empty();
         let placeholder = self.placeholder.clone();
         let style = window.text_style();
@@ -541,9 +467,9 @@ impl Element for TextElement {
         let mut bounds = bounds;
 
         let (display_text, text_color) = if is_empty {
-            (Rope::from(placeholder.as_str()), cx.theme().text_muted)
-        } else if state.masked {
-            (Rope::from("*".repeat(text.chars_count())), cx.theme().text)
+            (placeholder, cx.theme().text_muted)
+        } else if input.masked {
+            ("*".repeat(text.chars().count()).into(), cx.theme().text)
         } else {
             (text.clone(), cx.theme().text)
         };
@@ -574,20 +500,20 @@ impl Element for TextElement {
 
         let runs = if !is_empty {
             vec![run]
-        } else if let Some(ime_marked_range) = &state.ime_marked_range {
+        } else if let Some(marked_range) = &input.marked_range {
             // IME marked text
             vec![
                 TextRun {
-                    len: ime_marked_range.start,
+                    len: marked_range.start,
                     ..run.clone()
                 },
                 TextRun {
-                    len: ime_marked_range.end - ime_marked_range.start,
+                    len: marked_range.end - marked_range.start,
                     underline: marked_run.underline,
                     ..run.clone()
                 },
                 TextRun {
-                    len: display_text.len() - ime_marked_range.end,
+                    len: display_text.len() - marked_range.end,
                     ..run.clone()
                 },
             ]
@@ -598,76 +524,35 @@ impl Element for TextElement {
             vec![run]
         };
 
-        let wrap_width = if multi_line && state.soft_wrap {
+        let wrap_width = if multi_line {
             Some(bounds.size.width - line_number_width - RIGHT_MARGIN)
         } else {
             None
         };
 
-        // NOTE: Here 50 lines about 150µs
-        // let measure = crate::Measure::new("shape_text");
-        let visible_text = display_text
-            .slice_rows(visible_range.start as u32..visible_range.end as u32)
-            .to_string();
-
         let lines = window
             .text_system()
-            .shape_text(visible_text.into(), font_size, &runs, wrap_width, None)
+            .shape_text(display_text, font_size, &runs, wrap_width, None)
             .expect("failed to shape text");
-        // measure.end();
 
-        let mut longest_line_width = wrap_width.unwrap_or(px(0.));
-        if state.mode.is_multi_line() && !state.soft_wrap && lines.len() > 1 {
-            let longtest_line: SharedString = state
-                .text
-                .line(state.text.summary().longest_row as usize)
-                .to_string()
-                .into();
-            longest_line_width = window
-                .text_system()
-                .shape_line(
-                    longtest_line.clone(),
-                    font_size,
-                    &[TextRun {
-                        len: longtest_line.len(),
-                        font: style.font(),
-                        color: gpui::black(),
-                        background_color: None,
-                        underline: None,
-                        strikethrough: None,
-                    }],
-                    wrap_width,
-                )
-                .width;
-        }
+        let total_wrapped_lines = lines
+            .iter()
+            .map(|line| {
+                // +1 is the first line, `wrap_boundaries` is the wrapped lines after the `\n`.
+                1 + line.wrap_boundaries.len()
+            })
+            .sum::<usize>();
 
-        let total_wrapped_lines = state.text_wrapper.len();
-        let empty_bottom_height = bounds
-            .size
-            .height
-            .half()
-            .max(BOTTOM_MARGIN_ROWS * line_height);
+        let max_line_width = lines
+            .iter()
+            .map(|line| line.width())
+            .max()
+            .unwrap_or(bounds.size.width);
         let scroll_size = size(
-            if longest_line_width + line_number_width + RIGHT_MARGIN > bounds.size.width {
-                longest_line_width + line_number_width + RIGHT_MARGIN
-            } else {
-                longest_line_width
-            },
-            (total_wrapped_lines as f32 * line_height + empty_bottom_height)
-                .max(bounds.size.height),
+            max_line_width + line_number_width + RIGHT_MARGIN,
+            (total_wrapped_lines as f32 * line_height).max(bounds.size.height),
         );
 
-        let mut last_layout = LastLayout {
-            visible_range,
-            visible_top,
-            visible_range_offset: visible_start_offset..visible_end_offset,
-            line_height,
-            wrap_width,
-            line_number_width,
-            lines: Rc::new(lines),
-            cursor_bounds: None,
-        };
-
         // `position_for_index` for example
         //
         // #### text
@@ -699,27 +584,37 @@ impl Element for TextElement {
 
         // Calculate the scroll offset to keep the cursor in view
 
-        let (cursor_bounds, cursor_scroll_offset, _) =
-            self.layout_cursor(&last_layout, &mut bounds, window, cx);
-        last_layout.cursor_bounds = cursor_bounds;
+        let (cursor_bounds, cursor_scroll_offset, _) = self.layout_cursor(
+            &lines,
+            line_height,
+            &mut bounds,
+            line_number_width,
+            window,
+            cx,
+        );
 
-        let selection_path = self.layout_selections(&last_layout, &mut bounds, cx);
-        let search_match_paths = vec![];
-        let hover_highlight_path = None;
-        let line_numbers = None;
-        let hover_definition_hitbox = None;
+        let selection_path = self.layout_selections(
+            &lines,
+            line_height,
+            &mut bounds,
+            line_number_width,
+            window,
+            cx,
+        );
 
         PrepaintState {
             bounds,
-            last_layout,
+            last_layout: LastLayout {
+                lines: Rc::new(lines),
+                line_height,
+                visible_range,
+            },
             scroll_size,
-            line_numbers,
+            line_numbers: None,
+            line_number_width,
             cursor_bounds,
             cursor_scroll_offset,
             selection_path,
-            search_match_paths,
-            hover_highlight_path,
-            hover_definition_hitbox,
         }
     }
 
@@ -733,21 +628,21 @@ impl Element for TextElement {
         window: &mut Window,
         cx: &mut App,
     ) {
-        let focus_handle = self.state.read(cx).focus_handle.clone();
-        let show_cursor = self.state.read(cx).show_cursor(window, cx);
+        let focus_handle = self.input.read(cx).focus_handle.clone();
         let focused = focus_handle.is_focused(window);
         let bounds = prepaint.bounds;
-        let selected_range = self.state.read(cx).selected_range;
+        let selected_range = self.input.read(cx).selected_range.clone();
+        let visible_range = &prepaint.last_layout.visible_range;
 
         window.handle_input(
             &focus_handle,
-            ElementInputHandler::new(bounds, self.state.clone()),
+            ElementInputHandler::new(bounds, self.input.clone()),
             cx,
         );
 
         // Set Root focused_input when self is focused
         if focused {
-            let state = self.state.clone();
+            let state = self.input.clone();
             if Root::read(window, cx).focused_input.as_ref() != Some(&state) {
                 Root::update(window, cx, |root, _, cx| {
                     root.focused_input = Some(state);
@@ -758,7 +653,7 @@ impl Element for TextElement {
 
         // And reset focused_input when next_frame start
         window.on_next_frame({
-            let state = self.state.clone();
+            let state = self.input.clone();
             move |window, cx| {
                 if !focused && Root::read(window, cx).focused_input.as_ref() == Some(&state) {
                     Root::update(window, cx, |root, _, cx| {
@@ -773,10 +668,13 @@ impl Element for TextElement {
         let line_height = window.line_height();
         let origin = bounds.origin;
 
-        let invisible_top_padding = prepaint.last_layout.visible_top;
+        let mut invisible_top_padding = px(0.);
+        for line in prepaint.last_layout.lines.iter().take(visible_range.start) {
+            invisible_top_padding += line.size(line_height).height;
+        }
 
         let mut mask_offset_y = px(0.);
-        if self.state.read(cx).masked {
+        if self.input.read(cx).masked {
             // Move down offset for vertical centering the *****
             if cfg!(target_os = "macos") {
                 mask_offset_y = px(3.);
@@ -785,105 +683,60 @@ impl Element for TextElement {
             }
         }
 
-        // Paint active line
         let mut offset_y = px(0.);
         if let Some(line_numbers) = prepaint.line_numbers.as_ref() {
             offset_y += invisible_top_padding;
 
             // Each item is the normal lines.
             for lines in line_numbers.iter() {
-                let height = line_height * lines.len() as f32;
-                offset_y += height;
+                for line in lines {
+                    let p = point(origin.x, origin.y + offset_y);
+                    let line_size = line.size(line_height);
+                    _ = line.paint(p, line_height, TextAlign::Left, None, window, cx);
+                    offset_y += line_size.height;
+                }
             }
         }
 
         // Paint selections
-        if window.is_window_active() {
-            let secondary_selection = cx.theme().selection;
-            for (path, is_active) in prepaint.search_match_paths.iter() {
-                window.paint_path(path.clone(), secondary_selection);
-
-                if *is_active {
-                    window.paint_path(path.clone(), cx.theme().selection);
-                }
-            }
-
-            if let Some(path) = prepaint.selection_path.take() {
-                window.paint_path(path, cx.theme().selection);
-            }
-
-            // Paint hover highlight
-            if let Some(path) = prepaint.hover_highlight_path.take() {
-                window.paint_path(path, secondary_selection);
-            }
+        if let Some(path) = prepaint.selection_path.take() {
+            window.paint_path(path, cx.theme().selection);
         }
 
         // Paint text
         let mut offset_y = mask_offset_y + invisible_top_padding;
-        for line in prepaint.last_layout.lines.iter() {
-            let p = point(
-                origin.x + prepaint.last_layout.line_number_width,
-                origin.y + offset_y,
-            );
+        for line in prepaint
+            .last_layout
+            .iter()
+            .skip(visible_range.start)
+            .take(visible_range.len())
+        {
+            let p = point(origin.x + prepaint.line_number_width, origin.y + offset_y);
             _ = line.paint(p, line_height, TextAlign::Left, None, window, cx);
             offset_y += line.size(line_height).height;
         }
 
-        // Paint blinking cursor
-        if focused && show_cursor {
+        if focused {
             if let Some(mut cursor_bounds) = prepaint.cursor_bounds.take() {
                 cursor_bounds.origin.y += prepaint.cursor_scroll_offset.y;
                 window.paint_quad(fill(cursor_bounds, cx.theme().cursor));
             }
         }
 
-        // Paint line numbers
-        let mut offset_y = px(0.);
-        if let Some(line_numbers) = prepaint.line_numbers.as_ref() {
-            offset_y += invisible_top_padding;
-
-            // Paint line number background
-            window.paint_quad(fill(
-                Bounds {
-                    origin: input_bounds.origin,
-                    size: size(
-                        prepaint.last_layout.line_number_width - LINE_NUMBER_RIGHT_MARGIN,
-                        input_bounds.size.height,
-                    ),
-                },
-                cx.theme().background,
-            ));
-
-            // Each item is the normal lines.
-            for lines in line_numbers.iter() {
-                let p = point(input_bounds.origin.x, origin.y + offset_y);
-
-                for line in lines {
-                    _ = line.paint(p, line_height, window, cx);
-                    offset_y += line_height;
-                }
-            }
-        }
-
-        self.state.update(cx, |state, cx| {
-            state.last_layout = Some(prepaint.last_layout.clone());
-            state.last_bounds = Some(bounds);
-            state.last_cursor = Some(state.cursor());
-            state.set_input_bounds(input_bounds, cx);
-            state.last_selected_range = Some(selected_range);
-            state.scroll_size = prepaint.scroll_size;
-            state
+        self.input.update(cx, |input, cx| {
+            input.last_layout = Some(prepaint.last_layout.clone());
+            input.last_bounds = Some(bounds);
+            input.last_cursor_offset = Some(input.cursor_offset());
+            input.set_input_bounds(input_bounds, cx);
+            input.last_selected_range = Some(selected_range);
+            input.scroll_size = prepaint.scroll_size;
+            input.line_number_width = prepaint.line_number_width;
+            input
                 .scroll_handle
                 .set_offset(prepaint.cursor_scroll_offset);
-            state.deferred_scroll_offset = None;
-
             cx.notify();
         });
 
-        if let Some(hitbox) = prepaint.hover_definition_hitbox.as_ref() {
-            window.set_cursor_style(gpui::CursorStyle::PointingHand, hitbox);
-        }
-
         self.paint_mouse_listeners(window, cx);
     }
 }

crates/ui/src/input/mask_pattern.rs

@@ -1,410 +1,378 @@
-use gpui::SharedString;
-
-#[derive(Clone, PartialEq, Debug)]
-pub enum MaskToken {
-    /// 0 Digit, equivalent to `[0]`
-    // Digit0,
-    /// Digit, equivalent to `[0-9]`
-    Digit,
-    /// Letter, equivalent to `[a-zA-Z]`
-    Letter,
-    /// Letter or digit, equivalent to `[a-zA-Z0-9]`
-    LetterOrDigit,
-    /// Separator
-    Sep(char),
-    /// Any character
-    Any,
-}
-
-#[allow(unused)]
-impl MaskToken {
-    /// Check if the token is any character.
-    pub fn is_any(&self) -> bool {
-        matches!(self, MaskToken::Any)
-    }
-
-    /// Check if the token is a match for the given character.
-    ///
-    /// The separator is always a match any input character.
-    fn is_match(&self, ch: char) -> bool {
-        match self {
-            MaskToken::Digit => ch.is_ascii_digit(),
-            MaskToken::Letter => ch.is_ascii_alphabetic(),
-            MaskToken::LetterOrDigit => ch.is_ascii_alphanumeric(),
-            MaskToken::Any => true,
-            MaskToken::Sep(c) => *c == ch,
-        }
-    }
-
-    /// Is the token a separator (Can be ignored)
-    fn is_sep(&self) -> bool {
-        matches!(self, MaskToken::Sep(_))
-    }
-
-    /// Check if the token is a number.
-    pub fn is_number(&self) -> bool {
-        matches!(self, MaskToken::Digit)
-    }
-
-    pub fn placeholder(&self) -> char {
-        match self {
-            MaskToken::Sep(c) => *c,
-            _ => '_',
-        }
-    }
-
-    fn mask_char(&self, ch: char) -> char {
-        match self {
-            MaskToken::Digit | MaskToken::LetterOrDigit | MaskToken::Letter => ch,
-            MaskToken::Sep(c) => *c,
-            MaskToken::Any => ch,
-        }
-    }
-
-    fn unmask_char(&self, ch: char) -> Option<char> {
-        match self {
-            MaskToken::Digit => Some(ch),
-            MaskToken::Letter => Some(ch),
-            MaskToken::LetterOrDigit => Some(ch),
-            MaskToken::Any => Some(ch),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Clone, Default)]
-pub enum MaskPattern {
-    #[default]
-    None,
-    Pattern {
-        pattern: SharedString,
-        tokens: Vec<MaskToken>,
-    },
-    Number {
-        /// Group separator, e.g. "," or " "
-        separator: Option<char>,
-        /// Number of fraction digits, e.g. 2 for 123.45
-        fraction: Option<usize>,
-    },
-}
-
-impl From<&str> for MaskPattern {
-    fn from(pattern: &str) -> Self {
-        Self::new(pattern)
-    }
-}
-
-impl MaskPattern {
-    /// Create a new mask pattern
-    ///
-    /// - `9` - Digit
-    /// - `A` - Letter
-    /// - `#` - Letter or Digit
-    /// - `*` - Any character
-    /// - other characters - Separator
-    ///
-    /// For example:
-    ///
-    /// - `(999)999-9999` - US phone number: (123)456-7890
-    /// - `99999-9999` - ZIP code: 12345-6789
-    /// - `AAAA-99-####` - Custom pattern: ABCD-12-3AB4
-    /// - `*999*` - Custom pattern: (123) or [123]
-    pub fn new(pattern: &str) -> Self {
-        let tokens = pattern
-            .chars()
-            .map(|ch| match ch {
-                // '0' => MaskToken::Digit0,
-                '9' => MaskToken::Digit,
-                'A' => MaskToken::Letter,
-                '#' => MaskToken::LetterOrDigit,
-                '*' => MaskToken::Any,
-                _ => MaskToken::Sep(ch),
-            })
-            .collect();
-
-        Self::Pattern {
-            pattern: pattern.to_owned().into(),
-            tokens,
-        }
-    }
-
-    #[allow(unused)]
-    fn tokens(&self) -> Option<&Vec<MaskToken>> {
-        match self {
-            Self::Pattern { tokens, .. } => Some(tokens),
-            Self::Number { .. } => None,
-            Self::None => None,
-        }
-    }
-
-    /// Create a new mask pattern with group separator, e.g. "," or " "
-    pub fn number(sep: Option<char>) -> Self {
-        Self::Number {
-            separator: sep,
-            fraction: None,
-        }
-    }
-
-    pub fn placeholder(&self) -> Option<String> {
-        match self {
-            Self::Pattern { tokens, .. } => {
-                Some(tokens.iter().map(|token| token.placeholder()).collect())
-            }
-            Self::Number { .. } => None,
-            Self::None => None,
-        }
-    }
-
-    /// Return true if the mask pattern is None or no any pattern.
-    pub fn is_none(&self) -> bool {
-        match self {
-            Self::Pattern { tokens, .. } => tokens.is_empty(),
-            Self::Number { .. } => false,
-            Self::None => true,
-        }
-    }
-
-    /// Check is the mask text is valid.
-    ///
-    /// If the mask pattern is None, always return true.
-    pub fn is_valid(&self, mask_text: &str) -> bool {
-        if self.is_none() {
-            return true;
-        }
-
-        let mut text_index = 0;
-        let mask_text_chars: Vec<char> = mask_text.chars().collect();
-        match self {
-            Self::Pattern { tokens, .. } => {
-                for token in tokens {
-                    if text_index >= mask_text_chars.len() {
-                        break;
-                    }
-
-                    let ch = mask_text_chars[text_index];
-                    if token.is_match(ch) {
-                        text_index += 1;
-                    }
-                }
-                text_index == mask_text.len()
-            }
-            Self::Number { separator, .. } => {
-                if mask_text.is_empty() {
-                    return true;
-                }
-
-                // check if the text is valid number
-                let mut parts = mask_text.split('.');
-                let int_part = parts.next().unwrap_or("");
-                let frac_part = parts.next();
-
-                if int_part.is_empty() {
-                    return false;
-                }
-
-                let sign_positions: Vec<usize> = int_part
-                    .chars()
-                    .enumerate()
-                    .filter_map(|(i, ch)| match is_sign(&ch) {
-                        true => Some(i),
-                        false => None,
-                    })
-                    .collect();
-
-                // only one sign is valid
-                // sign is only valid at the beginning of the string
-                if sign_positions.len() > 1 || sign_positions.first() > Some(&0) {
-                    return false;
-                }
-
-                // check if the integer part is valid
-                if !int_part.chars().enumerate().all(|(i, ch)| {
-                    ch.is_ascii_digit() || is_sign(&ch) && i == 0 || Some(ch) == *separator
-                }) {
-                    return false;
-                }
-
-                // check if the fraction part is valid
-                if let Some(frac) = frac_part {
-                    if !frac
-                        .chars()
-                        .all(|ch| ch.is_ascii_digit() || Some(ch) == *separator)
-                    {
-                        return false;
-                    }
-                }
-
-                true
-            }
-            Self::None => true,
-        }
-    }
-
-    /// Check if valid input char at the given position.
-    pub fn is_valid_at(&self, ch: char, pos: usize) -> bool {
-        if self.is_none() {
-            return true;
-        }
-
-        match self {
-            Self::Pattern { tokens, .. } => {
-                if let Some(token) = tokens.get(pos) {
-                    if token.is_match(ch) {
-                        return true;
-                    }
-
-                    if token.is_sep() {
-                        // If next token is match, it's valid
-                        if let Some(next_token) = tokens.get(pos + 1) {
-                            if next_token.is_match(ch) {
-                                return true;
-                            }
-                        }
-                    }
-                }
-
-                false
-            }
-            Self::Number { .. } => true,
-            Self::None => true,
-        }
-    }
-
-    /// Format the text according to the mask pattern
-    ///
-    /// For example:
-    ///
-    /// - pattern: (999)999-999
-    /// - text: 123456789
-    /// - mask_text: (123)456-789
-    pub fn mask(&self, text: &str) -> SharedString {
-        if self.is_none() {
-            return text.to_owned().into();
-        }
-
-        match self {
-            Self::Number {
-                separator,
-                fraction,
-            } => {
-                if let Some(sep) = *separator {
-                    // Remove the existing group separator
-                    let text = text.replace(sep, "");
-
-                    let mut parts = text.split('.');
-                    let int_part = parts.next().unwrap_or("");
-
-                    // Limit the fraction part to the given range, if not enough, pad with 0
-                    let frac_part = parts.next().map(|part| {
-                        part.chars()
-                            .take(fraction.unwrap_or(usize::MAX))
-                            .collect::<String>()
-                    });
-
-                    // Reverse the integer part for easier grouping
-                    let mut chars: Vec<char> = int_part.chars().rev().collect();
-
-                    // Removing the sign from formatting to avoid cases such as: -,123
-                    let maybe_signed = chars.iter().position(is_sign).map(|pos| chars.remove(pos));
-
-                    let mut result = String::new();
-                    for (i, ch) in chars.iter().enumerate() {
-                        if i > 0 && i % 3 == 0 {
-                            result.push(sep);
-                        }
-                        result.push(*ch);
-                    }
-                    let int_with_sep: String = result.chars().rev().collect();
-
-                    let final_str = if let Some(frac) = frac_part {
-                        if fraction == &Some(0) {
-                            int_with_sep
-                        } else {
-                            format!("{int_with_sep}.{frac}")
-                        }
-                    } else {
-                        int_with_sep
-                    };
-
-                    let final_str = if let Some(sign) = maybe_signed {
-                        format!("{sign}{final_str}")
-                    } else {
-                        final_str
-                    };
-
-                    return final_str.into();
-                }
-
-                text.to_owned().into()
-            }
-            Self::Pattern { tokens, .. } => {
-                let mut result = String::new();
-                let mut text_index = 0;
-                let text_chars: Vec<char> = text.chars().collect();
-                for (pos, token) in tokens.iter().enumerate() {
-                    if text_index >= text_chars.len() {
-                        break;
-                    }
-                    let ch = text_chars[text_index];
-                    // Break if expected char is not match
-                    if !token.is_sep() && !self.is_valid_at(ch, pos) {
-                        break;
-                    }
-                    let mask_ch = token.mask_char(ch);
-                    result.push(mask_ch);
-                    if ch == mask_ch {
-                        text_index += 1;
-                        continue;
-                    }
-                }
-                result.into()
-            }
-            Self::None => text.to_owned().into(),
-        }
-    }
-
-    /// Extract original text from masked text
-    pub fn unmask(&self, mask_text: &str) -> String {
-        match self {
-            Self::Number { separator, .. } => {
-                if let Some(sep) = *separator {
-                    let mut result = String::new();
-                    for ch in mask_text.chars() {
-                        if ch == sep {
-                            continue;
-                        }
-                        result.push(ch);
-                    }
-
-                    if result.contains('.') {
-                        result = result.trim_end_matches('0').to_string();
-                    }
-                    return result;
-                }
-
-                mask_text.to_owned()
-            }
-            Self::Pattern { tokens, .. } => {
-                let mut result = String::new();
-                let mask_text_chars: Vec<char> = mask_text.chars().collect();
-                for (text_index, token) in tokens.iter().enumerate() {
-                    if text_index >= mask_text_chars.len() {
-                        break;
-                    }
-                    let ch = mask_text_chars[text_index];
-                    let unmask_ch = token.unmask_char(ch);
-                    if let Some(ch) = unmask_ch {
-                        result.push(ch);
-                    }
-                }
-                result
-            }
-            Self::None => mask_text.to_owned(),
-        }
-    }
-}
-
-#[inline]
-fn is_sign(ch: &char) -> bool {
-    matches!(ch, '+' | '-')
-}
+use gpui::SharedString;
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum MaskToken {
+    /// Digit, equivalent to `[0-9]`
+    Digit,
+    /// Letter, equivalent to `[a-zA-Z]`
+    Letter,
+    /// Letter or digit, equivalent to `[a-zA-Z0-9]`
+    LetterOrDigit,
+    /// Separator
+    Sep(char),
+    /// Any character
+    Any,
+}
+
+#[allow(unused)]
+impl MaskToken {
+    /// Check if the token is any character.
+    pub fn is_any(&self) -> bool {
+        matches!(self, MaskToken::Any)
+    }
+
+    /// Check if the token is a match for the given character.
+    ///
+    /// The separator is always a match any input character.
+    fn is_match(&self, ch: char) -> bool {
+        match self {
+            MaskToken::Digit => ch.is_ascii_digit(),
+            MaskToken::Letter => ch.is_ascii_alphabetic(),
+            MaskToken::LetterOrDigit => ch.is_ascii_alphanumeric(),
+            MaskToken::Any => true,
+            MaskToken::Sep(c) => *c == ch,
+        }
+    }
+
+    /// Is the token a separator (Can be ignored)
+    fn is_sep(&self) -> bool {
+        matches!(self, MaskToken::Sep(_))
+    }
+
+    /// Check if the token is a number.
+    pub fn is_number(&self) -> bool {
+        matches!(self, MaskToken::Digit)
+    }
+
+    pub fn placeholder(&self) -> char {
+        match self {
+            MaskToken::Sep(c) => *c,
+            _ => '_',
+        }
+    }
+
+    fn mask_char(&self, ch: char) -> char {
+        match self {
+            MaskToken::Digit | MaskToken::LetterOrDigit | MaskToken::Letter => ch,
+            MaskToken::Sep(c) => *c,
+            MaskToken::Any => ch,
+        }
+    }
+
+    fn unmask_char(&self, ch: char) -> Option<char> {
+        match self {
+            MaskToken::Digit => Some(ch),
+            MaskToken::Letter => Some(ch),
+            MaskToken::LetterOrDigit => Some(ch),
+            MaskToken::Any => Some(ch),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Clone, Default)]
+pub enum MaskPattern {
+    #[default]
+    None,
+    Pattern {
+        pattern: SharedString,
+        tokens: Vec<MaskToken>,
+    },
+    Number {
+        /// Group separator, e.g. "," or " "
+        separator: Option<char>,
+        /// Number of fraction digits, e.g. 2 for 123.45
+        fraction: Option<usize>,
+    },
+}
+
+impl From<&str> for MaskPattern {
+    fn from(pattern: &str) -> Self {
+        Self::new(pattern)
+    }
+}
+
+impl MaskPattern {
+    /// Create a new mask pattern
+    ///
+    /// - `9` - Digit
+    /// - `A` - Letter
+    /// - `#` - Letter or Digit
+    /// - `*` - Any character
+    /// - other characters - Separator
+    ///
+    /// For example:
+    ///
+    /// - `(999)999-9999` - US phone number: (123)456-7890
+    /// - `99999-9999` - ZIP code: 12345-6789
+    /// - `AAAA-99-####` - Custom pattern: ABCD-12-3AB4
+    /// - `*999*` - Custom pattern: (123) or [123]
+    pub fn new(pattern: &str) -> Self {
+        let tokens = pattern
+            .chars()
+            .map(|ch| match ch {
+                // '0' => MaskToken::Digit0,
+                '9' => MaskToken::Digit,
+                'A' => MaskToken::Letter,
+                '#' => MaskToken::LetterOrDigit,
+                '*' => MaskToken::Any,
+                _ => MaskToken::Sep(ch),
+            })
+            .collect();
+
+        Self::Pattern {
+            pattern: pattern.to_owned().into(),
+            tokens,
+        }
+    }
+
+    #[allow(unused)]
+    fn tokens(&self) -> Option<&Vec<MaskToken>> {
+        match self {
+            Self::Pattern { tokens, .. } => Some(tokens),
+            Self::Number { .. } => None,
+            Self::None => None,
+        }
+    }
+
+    /// Create a new mask pattern with group separator, e.g. "," or " "
+    pub fn number(sep: Option<char>) -> Self {
+        Self::Number {
+            separator: sep,
+            fraction: None,
+        }
+    }
+
+    pub fn placeholder(&self) -> Option<String> {
+        match self {
+            Self::Pattern { tokens, .. } => {
+                Some(tokens.iter().map(|token| token.placeholder()).collect())
+            }
+            Self::Number { .. } => None,
+            Self::None => None,
+        }
+    }
+
+    /// Return true if the mask pattern is None or no any pattern.
+    pub fn is_none(&self) -> bool {
+        match self {
+            Self::Pattern { tokens, .. } => tokens.is_empty(),
+            Self::Number { .. } => false,
+            Self::None => true,
+        }
+    }
+
+    /// Check is the mask text is valid.
+    ///
+    /// If the mask pattern is None, always return true.
+    pub fn is_valid(&self, mask_text: &str) -> bool {
+        if self.is_none() {
+            return true;
+        }
+
+        let mut text_index = 0;
+        let mask_text_chars: Vec<char> = mask_text.chars().collect();
+        match self {
+            Self::Pattern { tokens, .. } => {
+                for token in tokens {
+                    if text_index >= mask_text_chars.len() {
+                        break;
+                    }
+
+                    let ch = mask_text_chars[text_index];
+                    if token.is_match(ch) {
+                        text_index += 1;
+                    }
+                }
+                text_index == mask_text.len()
+            }
+            Self::Number { separator, .. } => {
+                if mask_text.is_empty() {
+                    return true;
+                }
+
+                // check if the text is valid number
+                let mut parts = mask_text.split('.');
+                let int_part = parts.next().unwrap_or("");
+                let frac_part = parts.next();
+
+                if int_part.is_empty() {
+                    return false;
+                }
+
+                // check if the integer part is valid
+                if !int_part
+                    .chars()
+                    .all(|ch| ch.is_ascii_digit() || Some(ch) == *separator)
+                {
+                    return false;
+                }
+
+                // check if the fraction part is valid
+                if let Some(frac) = frac_part {
+                    if !frac
+                        .chars()
+                        .all(|ch| ch.is_ascii_digit() || Some(ch) == *separator)
+                    {
+                        return false;
+                    }
+                }
+
+                true
+            }
+            Self::None => true,
+        }
+    }
+
+    /// Check if valid input char at the given position.
+    pub fn is_valid_at(&self, ch: char, pos: usize) -> bool {
+        if self.is_none() {
+            return true;
+        }
+
+        match self {
+            Self::Pattern { tokens, .. } => {
+                if let Some(token) = tokens.get(pos) {
+                    if token.is_match(ch) {
+                        return true;
+                    }
+
+                    if token.is_sep() {
+                        // If next token is match, it's valid
+                        if let Some(next_token) = tokens.get(pos + 1) {
+                            if next_token.is_match(ch) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+
+                false
+            }
+            Self::Number { .. } => true,
+            Self::None => true,
+        }
+    }
+
+    /// Format the text according to the mask pattern
+    ///
+    /// For example:
+    ///
+    /// - pattern: (999)999-999
+    /// - text: 123456789
+    /// - mask_text: (123)456-789
+    pub fn mask(&self, text: &str) -> SharedString {
+        if self.is_none() {
+            return text.to_owned().into();
+        }
+
+        match self {
+            Self::Number {
+                separator,
+                fraction,
+            } => {
+                if let Some(sep) = *separator {
+                    // Remove the existing group separator
+                    let text = text.replace(sep, "");
+
+                    let mut parts = text.split('.');
+                    let int_part = parts.next().unwrap_or("");
+
+                    // Limit the fraction part to the given range, if not enough, pad with 0
+                    let frac_part = parts.next().map(|part| {
+                        part.chars()
+                            .take(fraction.unwrap_or(usize::MAX))
+                            .collect::<String>()
+                    });
+
+                    // Reverse the integer part for easier grouping
+                    let chars: Vec<char> = int_part.chars().rev().collect();
+                    let mut result = String::new();
+                    for (i, ch) in chars.iter().enumerate() {
+                        if i > 0 && i % 3 == 0 {
+                            result.push(sep);
+                        }
+                        result.push(*ch);
+                    }
+                    let int_with_sep: String = result.chars().rev().collect();
+
+                    let final_str = if let Some(frac) = frac_part {
+                        if fraction == &Some(0) {
+                            int_with_sep
+                        } else {
+                            format!("{int_with_sep}.{frac}")
+                        }
+                    } else {
+                        int_with_sep
+                    };
+                    return final_str.into();
+                }
+
+                text.to_owned().into()
+            }
+            Self::Pattern { tokens, .. } => {
+                let mut result = String::new();
+                let mut text_index = 0;
+                let text_chars: Vec<char> = text.chars().collect();
+                for (pos, token) in tokens.iter().enumerate() {
+                    if text_index >= text_chars.len() {
+                        break;
+                    }
+                    let ch = text_chars[text_index];
+                    // Break if expected char is not match
+                    if !token.is_sep() && !self.is_valid_at(ch, pos) {
+                        break;
+                    }
+                    let mask_ch = token.mask_char(ch);
+                    result.push(mask_ch);
+                    if ch == mask_ch {
+                        text_index += 1;
+                        continue;
+                    }
+                }
+                result.into()
+            }
+            Self::None => text.to_owned().into(),
+        }
+    }
+
+    /// Extract original text from masked text
+    pub fn unmask(&self, mask_text: &str) -> String {
+        match self {
+            Self::Number { separator, .. } => {
+                if let Some(sep) = *separator {
+                    let mut result = String::new();
+                    for ch in mask_text.chars() {
+                        if ch == sep {
+                            continue;
+                        }
+                        result.push(ch);
+                    }
+
+                    if result.contains('.') {
+                        result = result.trim_end_matches('0').to_string();
+                    }
+                    return result;
+                }
+
+                mask_text.to_owned()
+            }
+            Self::Pattern { tokens, .. } => {
+                let mut result = String::new();
+                let mask_text_chars: Vec<char> = mask_text.chars().collect();
+                for (text_index, token) in tokens.iter().enumerate() {
+                    if text_index >= mask_text_chars.len() {
+                        break;
+                    }
+                    let ch = mask_text_chars[text_index];
+                    let unmask_ch = token.unmask_char(ch);
+                    if let Some(ch) = unmask_ch {
+                        result.push(ch);
+                    }
+                }
+                result
+            }
+            Self::None => mask_text.to_owned(),
+        }
+    }
+}

crates/ui/src/input/mod.rs

@@ -1,15 +1,13 @@
 mod blink_cursor;
 mod change;
-mod cursor;
 mod element;
 mod mask_pattern;
-mod mode;
-mod rope_ext;
 mod state;
 mod text_input;
 mod text_wrapper;
 
 pub(crate) mod clear_button;
 
+#[allow(ambiguous_glob_reexports)]
 pub use state::*;
 pub use text_input::*;

crates/ui/src/input/mode.rs

@@ -1,129 +0,0 @@
-use gpui::SharedString;
-
-use super::text_wrapper::TextWrapper;
-
-#[derive(Debug, Copy, Clone)]
-pub struct TabSize {
-    /// Default is 2
-    pub tab_size: usize,
-    /// Set true to use `\t` as tab indent, default is false
-    pub hard_tabs: bool,
-}
-
-impl Default for TabSize {
-    fn default() -> Self {
-        Self {
-            tab_size: 2,
-            hard_tabs: false,
-        }
-    }
-}
-
-impl TabSize {
-    pub(super) fn to_string(self) -> SharedString {
-        if self.hard_tabs {
-            "\t".into()
-        } else {
-            " ".repeat(self.tab_size).into()
-        }
-    }
-}
-
-#[derive(Default, Clone)]
-pub enum InputMode {
-    #[default]
-    SingleLine,
-    MultiLine {
-        tab: TabSize,
-        rows: usize,
-    },
-    AutoGrow {
-        rows: usize,
-        min_rows: usize,
-        max_rows: usize,
-    },
-}
-
-#[allow(unused)]
-impl InputMode {
-    #[inline]
-    pub(super) fn is_single_line(&self) -> bool {
-        matches!(self, InputMode::SingleLine)
-    }
-
-    #[inline]
-    pub(super) fn is_auto_grow(&self) -> bool {
-        matches!(self, InputMode::AutoGrow { .. })
-    }
-
-    #[inline]
-    pub(super) fn is_multi_line(&self) -> bool {
-        matches!(
-            self,
-            InputMode::MultiLine { .. } | InputMode::AutoGrow { .. }
-        )
-    }
-
-    pub(super) fn set_rows(&mut self, new_rows: usize) {
-        match self {
-            InputMode::MultiLine { rows, .. } => {
-                *rows = new_rows;
-            }
-            InputMode::AutoGrow {
-                rows,
-                min_rows,
-                max_rows,
-            } => {
-                *rows = new_rows.clamp(*min_rows, *max_rows);
-            }
-            _ => {}
-        }
-    }
-
-    pub(super) fn update_auto_grow(&mut self, text_wrapper: &TextWrapper) {
-        if self.is_single_line() {
-            return;
-        }
-
-        let wrapped_lines = text_wrapper.len();
-        self.set_rows(wrapped_lines);
-    }
-
-    /// At least 1 row be return.
-    pub(super) fn rows(&self) -> usize {
-        match self {
-            InputMode::MultiLine { rows, .. } => *rows,
-            InputMode::AutoGrow { rows, .. } => *rows,
-            _ => 1,
-        }
-        .max(1)
-    }
-
-    /// At least 1 row be return.
-    #[allow(unused)]
-    pub(super) fn min_rows(&self) -> usize {
-        match self {
-            InputMode::MultiLine { .. } => 1,
-            InputMode::AutoGrow { min_rows, .. } => *min_rows,
-            _ => 1,
-        }
-        .max(1)
-    }
-
-    #[allow(unused)]
-    pub(super) fn max_rows(&self) -> usize {
-        match self {
-            InputMode::MultiLine { .. } => usize::MAX,
-            InputMode::AutoGrow { max_rows, .. } => *max_rows,
-            _ => 1,
-        }
-    }
-
-    #[inline]
-    pub(super) fn tab_size(&self) -> Option<&TabSize> {
-        match self {
-            InputMode::MultiLine { tab, .. } => Some(tab),
-            _ => None,
-        }
-    }
-}

crates/ui/src/input/rope_ext.rs

@@ -1,207 +0,0 @@
-use std::ops::Range;
-
-use rope::{Point, Rope};
-
-use super::cursor::Position;
-
-/// An extension trait for `Rope` to provide additional utility methods.
-pub trait RopeExt {
-    /// Get the line at the given row (0-based) index, including the `\r` at the end, but not `\n`.
-    ///
-    /// Return empty rope if the row (0-based) is out of bounds.
-    fn line(&self, row: usize) -> Rope;
-
-    /// Start offset of the line at the given row (0-based) index.
-    fn line_start_offset(&self, row: usize) -> usize;
-
-    /// Line the end offset (including `\n`) of the line at the given row (0-based) index.
-    ///
-    /// Return the end of the rope if the row is out of bounds.
-    fn line_end_offset(&self, row: usize) -> usize;
-
-    /// Return the number of lines in the rope.
-    fn lines_len(&self) -> usize;
-
-    /// Return the lines iterator.
-    ///
-    /// Each line is including the `\r` at the end, but not `\n`.
-    fn lines(&self) -> RopeLines;
-
-    /// Check is equal to another rope.
-    fn eq(&self, other: &Rope) -> bool;
-
-    /// Total number of characters in the rope.
-    fn chars_count(&self) -> usize;
-
-    /// Get char at the given offset (byte).
-    ///
-    /// If the offset is in the middle of a multi-byte character will panic.
-    ///
-    /// If the offset is out of bounds, return None.
-    fn char_at(&self, offset: usize) -> Option<char>;
-
-    /// Get the byte offset from the given line, column [`Position`] (0-based).
-    fn position_to_offset(&self, line_col: &Position) -> usize;
-
-    /// Get the line, column [`Position`] (0-based) from the given byte offset.
-    fn offset_to_position(&self, offset: usize) -> Position;
-
-    /// Get the word byte range at the given offset (byte).
-    fn word_range(&self, offset: usize) -> Option<Range<usize>>;
-
-    /// Get word at the given offset (byte).
-    #[allow(dead_code)]
-    fn word_at(&self, offset: usize) -> String;
-}
-
-/// An iterator over the lines of a `Rope`.
-pub struct RopeLines {
-    row: usize,
-    end_row: usize,
-    rope: Rope,
-}
-
-impl RopeLines {
-    /// Create a new `RopeLines` iterator.
-    pub fn new(rope: Rope) -> Self {
-        let end_row = rope.lines_len();
-        Self {
-            row: 0,
-            end_row,
-            rope,
-        }
-    }
-}
-
-impl Iterator for RopeLines {
-    type Item = Rope;
-
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.row >= self.end_row {
-            return None;
-        }
-
-        let line = self.rope.line(self.row);
-        self.row += 1;
-        Some(line)
-    }
-
-    #[inline]
-    fn nth(&mut self, n: usize) -> Option<Self::Item> {
-        self.row = self.row.saturating_add(n);
-        self.next()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.end_row - self.row;
-        (len, Some(len))
-    }
-}
-
-impl std::iter::ExactSizeIterator for RopeLines {}
-impl std::iter::FusedIterator for RopeLines {}
-
-impl RopeExt for Rope {
-    fn line(&self, row: usize) -> Rope {
-        let start = self.line_start_offset(row);
-        let end = start + self.line_len(row as u32) as usize;
-        self.slice(start..end)
-    }
-
-    fn line_start_offset(&self, row: usize) -> usize {
-        let row = row as u32;
-        self.point_to_offset(Point::new(row, 0))
-    }
-
-    fn position_to_offset(&self, pos: &Position) -> usize {
-        let line = self.line(pos.line as usize);
-        self.line_start_offset(pos.line as usize)
-            + line
-                .chars()
-                .take(pos.character as usize)
-                .map(|c| c.len_utf8())
-                .sum::<usize>()
-    }
-
-    fn offset_to_position(&self, offset: usize) -> Position {
-        let point = self.offset_to_point(offset);
-        let line = self.line(point.row as usize);
-        let column = line.clip_offset(point.column as usize, sum_tree::Bias::Left);
-        let character = line.slice(0..column).chars().count();
-        Position::new(point.row, character as u32)
-    }
-
-    fn line_end_offset(&self, row: usize) -> usize {
-        if row > self.max_point().row as usize {
-            return self.len();
-        }
-
-        self.line_start_offset(row) + self.line_len(row as u32) as usize
-    }
-
-    fn lines_len(&self) -> usize {
-        self.max_point().row as usize + 1
-    }
-
-    fn lines(&self) -> RopeLines {
-        RopeLines::new(self.clone())
-    }
-
-    fn eq(&self, other: &Rope) -> bool {
-        self.summary() == other.summary()
-    }
-
-    fn chars_count(&self) -> usize {
-        self.chars().count()
-    }
-
-    fn char_at(&self, offset: usize) -> Option<char> {
-        if offset > self.len() {
-            return None;
-        }
-
-        let offset = self.clip_offset(offset, sum_tree::Bias::Left);
-        self.slice(offset..self.len()).chars().next()
-    }
-
-    fn word_range(&self, offset: usize) -> Option<Range<usize>> {
-        if offset >= self.len() {
-            return None;
-        }
-
-        let offset = self.clip_offset(offset, sum_tree::Bias::Left);
-
-        let mut left = String::new();
-        for c in self.reversed_chars_at(offset) {
-            if c.is_alphanumeric() || c == '_' {
-                left.insert(0, c);
-            } else {
-                break;
-            }
-        }
-        let start = offset.saturating_sub(left.len());
-
-        let right = self
-            .chars_at(offset)
-            .take_while(|c| c.is_alphanumeric() || *c == '_')
-            .collect::<String>();
-
-        let end = offset + right.len();
-
-        if start == end {
-            None
-        } else {
-            Some(start..end)
-        }
-    }
-
-    fn word_at(&self, offset: usize) -> String {
-        if let Some(range) = self.word_range(offset) {
-            self.slice(range).to_string()
-        } else {
-            String::new()
-        }
-    }
-}

crates/ui/src/input/text_input.rs

@@ -6,10 +6,11 @@ use gpui::{
 };
 use theme::ActiveTheme;
 
-use super::clear_button::clear_button;
-use super::state::{InputState, CONTEXT};
-use crate::button::{Button, ButtonVariants};
+use super::InputState;
+use crate::button::{Button, ButtonVariants as _};
 use crate::indicator::Indicator;
+use crate::input::clear_button::clear_button;
+use crate::scroll::{Scrollbar, ScrollbarAxis};
 use crate::{h_flex, IconName, Sizable, Size, StyleSized, StyledExt};
 
 #[derive(IntoElement)]
@@ -17,6 +18,7 @@ pub struct TextInput {
     state: Entity<InputState>,
     style: StyleRefinement,
     size: Size,
+    no_gap: bool,
     prefix: Option<AnyElement>,
     suffix: Option<AnyElement>,
     height: Option<DefiniteLength>,
@@ -24,8 +26,6 @@ pub struct TextInput {
     cleanable: bool,
     mask_toggle: bool,
     disabled: bool,
-    bordered: bool,
-    focus_bordered: bool,
 }
 
 impl Sizable for TextInput {
@@ -40,8 +40,9 @@ impl TextInput {
     pub fn new(state: &Entity<InputState>) -> Self {
         Self {
             state: state.clone(),
-            size: Size::default(),
             style: StyleRefinement::default(),
+            size: Size::default(),
+            no_gap: false,
             prefix: None,
             suffix: None,
             height: None,
@@ -49,8 +50,6 @@ impl TextInput {
             cleanable: false,
             mask_toggle: false,
             disabled: false,
-            bordered: true,
-            focus_bordered: true,
         }
     }
 
@@ -76,24 +75,12 @@ impl TextInput {
         self
     }
 
-    /// Set the appearance of the input field, if false the input field will no border, background.
+    /// Set the appearance of the input field.
     pub fn appearance(mut self, appearance: bool) -> Self {
         self.appearance = appearance;
         self
     }
 
-    /// Set the bordered for the input, default: true
-    pub fn bordered(mut self, bordered: bool) -> Self {
-        self.bordered = bordered;
-        self
-    }
-
-    /// Set focus border for the input, default is true.
-    pub fn focus_bordered(mut self, bordered: bool) -> Self {
-        self.focus_bordered = bordered;
-        self
-    }
-
     /// Set true to show the clear button when the input field is not empty.
     pub fn cleanable(mut self) -> Self {
         self.cleanable = true;
@@ -112,6 +99,15 @@ impl TextInput {
         self
     }
 
+    /// Set true to not use gap between input and prefix, suffix, and clear button.
+    ///
+    /// Default: false
+    #[allow(dead_code)]
+    pub(super) fn no_gap(mut self) -> Self {
+        self.no_gap = true;
+        self
+    }
+
     fn render_toggle_mask_button(state: Entity<InputState>) -> impl IntoElement {
         Button::new("toggle-mask")
             .icon(IconName::Eye)
@@ -136,51 +132,44 @@ impl TextInput {
     }
 }
 
-impl Styled for TextInput {
-    fn style(&mut self) -> &mut StyleRefinement {
-        &mut self.style
-    }
-}
-
 impl RenderOnce for TextInput {
     fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
         const LINE_HEIGHT: Rems = Rems(1.25);
-        let font = window.text_style().font();
-        let font_size = window.text_style().font_size.to_pixels(window.rem_size());
 
-        self.state.update(cx, |state, cx| {
-            state.text_wrapper.set_font(font, font_size, cx);
+        self.state.update(cx, |state, _| {
+            state.mode.set_height(self.height);
             state.disabled = self.disabled;
         });
 
         let state = self.state.read(cx);
+        let focused = state.focus_handle.is_focused(window);
 
-        let gap_x = match self.size {
+        let mut gap_x = match self.size {
             Size::Small => px(4.),
             Size::Large => px(8.),
             _ => px(4.),
         };
 
+        if self.no_gap {
+            gap_x = px(0.);
+        }
+
+        let prefix = self.prefix;
+        let suffix = self.suffix;
+
+        let show_clear_button =
+            self.cleanable && !state.loading && !state.text.is_empty() && state.is_single_line();
+
         let bg = if state.disabled {
             cx.theme().surface_background
         } else {
             cx.theme().elevated_surface_background
         };
 
-        let prefix = self.prefix;
-        let suffix = self.suffix;
-
-        let show_clear_button = self.cleanable
-            && !state.loading
-            && !state.text.is_empty()
-            && state.mode.is_single_line();
-
-        let has_suffix = suffix.is_some() || state.loading || self.mask_toggle || show_clear_button;
-
         div()
             .id(("input", self.state.entity_id()))
             .flex()
-            .key_context(CONTEXT)
+            .key_context(crate::input::CONTEXT)
             .track_focus(&state.focus_handle)
             .when(!state.disabled, |this| {
                 this.on_action(window.listener_for(&self.state, InputState::backspace))
@@ -193,31 +182,17 @@ impl RenderOnce for TextInput {
                     .on_action(window.listener_for(&self.state, InputState::delete_next_word))
                     .on_action(window.listener_for(&self.state, InputState::enter))
                     .on_action(window.listener_for(&self.state, InputState::escape))
-                    .on_action(window.listener_for(&self.state, InputState::paste))
-                    .on_action(window.listener_for(&self.state, InputState::cut))
-                    .on_action(window.listener_for(&self.state, InputState::undo))
-                    .on_action(window.listener_for(&self.state, InputState::redo))
-                    .when(state.mode.is_multi_line(), |this| {
-                        this.on_action(window.listener_for(&self.state, InputState::indent_inline))
-                            .on_action(window.listener_for(&self.state, InputState::outdent_inline))
-                            .on_action(window.listener_for(&self.state, InputState::indent_block))
-                            .on_action(window.listener_for(&self.state, InputState::outdent_block))
-                            .on_action(
-                                window.listener_for(&self.state, InputState::shift_to_new_line),
-                            )
-                    })
             })
             .on_action(window.listener_for(&self.state, InputState::left))
             .on_action(window.listener_for(&self.state, InputState::right))
             .on_action(window.listener_for(&self.state, InputState::select_left))
             .on_action(window.listener_for(&self.state, InputState::select_right))
-            .when(state.mode.is_multi_line(), |this| {
+            .when(state.is_multi_line(), |this| {
                 this.on_action(window.listener_for(&self.state, InputState::up))
                     .on_action(window.listener_for(&self.state, InputState::down))
                     .on_action(window.listener_for(&self.state, InputState::select_up))
                     .on_action(window.listener_for(&self.state, InputState::select_down))
-                    .on_action(window.listener_for(&self.state, InputState::page_up))
-                    .on_action(window.listener_for(&self.state, InputState::page_down))
+                    .on_action(window.listener_for(&self.state, InputState::shift_to_new_line))
             })
             .on_action(window.listener_for(&self.state, InputState::select_all))
             .on_action(window.listener_for(&self.state, InputState::select_to_start_of_line))
@@ -234,69 +209,90 @@ impl RenderOnce for TextInput {
             .on_action(window.listener_for(&self.state, InputState::select_to_end))
             .on_action(window.listener_for(&self.state, InputState::show_character_palette))
             .on_action(window.listener_for(&self.state, InputState::copy))
+            .on_action(window.listener_for(&self.state, InputState::paste))
+            .on_action(window.listener_for(&self.state, InputState::cut))
+            .on_action(window.listener_for(&self.state, InputState::undo))
+            .on_action(window.listener_for(&self.state, InputState::redo))
             .on_key_down(window.listener_for(&self.state, InputState::on_key_down))
             .on_mouse_down(
                 MouseButton::Left,
                 window.listener_for(&self.state, InputState::on_mouse_down),
             )
             .on_mouse_down(
-                MouseButton::Right,
+                MouseButton::Middle,
                 window.listener_for(&self.state, InputState::on_mouse_down),
             )
             .on_mouse_up(
                 MouseButton::Left,
                 window.listener_for(&self.state, InputState::on_mouse_up),
             )
-            .on_mouse_up(
-                MouseButton::Right,
-                window.listener_for(&self.state, InputState::on_mouse_up),
-            )
             .on_scroll_wheel(window.listener_for(&self.state, InputState::on_scroll_wheel))
             .size_full()
             .line_height(LINE_HEIGHT)
-            .input_px(self.size)
+            .cursor_text()
             .input_py(self.size)
             .input_h(self.size)
-            .cursor_text()
-            .text_size(font_size)
-            .items_center()
-            .when(state.mode.is_multi_line(), |this| {
+            .when(state.is_multi_line(), |this| {
                 this.h_auto()
                     .when_some(self.height, |this, height| this.h(height))
             })
             .when(self.appearance, |this| {
-                this.bg(bg).rounded(cx.theme().radius)
+                this.bg(bg)
+                    .rounded(cx.theme().radius)
+                    .when(focused, |this| this.border_color(cx.theme().ring))
             })
+            .when(prefix.is_none(), |this| this.input_pl(self.size))
+            .input_pr(self.size)
             .items_center()
             .gap(gap_x)
-            .refine_style(&self.style)
             .children(prefix)
+            // TODO: Define height here, and use it in the input element
             .child(self.state.clone())
-            .when(has_suffix, |this| {
-                this.pr_2().child(
-                    h_flex()
-                        .id("suffix")
-                        .gap(gap_x)
-                        .when(self.appearance, |this| this.bg(bg))
-                        .items_center()
-                        .when(state.loading, |this| {
-                            this.child(Indicator::new().color(cx.theme().text_muted))
-                        })
-                        .when(self.mask_toggle, |this| {
-                            this.child(Self::render_toggle_mask_button(self.state.clone()))
-                        })
-                        .when(show_clear_button, |this| {
-                            this.child(clear_button(cx).on_click({
-                                let state = self.state.clone();
-                                move |_, window, cx| {
-                                    state.update(cx, |state, cx| {
-                                        state.clean(window, cx);
-                                    })
-                                }
-                            }))
-                        })
-                        .children(suffix),
-                )
+            .child(
+                h_flex()
+                    .id("suffix")
+                    .absolute()
+                    .gap(gap_x)
+                    .when(self.appearance, |this| this.bg(bg))
+                    .items_center()
+                    .when(suffix.is_none(), |this| this.pr_1())
+                    .right_0()
+                    .when(state.loading, |this| {
+                        this.child(Indicator::new().color(cx.theme().text_muted))
+                    })
+                    .when(self.mask_toggle, |this| {
+                        this.child(Self::render_toggle_mask_button(self.state.clone()))
+                    })
+                    .when(show_clear_button, |this| {
+                        this.child(clear_button(cx).on_click({
+                            let state = self.state.clone();
+                            move |_, window, cx| {
+                                state.update(cx, |state, cx| {
+                                    state.clean(window, cx);
+                                })
+                            }
+                        }))
+                    })
+                    .children(suffix),
+            )
+            .when(state.is_multi_line(), |this| {
+                if state.last_layout.is_some() {
+                    this.relative().child(
+                        div()
+                            .absolute()
+                            .top_0()
+                            .left_0()
+                            .right(px(1.))
+                            .bottom_0()
+                            .child(
+                                Scrollbar::vertical(&state.scrollbar_state, &state.scroll_handle)
+                                    .axis(ScrollbarAxis::Vertical),
+                            ),
+                    )
+                } else {
+                    this
+                }
             })
+            .refine_style(&self.style)
     }
 }

crates/ui/src/input/text_wrapper.rs

@@ -1,215 +1,99 @@
-use std::ops::Range;
-
-use gpui::{App, Font, LineFragment, Pixels};
-use rope::Rope;
-
-use super::rope_ext::RopeExt;
-
-/// A line with soft wrapped lines info.
-#[derive(Clone)]
-pub(super) struct LineItem {
-    /// The original line text.
-    line: Rope,
-    /// The soft wrapped lines relative byte range (0..line.len) of this line (Include first line).
-    ///
-    /// FIXME: Here in somecase, the `line_wrapper.wrap_line` has returned different
-    /// like the `window.text_system().shape_text`. So, this value may not equal
-    /// the actual rendered lines.
-    wrapped_lines: Vec<Range<usize>>,
-}
-
-impl LineItem {
-    /// Get the bytes length of this line.
-    #[inline]
-    pub(super) fn len(&self) -> usize {
-        self.line.len()
-    }
-
-    /// Get number of soft wrapped lines of this line (include the first line).
-    #[inline]
-    pub(super) fn lines_len(&self) -> usize {
-        self.wrapped_lines.len()
-    }
-
-    /// Get the height of this line item with given line height.
-    pub(super) fn height(&self, line_height: Pixels) -> Pixels {
-        self.lines_len() as f32 * line_height
-    }
-}
-
-/// Used to prepare the text with soft wrap to be get lines to displayed in the Editor.
-///
-/// After use lines to calculate the scroll size of the Editor.
-pub(super) struct TextWrapper {
-    text: Rope,
-    /// Total wrapped lines (Inlucde the first line), value is start and end index of the line.
-    soft_lines: usize,
-    font: Font,
-    font_size: Pixels,
-    /// If is none, it means the text is not wrapped
-    wrap_width: Option<Pixels>,
-    /// The lines by split \n
-    pub(super) lines: Vec<LineItem>,
-}
-
-#[allow(unused)]
-impl TextWrapper {
-    pub(super) fn new(font: Font, font_size: Pixels, wrap_width: Option<Pixels>) -> Self {
-        Self {
-            text: Rope::new(),
-            font,
-            font_size,
-            wrap_width,
-            soft_lines: 0,
-            lines: Vec::new(),
-        }
-    }
-
-    #[inline]
-    pub(super) fn set_default_text(&mut self, text: &Rope) {
-        self.text = text.clone();
-    }
-
-    /// Get the total number of lines including wrapped lines.
-    #[inline]
-    pub(super) fn len(&self) -> usize {
-        self.soft_lines
-    }
-
-    /// Get the line item by row index.
-    #[inline]
-    pub(super) fn line(&self, row: usize) -> Option<&LineItem> {
-        self.lines.get(row)
-    }
-
-    pub(super) fn set_wrap_width(&mut self, wrap_width: Option<Pixels>, cx: &mut App) {
-        if wrap_width == self.wrap_width {
-            return;
-        }
-
-        self.wrap_width = wrap_width;
-        self.update_all(&self.text.clone(), true, cx);
-    }
-
-    pub(super) fn set_font(&mut self, font: Font, font_size: Pixels, cx: &mut App) {
-        if self.font.eq(&font) && self.font_size == font_size {
-            return;
-        }
-
-        self.font = font;
-        self.font_size = font_size;
-        self.update_all(&self.text.clone(), true, cx);
-    }
-
-    /// Update the text wrapper and recalculate the wrapped lines.
-    ///
-    /// If the `text` is the same as the current text, do nothing.
-    ///
-    /// - `changed_text`: The text [`Rope`] that has changed.
-    /// - `range`: The `selected_range` before change.
-    /// - `new_text`: The inserted text.
-    /// - `force`: Whether to force the update, if false, the update will be skipped if the text is the same.
-    /// - `cx`: The application context.
-    pub(super) fn update(
-        &mut self,
-        changed_text: &Rope,
-        range: &Range<usize>,
-        new_text: &Rope,
-        force: bool,
-        cx: &mut App,
-    ) {
-        let mut line_wrapper = cx
-            .text_system()
-            .line_wrapper(self.font.clone(), self.font_size);
-        self._update(
-            changed_text,
-            range,
-            new_text,
-            force,
-            &mut |line_str, wrap_width| {
-                line_wrapper
-                    .wrap_line(&[LineFragment::text(line_str)], wrap_width)
-                    .collect()
-            },
-        );
-    }
-
-    fn _update<F>(
-        &mut self,
-        changed_text: &Rope,
-        range: &Range<usize>,
-        new_text: &Rope,
-        force: bool,
-        wrap_line: &mut F,
-    ) where
-        F: FnMut(&str, Pixels) -> Vec<gpui::Boundary>,
-    {
-        if self.text.eq(changed_text) && !force {
-            return;
-        }
-
-        // Remove the old changed lines.
-        let start_row = self.text.offset_to_point(range.start).row as usize;
-        let start_row = start_row.min(self.lines.len().saturating_sub(1));
-        let end_row = self.text.offset_to_point(range.end).row as usize;
-        let end_row = end_row.min(self.lines.len().saturating_sub(1));
-        let rows_range = start_row..=end_row;
-
-        // To add the new lines.
-        let new_start_row = changed_text.offset_to_point(range.start).row as usize;
-        let new_start_offset = changed_text.line_start_offset(new_start_row);
-        let new_end_row = changed_text
-            .offset_to_point(range.start + new_text.len())
-            .row as usize;
-        let new_end_offset = changed_text.line_end_offset(new_end_row);
-        let new_range = new_start_offset..new_end_offset;
-
-        let mut new_lines = vec![];
-
-        let wrap_width = self.wrap_width;
-
-        for line in changed_text.slice(new_range).lines() {
-            let line_str = line.to_string();
-            let mut wrapped_lines = vec![];
-            let mut prev_boundary_ix = 0;
-
-            // If wrap_width is Pixels::MAX, skip wrapping to disable word wrap
-            if let Some(wrap_width) = wrap_width {
-                // Here only have wrapped line, if there is no wrap meet, the `line_wraps` result will empty.
-                for boundary in wrap_line(&line_str, wrap_width) {
-                    wrapped_lines.push(prev_boundary_ix..boundary.ix);
-                    prev_boundary_ix = boundary.ix;
-                }
-            }
-
-            // Reset of the line
-            if !line_str[prev_boundary_ix..].is_empty() || prev_boundary_ix == 0 {
-                wrapped_lines.push(prev_boundary_ix..line.len());
-            }
-
-            new_lines.push(LineItem {
-                line: line.clone(),
-                wrapped_lines,
-            });
-        }
-
-        // dbg!(&new_lines.len());
-        // dbg!(self.lines.len());
-        if self.lines.is_empty() {
-            self.lines = new_lines;
-        } else {
-            self.lines.splice(rows_range, new_lines);
-        }
-
-        // dbg!(self.lines.len());
-        self.text = changed_text.clone();
-        self.soft_lines = self.lines.iter().map(|l| l.lines_len()).sum();
-    }
-
-    /// Update the text wrapper and recalculate the wrapped lines.
-    ///
-    /// If the `text` is the same as the current text, do nothing.
-    pub(crate) fn update_all(&mut self, text: &Rope, force: bool, cx: &mut App) {
-        self.update(text, &(0..text.len()), text, force, cx);
-    }
-}
+use std::ops::Range;
+
+use gpui::{App, Font, LineFragment, Pixels, SharedString};
+
+#[allow(unused)]
+pub(super) struct LineWrap {
+    /// The number of soft wrapped lines of this line (Not include first line.)
+    pub(super) wrap_lines: usize,
+    /// The range of the line text in the entire text.
+    pub(super) range: Range<usize>,
+}
+
+impl LineWrap {
+    pub(super) fn height(&self, line_height: Pixels) -> Pixels {
+        line_height * (self.wrap_lines + 1)
+    }
+}
+
+/// Used to prepare the text with soft_wrap to be get lines to displayed in the TextArea
+///
+/// After use lines to calculate the scroll size of the TextArea
+pub(super) struct TextWrapper {
+    pub(super) text: SharedString,
+    /// The wrapped lines, value is start and end index of the line (by split \n).
+    pub(super) wrapped_lines: Vec<Range<usize>>,
+    /// The lines by split \n
+    pub(super) lines: Vec<LineWrap>,
+    pub(super) font: Font,
+    pub(super) font_size: Pixels,
+    /// If is none, it means the text is not wrapped
+    pub(super) wrap_width: Option<Pixels>,
+}
+
+#[allow(unused)]
+impl TextWrapper {
+    pub(super) fn new(font: Font, font_size: Pixels, wrap_width: Option<Pixels>) -> Self {
+        Self {
+            text: SharedString::default(),
+            font,
+            font_size,
+            wrap_width,
+            wrapped_lines: Vec::new(),
+            lines: Vec::new(),
+        }
+    }
+
+    pub(super) fn set_wrap_width(&mut self, wrap_width: Option<Pixels>, cx: &mut App) {
+        self.wrap_width = wrap_width;
+        self.update(&self.text.clone(), true, cx);
+    }
+
+    pub(super) fn set_font(&mut self, font: Font, font_size: Pixels, cx: &mut App) {
+        self.font = font;
+        self.font_size = font_size;
+        self.update(&self.text.clone(), true, cx);
+    }
+
+    pub(super) fn update(&mut self, text: &SharedString, force: bool, cx: &mut App) {
+        if &self.text == text && !force {
+            return;
+        }
+
+        let mut wrapped_lines = vec![];
+        let mut lines = vec![];
+        let wrap_width = self.wrap_width.unwrap_or(Pixels::MAX);
+        let mut line_wrapper = cx
+            .text_system()
+            .line_wrapper(self.font.clone(), self.font_size);
+
+        let mut prev_line_ix = 0;
+        for line in text.split('\n') {
+            let mut line_wraps = vec![];
+            let mut prev_boundary_ix = 0;
+
+            // Here only have wrapped line, if there is no wrap meet, the `line_wraps` result will empty.
+            for boundary in line_wrapper.wrap_line(&[LineFragment::text(line)], wrap_width) {
+                line_wraps.push(prev_boundary_ix..boundary.ix);
+                prev_boundary_ix = boundary.ix;
+            }
+
+            lines.push(LineWrap {
+                wrap_lines: line_wraps.len(),
+                range: prev_line_ix..prev_line_ix + line.len(),
+            });
+
+            wrapped_lines.extend(line_wraps);
+            // Reset of the line
+            if !line[prev_boundary_ix..].is_empty() || prev_boundary_ix == 0 {
+                wrapped_lines.push(prev_line_ix + prev_boundary_ix..prev_line_ix + line.len());
+            }
+
+            prev_line_ix += line.len() + 1;
+        }
+
+        self.text = text.clone();
+        self.wrapped_lines = wrapped_lines;
+        self.lines = lines;
+    }
+}

crates/ui/src/list/list.rs

@@ -299,16 +299,14 @@ where
 
     fn on_query_input_event(
         &mut self,
-        state: &Entity<InputState>,
+        _: &Entity<InputState>,
         event: &InputEvent,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
         match event {
-            InputEvent::Change => {
-                let text = state.read(cx).value();
+            InputEvent::Change(text) => {
                 let text = text.trim().to_string();
-
                 if Some(&text) == self.last_query.as_ref() {
                     return;
                 }
@@ -349,7 +347,7 @@ where
         }
     }
 
-    fn set_querying(&mut self, querying: bool, _window: &mut Window, cx: &mut Context<Self>) {
+    fn set_querying(&mut self, querying: bool, _: &mut Window, cx: &mut Context<Self>) {
         self.querying = querying;
         if let Some(input) = &self.query_input {
             input.update(cx, |input, cx| input.set_loading(querying, cx))

crates/ui/src/resizable/panel.rs

@@ -405,14 +405,13 @@ impl Render for ResizablePanel {
             return div();
         }
 
+        let view = cx.entity().clone();
         let total_size = self
             .group
             .as_ref()
             .and_then(|group| group.upgrade())
             .map(|group| group.read(cx).total_size());
 
-        let view = cx.entity();
-
         div()
             .flex()
             .flex_grow()

crates/ui/src/root.rs

@@ -194,7 +194,7 @@ impl Root {
         }
     }
 
-    /// Render Notification layer.
+    // Render Notification layer.
     pub fn render_notification_layer(
         window: &mut Window,
         cx: &mut App,

crates/ui/src/text.rs

@@ -1,7 +1,7 @@
 use std::ops::Range;
 use std::sync::Arc;
 
-use common::display::RenderedProfile;
+use common::display::ReadableProfile;
 use gpui::{
     AnyElement, AnyView, App, ElementId, HighlightStyle, InteractiveText, IntoElement,
     SharedString, StyledText, UnderlineStyle, Window,
@@ -13,7 +13,7 @@ use regex::Regex;
 use registry::Registry;
 use theme::ActiveTheme;
 
-use crate::actions::OpenPublicKey;
+use crate::actions::OpenProfile;
 
 static URL_REGEX: Lazy<Regex> = Lazy::new(|| {
     Regex::new(r"^(?:[a-zA-Z]+://)?([a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}(:\d+)?(/.*)?$").unwrap()
@@ -140,7 +140,7 @@ impl RenderedText {
                         log::error!("Failed to parse public key from: {clean_url}");
                         return;
                     };
-                    window.dispatch_action(Box::new(OpenPublicKey(public_key)), cx);
+                    window.dispatch_action(Box::new(OpenProfile(public_key)), cx);
                 } else if is_url(token) {
                     if !token.starts_with("http") {
                         cx.open_url(&format!("https://{token}"));

locales/app.yml

@@ -51,8 +51,6 @@ common:
     en: "Recommended:"
   resend:
     en: "Resend"
-  seen_on:
-    en: "Seen on"
 
 auto_update:
   updating:
@@ -272,11 +270,9 @@ profile:
   unknown:
     en: "Unknown contact"
   njump:
-    en: "View on njump.me"
+    en: "Open in njump.me"
   no_bio:
     en: "No bio."
-  copy:
-    en: "Copy Public Key"
 
 preferences:
   account_header:
@@ -317,6 +313,10 @@ preferences:
     en: "Display"
 
 compose:
+  placeholder_npub:
+    en: "npub or nprofile..."
+  placeholder_title:
+    en: "Family...(Optional)"
   create_dm_button:
     en: "Create DM"
   creating_dm_button:
@@ -399,14 +399,6 @@ sidebar:
     en: "Incoming new conversations"
   trusted_contacts_tooltip:
     en: "Only show rooms from trusted contacts"
-  no_requests:
-    en: "No message requests"
-  no_requests_label:
-    en: "New message requests from people you don't know will appear here."
-  no_conversations:
-    en: "No conversations"
-  no_conversations_label:
-    en: "Start a conversation with someone to get started."
 
 loading:
   label:

script/release

@@ -1,79 +0,0 @@
-#!/bin/bash
-
-# Script to release a new version of the application
-# Usage: ./release <new_version>
-
-set -e  # Exit on any error
-
-if [ $# -ne 1 ]; then
-    echo "Usage: $0 <new_version>"
-    echo "Example: $0 1.0.0"
-    exit 1
-fi
-
-NEW_VERSION="$1"
-WORKSPACE_CARGO="Cargo.toml"
-CRATE_CARGO="crates/coop/Cargo.toml"
-
-# Check if both Cargo.toml files exist
-if [ ! -f "$WORKSPACE_CARGO" ]; then
-    echo "Error: $WORKSPACE_CARGO not found in current directory"
-    exit 1
-fi
-
-if [ ! -f "$CRATE_CARGO" ]; then
-    echo "Error: $CRATE_CARGO not found"
-    exit 1
-fi
-
-# Function to update version in a Cargo.toml file
-update_version() {
-    local file="$1"
-    local backup="${file}.bak"
-
-    # Backup the original file
-    cp "$file" "$backup"
-
-    # Replace the version in Cargo.toml
-    if sed -i.bak -E "s/^version = \"[0-9]+\.[0-9]+\.[0-9]+\"/version = \"$NEW_VERSION\"/" "$file"; then
-        echo "✓ Updated version to $NEW_VERSION in $file"
-        # Remove backup created by sed
-        if [ -f "${file}.bak" ]; then
-            rm "${file}.bak"
-        fi
-    else
-        echo "Error: Failed to update version in $file"
-        # Restore original backup
-        mv "$backup" "$file"
-        exit 1
-    fi
-
-    # Remove the initial backup file
-    rm -f "$backup"
-}
-
-# Update both Cargo.toml files
-echo "Updating versions..."
-update_version "$WORKSPACE_CARGO"
-update_version "$CRATE_CARGO"
-
-# Create git tag
-TAG_NAME="v$NEW_VERSION"
-COMMIT_MSG="Release version $NEW_VERSION"
-
-if git tag -a "$TAG_NAME" -m "$COMMIT_MSG"; then
-    echo "✓ Created git tag: $TAG_NAME"
-else
-    echo "Error: Failed to create git tag"
-    exit 1
-fi
-
-# Push to origin (both commits and tags)
-echo "Pushing to origin..."
-if git push origin master && git push origin "$TAG_NAME"; then
-    echo "✓ Successfully pushed to origin"
-    echo "✓ Release $NEW_VERSION completed successfully!"
-else
-    echo "Error: Failed to push to origin"
-    exit 1
-fi