Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

extensions_ui: Show installed extensions when offline (#64766)

Finn Evers8da42ddee309
diff --git a/crates/extension_host/src/extension_host.rs b/crates/extension_host/src/extension_host.rs
index 36dd2943c45..0b8da455e6a 100644
--- a/crates/extension_host/src/extension_host.rs
+++ b/crates/extension_host/src/extension_host.rs
@@ -197,6 +197,15 @@ pub enum ExtensionOperation {
Remove,
}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ExtensionStatus {
+ NotInstalled,
+ Installing,
+ Upgrading,
+ Installed(Arc<str>),
+ Removing,
+}
+
#[derive(Clone)]
pub enum Event {
ExtensionsUpdated,
@@ -560,6 +569,27 @@ impl ExtensionStore {
&self.extension_index.extensions
}
+ /// Returns the status of the extension, where outstanding operations take
+ /// precedence over the installed state.
+ pub fn extension_status(&self, extension_id: &str) -> ExtensionStatus {
+ match self.outstanding_operations.get(extension_id) {
+ Some(ExtensionOperation::Install) => ExtensionStatus::Installing,
+ Some(ExtensionOperation::Remove) => ExtensionStatus::Removing,
+ Some(ExtensionOperation::Upgrade) => ExtensionStatus::Upgrading,
+ None => match self.extension_index.extensions.get(extension_id) {
+ Some(extension) => ExtensionStatus::Installed(extension.manifest.version.clone()),
+ None => ExtensionStatus::NotInstalled,
+ },
+ }
+ }
+
+ pub fn is_dev_extension(&self, extension_id: &str) -> bool {
+ self.extension_index
+ .extensions
+ .get(extension_id)
+ .is_some_and(|extension| extension.dev)
+ }
+
pub fn dev_extensions(&self) -> impl Iterator<Item = &Arc<ExtensionManifest>> {
self.extension_index
.extensions
diff --git a/crates/extensions_ui/src/components.rs b/crates/extensions_ui/src/components.rs
index 92f9c3cdfed..bfe081f1993 100644
--- a/crates/extensions_ui/src/components.rs
+++ b/crates/extensions_ui/src/components.rs
@@ -1,4 +1,4 @@
mod extension_card;
pub use extension_card::ExtensionCard;
-pub(crate) use extension_card::{extension_provides_label, remote_extension_status};
+pub(crate) use extension_card::extension_provides_label;
diff --git a/crates/extensions_ui/src/components/extension_card.rs b/crates/extensions_ui/src/components/extension_card.rs
index ce74c0cc888..5a117b742af 100644
--- a/crates/extensions_ui/src/components/extension_card.rs
+++ b/crates/extensions_ui/src/components/extension_card.rs
@@ -2,7 +2,7 @@ use std::{collections::BTreeSet, sync::Arc};
use cloud_api_types::{ExtensionApiManifest, ExtensionMetadata, ExtensionProvides};
use extension::{ExtensionManifest, SchemaVersion};
-use extension_host::{ExtensionOperation, ExtensionStore};
+use extension_host::{ExtensionOperation, ExtensionStatus, ExtensionStore};
use gpui::{Anchor, ElementId, Entity, Point, SharedString, prelude::*};
use num_format::{Locale, ToFormattedString};
use release_channel::ReleaseChannel;
@@ -13,52 +13,31 @@ type ContextMenuBuilder = Box<
>;
type ExtensionCardActions = [Option<Button>; 3];
-fn extension_status(extension_id: &str, extension_store: &ExtensionStore) -> ExtensionStatus {
- match extension_store.outstanding_operations().get(extension_id) {
- Some(ExtensionOperation::Install) => ExtensionStatus::Installing,
- Some(ExtensionOperation::Remove) => ExtensionStatus::Removing,
- Some(ExtensionOperation::Upgrade) => ExtensionStatus::Upgrading,
- None => match extension_store.installed_extensions().get(extension_id) {
- Some(extension) => ExtensionStatus::Installed(extension.manifest.version.clone()),
- None => ExtensionStatus::NotInstalled,
- },
- }
-}
-
-pub(crate) fn remote_extension_status(extension_id: &str, cx: &App) -> ExtensionStatus {
- let extension_store = ExtensionStore::global(cx).read(cx);
- if extension_store
- .installed_extensions()
- .get(extension_id)
- .is_some_and(|extension| extension.dev)
- {
- ExtensionStatus::OverriddenByDevExtension
- } else {
- extension_status(extension_id, extension_store)
- }
-}
-
+/// Local state of a published extension, derived from the `ExtensionStore`.
#[derive(Clone)]
-pub(crate) enum ExtensionStatus {
- NotInstalled,
- Installing,
- Upgrading,
- Installed(Arc<str>),
- Removing,
+enum PublishedExtensionState {
+ /// A dev extension with the same id is installed locally and takes
+ /// precedence, so the published version can't be installed or managed.
+ /// This replaces the store status, which would describe the dev extension.
OverriddenByDevExtension,
+ /// Managed by the store like any other extension.
+ Store(ExtensionStatus),
}
-impl ExtensionStatus {
- pub fn disables_actions(&self) -> bool {
- matches!(
- self,
- Self::Installing | Self::Upgrading | Self::Removing | Self::OverriddenByDevExtension
- )
+impl PublishedExtensionState {
+ fn new(extension_id: &str, extension_store: &ExtensionStore) -> Self {
+ if extension_store.is_dev_extension(extension_id) {
+ Self::OverriddenByDevExtension
+ } else {
+ Self::Store(extension_store.extension_status(extension_id))
+ }
}
+}
- pub fn is_installed(&self) -> bool {
- matches!(self, Self::Installed(_) | Self::Upgrading | Self::Removing)
- }
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum LocalExtensionKind {
+ Dev,
+ Installed,
}
struct ExtensionCardDetails {
@@ -76,8 +55,9 @@ struct ExtensionCardDetails {
#[derive(Clone)]
enum ExtensionCardSource {
Dev,
+ Installed,
Remote {
- status: ExtensionStatus,
+ state: PublishedExtensionState,
download_count: u64,
},
}
@@ -86,7 +66,7 @@ impl ExtensionCardSource {
fn installed_version(&self, latest_version: &Arc<str>) -> Option<Arc<str>> {
match self {
Self::Remote {
- status: ExtensionStatus::Installed(installed_version),
+ state: PublishedExtensionState::Store(ExtensionStatus::Installed(installed_version)),
..
} if installed_version != latest_version => Some(installed_version.clone()),
_ => None,
@@ -96,7 +76,7 @@ impl ExtensionCardSource {
fn download_count(&self) -> Option<u64> {
match self {
Self::Remote { download_count, .. } => Some(*download_count),
- Self::Dev => None,
+ Self::Dev | Self::Installed => None,
}
}
@@ -108,7 +88,7 @@ impl ExtensionCardSource {
matches!(
self,
Self::Remote {
- status: ExtensionStatus::OverriddenByDevExtension,
+ state: PublishedExtensionState::OverriddenByDevExtension,
..
}
)
@@ -123,22 +103,34 @@ pub struct ExtensionCard {
}
impl ExtensionCard {
- pub fn for_dev(extension: Arc<ExtensionManifest>, cx: &App) -> Self {
- let extension_store = ExtensionStore::global(cx).read(cx);
- let status = extension_status(&extension.id, extension_store);
- Self::dev::<true>(extension, status)
+ pub fn for_dev(extension: Arc<ExtensionManifest>, extension_store: &ExtensionStore) -> Self {
+ let status = extension_store.extension_status(&extension.id);
+ Self::manifest(extension, status, LocalExtensionKind::Dev)
+ }
+
+ pub fn for_installed(
+ extension: Arc<ExtensionManifest>,
+ extension_store: &ExtensionStore,
+ ) -> Self {
+ let status = extension_store.extension_status(&extension.id);
+ Self::manifest(extension, status, LocalExtensionKind::Installed)
}
- pub fn for_remote(extension: &ExtensionMetadata, cx: &App) -> Self {
- let status = remote_extension_status(&extension.id, cx);
- Self::remote::<true>(extension, status, cx)
+ pub fn for_remote(
+ extension: &ExtensionMetadata,
+ extension_store: &ExtensionStore,
+ cx: &App,
+ ) -> Self {
+ let state = PublishedExtensionState::new(&extension.id, extension_store);
+ Self::remote(extension, state, cx)
}
- fn dev<const ENABLE_HANDLERS: bool>(
+ fn manifest(
extension: Arc<ExtensionManifest>,
status: ExtensionStatus,
+ kind: LocalExtensionKind,
) -> Self {
- let actions = Self::actions_for_dev_extension::<ENABLE_HANDLERS>(&extension, &status);
+ let actions = Self::actions_for_manifest_extension(&extension, &status, kind);
let details = ExtensionCardDetails {
id: extension.id.clone(),
name: extension.name.clone().into(),
@@ -148,7 +140,10 @@ impl ExtensionCard {
repository_url: extension.repository.clone().map(Into::into),
repository_icon: IconName::Link,
provided_features: provided_feature_labels(extension.provides()),
- source: ExtensionCardSource::Dev,
+ source: match kind {
+ LocalExtensionKind::Dev => ExtensionCardSource::Dev,
+ LocalExtensionKind::Installed => ExtensionCardSource::Installed,
+ },
};
Self {
@@ -158,12 +153,8 @@ impl ExtensionCard {
}
}
- fn remote<const ENABLE_HANDLERS: bool>(
- extension: &ExtensionMetadata,
- status: ExtensionStatus,
- cx: &App,
- ) -> Self {
- let actions = Self::actions_for_remote_extension::<ENABLE_HANDLERS>(extension, &status, cx);
+ fn remote(extension: &ExtensionMetadata, state: PublishedExtensionState, cx: &App) -> Self {
+ let actions = Self::actions_for_remote_extension(extension, &state, cx);
let details = ExtensionCardDetails {
id: extension.id.clone(),
name: extension.manifest.name.clone().into(),
@@ -174,7 +165,7 @@ impl ExtensionCard {
repository_icon: IconName::Link,
provided_features: provided_feature_labels(extension.manifest.provides.iter().copied()),
source: ExtensionCardSource::Remote {
- status,
+ state,
download_count: extension.download_count,
},
};
@@ -186,36 +177,40 @@ impl ExtensionCard {
}
}
+ fn disables_actions(status: &ExtensionStatus) -> bool {
+ match status {
+ ExtensionStatus::Installing
+ | ExtensionStatus::Upgrading
+ | ExtensionStatus::Removing => true,
+ ExtensionStatus::NotInstalled | ExtensionStatus::Installed(_) => false,
+ }
+ }
+
fn button_id(extension_id: &Arc<str>, operation: ExtensionOperation) -> ElementId {
(SharedString::from(extension_id.clone()), operation as usize).into()
}
- fn uninstall_button<const ENABLE_HANDLERS: bool>(
- extension_id: &Arc<str>,
- is_dev: bool,
- ) -> Button {
+ fn uninstall_button(extension_id: &Arc<str>, is_dev: bool) -> Button {
Button::new(
Self::button_id(extension_id, ExtensionOperation::Remove),
"Uninstall",
)
- .when(ENABLE_HANDLERS, |button| {
- button.on_click({
- let extension_id = extension_id.clone();
- move |_, _, cx| {
- if !is_dev {
- telemetry::event!("Extension Uninstalled", extension_id);
- }
- ExtensionStore::global(cx).update(cx, |store, cx| {
- store
- .uninstall_extension(extension_id.clone(), cx)
- .detach_and_log_err(cx);
- });
+ .on_click({
+ let extension_id = extension_id.clone();
+ move |_, _, cx| {
+ if !is_dev {
+ telemetry::event!("Extension Uninstalled", extension_id);
}
- })
+ ExtensionStore::global(cx).update(cx, |store, cx| {
+ store
+ .uninstall_extension(extension_id.clone(), cx)
+ .detach_and_log_err(cx);
+ });
+ }
})
}
- fn configure_button<const ENABLE_HANDLERS: bool>(
+ fn configure_button(
extension_id: &Arc<str>,
manifest: Option<Arc<ExtensionManifest>>,
) -> Button {
@@ -223,40 +218,40 @@ impl ExtensionCard {
SharedString::from(format!("configure-{extension_id}")),
"Configure",
)
- .when(ENABLE_HANDLERS, |button| {
- button.on_click({
- let extension_id = extension_id.clone();
- move |_, _, cx| {
- let manifest = manifest.clone().or_else(|| {
- ExtensionStore::global(cx)
- .read(cx)
- .extension_manifest_for_id(&extension_id)
- .cloned()
+ .on_click({
+ let extension_id = extension_id.clone();
+ move |_, _, cx| {
+ let manifest = manifest.clone().or_else(|| {
+ ExtensionStore::global(cx)
+ .read(cx)
+ .extension_manifest_for_id(&extension_id)
+ .cloned()
+ });
+ if let Some(manifest) = manifest
+ && let Some(events) = extension::ExtensionEvents::try_global(cx)
+ {
+ events.update(cx, |this, cx| {
+ this.emit(extension::Event::ConfigureExtensionRequested(manifest), cx)
});
- if let Some(manifest) = manifest
- && let Some(events) = extension::ExtensionEvents::try_global(cx)
- {
- events.update(cx, |this, cx| {
- this.emit(extension::Event::ConfigureExtensionRequested(manifest), cx)
- });
- }
}
- })
+ }
})
}
- fn actions_for_dev_extension<const ENABLE_HANDLERS: bool>(
+ fn actions_for_manifest_extension(
extension: &Arc<ExtensionManifest>,
status: &ExtensionStatus,
+ kind: LocalExtensionKind,
) -> ExtensionCardActions {
- let rebuild = Button::new(
- SharedString::from(format!("rebuild-{}", extension.id)),
- "Rebuild",
- )
- .color(Color::Accent)
- .disabled(status.disables_actions())
- .when(ENABLE_HANDLERS, |button| {
- button.on_click({
+ let is_dev = kind == LocalExtensionKind::Dev;
+ let rebuild = is_dev.then(|| {
+ Button::new(
+ SharedString::from(format!("rebuild-{}", extension.id)),
+ "Rebuild",
+ )
+ .color(Color::Accent)
+ .disabled(Self::disables_actions(status))
+ .on_click({
let extension_id = extension.id.clone();
move |_, _, cx| {
ExtensionStore::global(cx).update(cx, |store, cx| {
@@ -265,19 +260,31 @@ impl ExtensionCard {
}
})
});
- let uninstall = Self::uninstall_button::<ENABLE_HANDLERS>(&extension.id, true)
- .color(Color::Accent)
- .disabled(status.disables_actions());
+ let uninstall = Self::uninstall_button(&extension.id, is_dev)
+ .when_else(
+ is_dev,
+ |button| button.color(Color::Accent),
+ |button| button.style(ButtonStyle::OutlinedGhost),
+ )
+ .disabled(Self::disables_actions(status));
let configure = (!extension.context_servers.is_empty()).then(|| {
- Self::configure_button::<ENABLE_HANDLERS>(&extension.id, Some(extension.clone()))
- .color(Color::Accent)
- .disabled(status.disables_actions())
+ Self::configure_button(&extension.id, Some(extension.clone()))
+ .when_else(
+ is_dev,
+ |button| button.color(Color::Accent),
+ |button| button.style(ButtonStyle::OutlinedGhost),
+ )
+ .disabled(Self::disables_actions(status))
});
- [Some(rebuild), Some(uninstall), configure]
+ if is_dev {
+ [rebuild, Some(uninstall), configure]
+ } else {
+ [None, configure, Some(uninstall)]
+ }
}
- fn install_button<const ENABLE_HANDLERS: bool>(extension_id: &Arc<str>) -> Button {
+ fn install_button(extension_id: &Arc<str>) -> Button {
Button::new(
Self::button_id(extension_id, ExtensionOperation::Install),
"Install",
@@ -288,22 +295,20 @@ impl ExtensionCard {
.size(IconSize::Small)
.color(Color::Muted),
)
- .when(ENABLE_HANDLERS, |button| {
- button.on_click({
- let extension_id = extension_id.clone();
- move |_, _, cx| {
- telemetry::event!("Extension Installed");
- ExtensionStore::global(cx).update(cx, |store, cx| {
- store.install_latest_extension(extension_id.clone(), cx)
- });
- }
- })
+ .on_click({
+ let extension_id = extension_id.clone();
+ move |_, _, cx| {
+ telemetry::event!("Extension Installed");
+ ExtensionStore::global(cx).update(cx, |store, cx| {
+ store.install_latest_extension(extension_id.clone(), cx)
+ });
+ }
})
}
- fn actions_for_remote_extension<const ENABLE_HANDLERS: bool>(
+ fn actions_for_remote_extension(
extension: &ExtensionMetadata,
- status: &ExtensionStatus,
+ state: &PublishedExtensionState,
cx: &App,
) -> ExtensionCardActions {
let is_configurable = extension
@@ -311,38 +316,44 @@ impl ExtensionCard {
.provides
.contains(&ExtensionProvides::ContextServers);
+ let status = match state {
+ PublishedExtensionState::OverriddenByDevExtension => {
+ return [
+ None,
+ None,
+ Some(Self::install_button(&extension.id).disabled(true)),
+ ];
+ }
+ PublishedExtensionState::Store(status) => status,
+ };
+
match status {
- ExtensionStatus::OverriddenByDevExtension
- | ExtensionStatus::NotInstalled
- | ExtensionStatus::Installing => [
+ ExtensionStatus::NotInstalled | ExtensionStatus::Installing => [
None,
None,
- Some(
- Self::install_button::<ENABLE_HANDLERS>(&extension.id)
- .disabled(status.disables_actions()),
- ),
+ Some(Self::install_button(&extension.id).disabled(Self::disables_actions(status))),
],
ExtensionStatus::Upgrading | ExtensionStatus::Removing => {
- let uninstall = Self::uninstall_button::<ENABLE_HANDLERS>(&extension.id, false)
+ let uninstall = Self::uninstall_button(&extension.id, false)
.style(ButtonStyle::OutlinedGhost)
- .disabled(status.disables_actions());
+ .disabled(Self::disables_actions(status));
let upgrade = matches!(status, ExtensionStatus::Upgrading).then(|| {
Button::new(
Self::button_id(&extension.id, ExtensionOperation::Upgrade),
"Upgrade",
)
- .disabled(status.disables_actions())
+ .disabled(Self::disables_actions(status))
});
let configure = is_configurable.then(|| {
- Self::configure_button::<ENABLE_HANDLERS>(&extension.id, None)
- .disabled(status.disables_actions())
+ Self::configure_button(&extension.id, None)
+ .disabled(Self::disables_actions(status))
});
[upgrade, configure, Some(uninstall)]
}
ExtensionStatus::Installed(installed_version) => {
- let uninstall = Self::uninstall_button::<ENABLE_HANDLERS>(&extension.id, false)
- .style(ButtonStyle::OutlinedGhost);
+ let uninstall =
+ Self::uninstall_button(&extension.id, false).style(ButtonStyle::OutlinedGhost);
let upgrade = (installed_version != &extension.manifest.version).then(|| {
let is_compatible = extension_host::is_version_compatible(
ReleaseChannel::global(cx),
@@ -367,28 +378,21 @@ impl ExtensionCard {
})
})
.disabled(!is_compatible)
- .when(ENABLE_HANDLERS, |button| {
- button.on_click({
- let extension_id = extension.id.clone();
- let version = extension.manifest.version.clone();
- move |_, _, cx| {
- telemetry::event!("Extension Installed", extension_id, version);
- ExtensionStore::global(cx).update(cx, |store, cx| {
- store
- .upgrade_extension(
- extension_id.clone(),
- version.clone(),
- cx,
- )
- .detach_and_log_err(cx)
- });
- }
- })
+ .on_click({
+ let extension_id = extension.id.clone();
+ let version = extension.manifest.version.clone();
+ move |_, _, cx| {
+ telemetry::event!("Extension Installed", extension_id, version);
+ ExtensionStore::global(cx).update(cx, |store, cx| {
+ store
+ .upgrade_extension(extension_id.clone(), version.clone(), cx)
+ .detach_and_log_err(cx)
+ });
+ }
})
});
let configure = is_configurable.then(|| {
- Self::configure_button::<ENABLE_HANDLERS>(&extension.id, None)
- .style(ButtonStyle::OutlinedGhost)
+ Self::configure_button(&extension.id, None).style(ButtonStyle::OutlinedGhost)
});
[upgrade, configure, Some(uninstall)]
@@ -437,18 +441,6 @@ pub(crate) fn extension_provides_label(provides: ExtensionProvides) -> &'static
}
}
-fn preview_dev_card(extension: Arc<ExtensionManifest>, status: ExtensionStatus) -> ExtensionCard {
- ExtensionCard::dev::<false>(extension, status)
-}
-
-fn preview_remote_card(
- extension: &ExtensionMetadata,
- status: ExtensionStatus,
- cx: &App,
-) -> ExtensionCard {
- ExtensionCard::remote::<false>(extension, status, cx)
-}
-
impl Component for ExtensionCard {
fn scope() -> ComponentScope {
ComponentScope::DataDisplay
@@ -486,7 +478,8 @@ impl Component for ExtensionCard {
fn dev_extension() -> Arc<ExtensionManifest> {
Arc::new(ExtensionManifest {
- id: "preview-dev-theme".into(),
+ // Fake ID which will never be accepted during publishing
+ id: "zed-demo-theme".into(),
name: "Local Theme".to_owned(),
version: "0.1.0".into(),
schema_version: SchemaVersion::ZERO,
@@ -512,7 +505,7 @@ impl Component for ExtensionCard {
let examples = vec![
single_example(
"Available to Install",
- preview_remote_card(
+ ExtensionCard::remote(
&remote_extension(
"preview-toml",
"TOML",
@@ -521,14 +514,14 @@ impl Component for ExtensionCard {
482_391,
[ExtensionProvides::Languages],
),
- ExtensionStatus::NotInstalled,
+ PublishedExtensionState::Store(ExtensionStatus::NotInstalled),
cx,
)
.into_any_element(),
),
single_example(
"Installed",
- preview_remote_card(
+ ExtensionCard::remote(
&remote_extension(
"preview-python",
"Python",
@@ -541,14 +534,14 @@ impl Component for ExtensionCard {
ExtensionProvides::ContextServers,
],
),
- ExtensionStatus::Installed("0.5.1".into()),
+ PublishedExtensionState::Store(ExtensionStatus::Installed("0.5.1".into())),
cx,
)
.into_any_element(),
),
single_example(
"Update Available",
- preview_remote_card(
+ ExtensionCard::remote(
&remote_extension(
"preview-rust",
"Rust",
@@ -560,19 +553,23 @@ impl Component for ExtensionCard {
ExtensionProvides::LanguageServers,
],
),
- ExtensionStatus::Installed("0.3.1".into()),
+ PublishedExtensionState::Store(ExtensionStatus::Installed("0.3.1".into())),
cx,
)
.into_any_element(),
),
single_example(
"Development Extension",
- preview_dev_card(dev_extension(), ExtensionStatus::Installed("0.1.0".into()))
- .into_any_element(),
+ ExtensionCard::manifest(
+ dev_extension(),
+ ExtensionStatus::Installed("0.1.0".into()),
+ LocalExtensionKind::Dev,
+ )
+ .into_any_element(),
),
single_example(
"Overridden by Development Extension",
- preview_remote_card(
+ ExtensionCard::remote(
&remote_extension(
"preview-overridden-theme",
"Local Theme",
@@ -581,7 +578,7 @@ impl Component for ExtensionCard {
36_512,
[ExtensionProvides::Themes],
),
- ExtensionStatus::OverriddenByDevExtension,
+ PublishedExtensionState::OverriddenByDevExtension,
cx,
)
.into_any_element(),
diff --git a/crates/extensions_ui/src/extensions_ui.rs b/crates/extensions_ui/src/extensions_ui.rs
index b5bf231e665..77be3070d98 100644
--- a/crates/extensions_ui/src/extensions_ui.rs
+++ b/crates/extensions_ui/src/extensions_ui.rs
@@ -11,7 +11,7 @@ use cloud_api_types::{ExtensionMetadata, ExtensionProvides};
use collections::{BTreeMap, BTreeSet};
use command_palette_hooks::CommandPaletteFilter;
use editor::{Editor, EditorElement, EditorStyle};
-use extension_host::{ExtensionManifest, ExtensionStore};
+use extension_host::{ExtensionIndexEntry, ExtensionManifest, ExtensionStore};
use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
use git::{GitHostingProviderRegistry, parse_git_remote_url};
use gpui::{
@@ -29,8 +29,8 @@ use settings::{Settings, SettingsContent};
use strum::IntoEnumIterator as _;
use theme_settings::ThemeSettings;
use ui::{
- Banner, ContextMenu, Divider, ListItem, ListItemSpacing, ScrollableHandle, Switch,
- ToggleButtonGroup, ToggleButtonGroupSize, ToggleButtonGroupStyle, ToggleButtonSimple,
+ Banner, CommonAnimationExt, ContextMenu, Divider, ListItem, ListItemSpacing, ScrollableHandle,
+ Switch, ToggleButtonGroup, ToggleButtonGroupSize, ToggleButtonGroupStyle, ToggleButtonSimple,
WithScrollbar, prelude::*,
};
use util::ResultExt;
@@ -42,7 +42,7 @@ use workspace::{
};
use zed_actions::ExtensionCategoryFilter;
-use crate::components::{ExtensionCard, extension_provides_label, remote_extension_status};
+use crate::components::{ExtensionCard, extension_provides_label};
use crate::extension_version_selector::{
ExtensionVersionSelector, ExtensionVersionSelectorDelegate,
};
@@ -293,15 +293,6 @@ enum ExtensionFilter {
NotInstalled,
}
-impl ExtensionFilter {
- pub fn include_dev_extensions(&self) -> bool {
- match self {
- Self::All | Self::Installed => true,
- Self::NotInstalled => false,
- }
- }
-}
-
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
enum Feature {
AgentClaude,
@@ -371,22 +362,50 @@ fn keywords_by_feature() -> &'static BTreeMap<Feature, Vec<&'static str>> {
})
}
+#[derive(Clone, Copy)]
+enum DisplayedExtension {
+ /// Index into the installed search results. `remote_index` points to the
+ /// extension's metadata from the latest fetch, if it was part of it.
+ Installed {
+ index: usize,
+ remote_index: Option<usize>,
+ },
+ /// Index into the remote extensions.
+ Remote(usize),
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum ExtensionFetchState {
+ Fetching,
+ Succeeded,
+ Failed,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum FetchDebounce {
+ Immediate,
+ /// Debounce the fetch if there is a search query.
+ WhenSearching,
+}
+
pub struct ExtensionsPage {
workspace: WeakEntity<Workspace>,
+ extension_store: Entity<ExtensionStore>,
provider_registry: Arc<GitHostingProviderRegistry>,
list: UniformListScrollHandle,
- is_fetching_extensions: bool,
- fetch_failed: bool,
+ fetch_state: ExtensionFetchState,
filter: ExtensionFilter,
- remote_extension_entries: Vec<ExtensionMetadata>,
- dev_extension_entries: Vec<Arc<ExtensionManifest>>,
- filtered_remote_extension_indices: Vec<usize>,
- filtered_dev_extension_indices: Vec<usize>,
+ /// Installed extensions matching the current search.
+ installed_search_results: Vec<ExtensionIndexEntry>,
+ /// Results of the latest fetch, empty if it failed.
+ remote_extensions: Vec<ExtensionMetadata>,
+ displayed_extensions: Vec<DisplayedExtension>,
query_editor: Entity<Editor>,
query_contains_error: bool,
provides_filter: Option<ExtensionProvides>,
_subscriptions: [gpui::Subscription; 2],
extension_fetch_task: Option<Task<()>>,
+ local_search_task: Option<Task<()>>,
upsells: BTreeSet<Feature>,
}
@@ -399,16 +418,16 @@ impl ExtensionsPage {
cx: &mut Context<Workspace>,
) -> Entity<Self> {
cx.new(|cx| {
- let store = ExtensionStore::global(cx);
+ let extension_store = ExtensionStore::global(cx);
let workspace_handle = workspace.weak_handle();
let subscriptions = [
- cx.observe(&store, |_: &mut Self, _, cx| cx.notify()),
+ cx.observe(&extension_store, |_: &mut Self, _, cx| cx.notify()),
cx.subscribe_in(
- &store,
+ &extension_store,
window,
move |this, _, event, window, cx| match event {
extension_host::Event::ExtensionsUpdated => {
- this.fetch_extensions_debounced(None, cx)
+ this.update_local_search_results(cx)
}
extension_host::Event::ExtensionInstalled(extension_id) => this
.on_extension_installed(
@@ -437,28 +456,24 @@ impl ExtensionsPage {
let mut this = Self {
workspace: workspace.weak_handle(),
+ extension_store,
provider_registry,
list: scroll_handle,
- is_fetching_extensions: false,
- fetch_failed: false,
+ fetch_state: ExtensionFetchState::Fetching,
filter: ExtensionFilter::All,
- dev_extension_entries: Vec::new(),
- filtered_remote_extension_indices: Vec::new(),
- filtered_dev_extension_indices: Vec::new(),
- remote_extension_entries: Vec::new(),
+ installed_search_results: Vec::new(),
+ remote_extensions: Vec::new(),
+ displayed_extensions: Vec::new(),
query_contains_error: false,
provides_filter,
extension_fetch_task: None,
+ local_search_task: None,
_subscriptions: subscriptions,
query_editor,
upsells: BTreeSet::default(),
};
- this.fetch_extensions(
- this.search_query(cx),
- Some(BTreeSet::from_iter(this.provides_filter)),
- None,
- cx,
- );
+ this.update_local_search_results(cx);
+ this.fetch_extensions(FetchDebounce::Immediate, None, cx);
this
})
}
@@ -476,7 +491,7 @@ impl ExtensionsPage {
window: &mut Window,
cx: &mut Context<Self>,
) {
- let extension_store = ExtensionStore::global(cx).read(cx);
+ let extension_store = self.extension_store.read(cx);
let themes = extension_store
.extension_themes(extension_id)
.map(|name| name.to_string())
@@ -515,43 +530,117 @@ impl ExtensionsPage {
}
}
- fn filter_extension_entries(&mut self, cx: &mut Context<Self>) {
- self.filtered_remote_extension_indices.clear();
- self.filtered_remote_extension_indices.extend(
- self.remote_extension_entries
- .iter()
- .enumerate()
- .filter(|(_, extension)| {
- if self.filter == ExtensionFilter::All {
- return true;
- }
+ /// Runs the search against the locally installed extensions, independently of
+ /// the remote fetch, so local results show up without waiting for the server.
+ fn update_local_search_results(&mut self, cx: &mut Context<Self>) {
+ let search = self.search_query(cx);
+ let mut installed_extensions = self
+ .extension_store
+ .read(cx)
+ .installed_extensions()
+ .values()
+ .cloned()
+ .collect::<Vec<_>>();
- let status = remote_extension_status(&extension.id, cx);
- match self.filter {
- ExtensionFilter::Installed => status.is_installed(),
- ExtensionFilter::NotInstalled => !status.is_installed(),
- ExtensionFilter::All => true,
+ self.local_search_task = Some(cx.spawn(async move |this, cx| {
+ let results = match search.as_deref() {
+ None => {
+ installed_extensions
+ .sort_by_cached_key(|extension| extension.manifest.name.to_lowercase());
+ installed_extensions
+ }
+ Some(search) => {
+ if let Some(extension_id) = search.strip_prefix("id:") {
+ installed_extensions
+ .into_iter()
+ .filter(|extension| extension.manifest.id.as_ref() == extension_id)
+ .collect()
+ } else {
+ let match_candidates = installed_extensions
+ .iter()
+ .enumerate()
+ .map(|(index, extension)| {
+ StringMatchCandidate::new(index, &extension.manifest.name)
+ })
+ .collect::<Vec<_>>();
+ let matches = match_strings(
+ &match_candidates,
+ search,
+ false,
+ true,
+ match_candidates.len(),
+ &Default::default(),
+ cx.background_executor().clone(),
+ )
+ .await;
+ matches
+ .into_iter()
+ .filter_map(|matched| {
+ installed_extensions.get(matched.candidate_id).cloned()
+ })
+ .collect()
}
- })
- .filter(|(_, extension)| match self.provides_filter {
- Some(provides) => extension.manifest.provides.contains(&provides),
- None => true,
- })
- .map(|(ix, _)| ix),
- );
+ }
+ };
+
+ this.update(cx, |this, cx| {
+ this.installed_search_results = results;
+ this.rebuild_displayed_extensions(cx);
+ })
+ .ok();
+ }));
+ }
+
+ fn rebuild_displayed_extensions(&mut self, cx: &mut Context<Self>) {
+ let installed_extensions = self.extension_store.read(cx).installed_extensions();
+ let provides_filter = self.provides_filter;
- self.filtered_dev_extension_indices.clear();
- self.filtered_dev_extension_indices.extend(
- self.dev_extension_entries
+ // Remote results can lag behind a provides filter change by one fetch, so
+ // the filter is applied locally as well.
+ let installed_rows =
+ self.installed_search_results
.iter()
.enumerate()
- .filter(|(_, manifest)| match self.provides_filter {
- Some(provides) => manifest.provides().contains(&provides),
- None => true,
- })
- .map(|(ix, _)| ix),
- );
+ .filter(|(_, extension)| {
+ provides_filter
+ .is_none_or(|provides| extension.manifest.provides().contains(&provides))
+ });
+ let remote_rows = self
+ .remote_extensions
+ .iter()
+ .enumerate()
+ .filter(|(_, extension)| {
+ provides_filter
+ .is_none_or(|provides| extension.manifest.provides.contains(&provides))
+ });
+ let installed_row = |(index, extension): (usize, &ExtensionIndexEntry)| {
+ let remote_index = (!extension.dev).then(|| {
+ self.remote_extensions
+ .iter()
+ .position(|remote| remote.id == extension.manifest.id)
+ });
+ DisplayedExtension::Installed {
+ index,
+ remote_index: remote_index.flatten(),
+ }
+ };
+ let remote_row = |(index, _)| DisplayedExtension::Remote(index);
+ self.displayed_extensions = match self.filter {
+ ExtensionFilter::All if self.fetch_state == ExtensionFetchState::Failed => {
+ installed_rows.map(installed_row).collect()
+ }
+ ExtensionFilter::All => installed_rows
+ .filter(|(_, extension)| extension.dev)
+ .map(installed_row)
+ .chain(remote_rows.map(remote_row))
+ .collect(),
+ ExtensionFilter::Installed => installed_rows.map(installed_row).collect(),
+ ExtensionFilter::NotInstalled => remote_rows
+ .filter(|(_, extension)| !installed_extensions.contains_key(&extension.id))
+ .map(remote_row)
+ .collect(),
+ };
cx.notify();
}
@@ -560,97 +649,79 @@ impl ExtensionsPage {
cx.notify();
}
+ /// Fetches the remote extensions for the current search. Any fetch still in
+ /// flight is cancelled.
fn fetch_extensions(
&mut self,
- search: Option<String>,
- provides_filter: Option<BTreeSet<ExtensionProvides>>,
- on_complete: Option<Box<dyn FnOnce(&mut Self, &mut Context<Self>) + Send>>,
+ debounce: FetchDebounce,
+ on_complete: Option<Box<dyn FnOnce(&mut Self, &mut Context<Self>)>>,
cx: &mut Context<Self>,
) {
- self.is_fetching_extensions = true;
- self.fetch_failed = false;
+ let search = self.search_query(cx);
+ let provides_filter = BTreeSet::from_iter(self.provides_filter);
+ self.fetch_state = ExtensionFetchState::Fetching;
cx.notify();
- let extension_store = ExtensionStore::global(cx);
-
- let dev_extensions = extension_store
- .read(cx)
- .dev_extensions()
- .cloned()
- .collect::<Vec<_>>();
-
- let remote_extensions =
- if let Some(id) = search.as_ref().and_then(|s| s.strip_prefix("id:")) {
- let versions =
- extension_store.update(cx, |store, cx| store.fetch_extension_versions(id, cx));
- cx.foreground_executor().spawn(async move {
- let versions = versions.await?;
- let latest = versions
- .into_iter()
- .max_by_key(|v| v.published_at)
- .context("no extension found")?;
- Ok(vec![latest])
- })
- } else {
- extension_store.update(cx, |store, cx| {
- store.fetch_extensions(search.as_deref(), provides_filter.as_ref(), cx)
- })
- };
-
- cx.spawn(async move |this, cx| {
- let dev_extensions = if let Some(search) = search {
- let match_candidates = dev_extensions
- .iter()
- .enumerate()
- .map(|(ix, manifest)| StringMatchCandidate::new(ix, &manifest.name))
- .collect::<Vec<_>>();
+ self.extension_fetch_task = Some(cx.spawn(async move |this, cx| {
+ // Only debounce the fetching of extensions if we have a search
+ // query.
+ //
+ // If the search was just cleared then we can just reload the list
+ // of extensions without a debounce, which allows us to avoid seeing
+ // an intermittent flash of a "no extensions" state.
+ if debounce == FetchDebounce::WhenSearching && search.is_some() {
+ cx.background_executor()
+ .timer(Duration::from_millis(250))
+ .await;
+ }
- let matches = match_strings(
- &match_candidates,
- &search,
- false,
- true,
- match_candidates.len(),
- &Default::default(),
- cx.background_executor().clone(),
- )
- .await;
- matches
- .into_iter()
- .map(|mat| dev_extensions[mat.candidate_id].clone())
- .collect()
- } else {
- dev_extensions
+ let Ok(remote_extensions) = this.update(cx, |this, cx| {
+ let extension_store = &this.extension_store;
+ if let Some(id) = search
+ .as_deref()
+ .and_then(|search| search.strip_prefix("id:"))
+ {
+ let versions = extension_store
+ .update(cx, |store, cx| store.fetch_extension_versions(id, cx));
+ cx.foreground_executor().spawn(async move {
+ let versions = versions.await?;
+ let latest = versions
+ .into_iter()
+ .max_by_key(|version| version.published_at)
+ .context("no extension found")?;
+ Ok(vec![latest])
+ })
+ } else {
+ extension_store.update(cx, |store, cx| {
+ store.fetch_extensions(search.as_deref(), Some(&provides_filter), cx)
+ })
+ }
+ }) else {
+ return;
};
-
let fetch_result = remote_extensions.await;
- let result = this.update(cx, |this, cx| {
- cx.notify();
- this.dev_extension_entries = dev_extensions;
- this.is_fetching_extensions = false;
-
+ this.update(cx, |this, cx| {
match fetch_result {
- Ok(extensions) => {
- this.fetch_failed = false;
- this.remote_extension_entries = extensions;
- this.filter_extension_entries(cx);
- if let Some(callback) = on_complete {
- callback(this, cx);
- }
- Ok(())
+ Ok(remote_extensions) => {
+ this.fetch_state = ExtensionFetchState::Succeeded;
+ this.remote_extensions = remote_extensions;
}
- Err(err) => {
- this.fetch_failed = true;
- this.filter_extension_entries(cx);
- Err(err)
+ Err(error) => {
+ log::error!("failed to fetch extensions: {error:#}");
+ this.fetch_state = ExtensionFetchState::Failed;
+ this.remote_extensions.clear();
}
}
- });
-
- result?
- })
- .detach_and_log_err(cx);
+ this.rebuild_displayed_extensions(cx);
+ if this.fetch_state == ExtensionFetchState::Succeeded
+ && let Some(on_complete) = on_complete
+ {
+ on_complete(this, cx);
+ }
+ })
+ .ok();
+ }));
}
fn render_extensions(
@@ -659,71 +730,95 @@ impl ExtensionsPage {
_: &mut Window,
cx: &mut Context<Self>,
) -> Vec<ExtensionCard> {
- let dev_extension_entries_len = if self.filter.include_dev_extensions() {
- self.filtered_dev_extension_indices.len()
- } else {
- 0
- };
+ let extension_store = self.extension_store.read(cx);
range
- .map(|ix| {
- if ix < dev_extension_entries_len {
- let dev_ix = self.filtered_dev_extension_indices[ix];
- let extension = &self.dev_extension_entries[dev_ix];
- let repository_icon = extension
- .repository
- .as_deref()
- .map(|url| self.get_repository_icon(url));
- let card = ExtensionCard::for_dev(extension.clone(), cx);
- if let Some(icon) = repository_icon {
- card.repository_icon(icon)
- } else {
- card
- }
- } else {
- let extension_ix =
- self.filtered_remote_extension_indices[ix - dev_extension_entries_len];
- let extension = &self.remote_extension_entries[extension_ix];
- self.render_remote_extension(extension, cx)
- }
+ .filter_map(|index| {
+ let row = *self.displayed_extensions.get(index)?;
+ self.render_extension(row, extension_store, cx)
})
.collect()
}
- fn render_remote_extension(
+ fn render_extension(
&self,
- extension: &ExtensionMetadata,
- cx: &mut Context<Self>,
- ) -> ExtensionCard {
- let repository_icon = self.get_repository_icon(&extension.manifest.repository);
- let card = ExtensionCard::for_remote(extension, cx).repository_icon(repository_icon);
- let this = cx.weak_entity();
-
- card.context_menu(move |extension_id, authors, window, cx| {
- let this = this.upgrade()?;
- Some(ContextMenu::build(window, cx, |context_menu, window, _| {
- context_menu
- .entry(
- "Install Another Version...",
- None,
- window.handler_for(&this, {
- let extension_id = extension_id.clone();
- move |this, window, cx| {
- this.show_extension_version_list(extension_id.clone(), window, cx)
- }
- }),
- )
- .entry("Copy Extension ID", None, {
+ row: DisplayedExtension,
+ extension_store: &ExtensionStore,
+ cx: &Context<Self>,
+ ) -> Option<ExtensionCard> {
+ let remote_index = match row {
+ DisplayedExtension::Installed {
+ index,
+ remote_index: None,
+ } => {
+ let extension = self.installed_search_results.get(index)?;
+ let manifest = extension.manifest.clone();
+ let repository_icon = manifest
+ .repository
+ .as_deref()
+ .map(|url| self.get_repository_icon(url));
+ let card = if extension.dev {
+ ExtensionCard::for_dev(manifest, extension_store)
+ } else {
+ ExtensionCard::for_installed(manifest, extension_store)
+ };
+ return Some(match repository_icon {
+ Some(icon) => card.repository_icon(icon),
+ None => card,
+ });
+ }
+ DisplayedExtension::Installed {
+ remote_index: Some(remote_index),
+ ..
+ }
+ | DisplayedExtension::Remote(remote_index) => remote_index,
+ };
+
+ let extension = self.remote_extensions.get(remote_index)?;
+ let weak_self = cx.weak_entity();
+ Some(
+ ExtensionCard::for_remote(extension, extension_store, cx)
+ .repository_icon(self.get_repository_icon(&extension.manifest.repository))
+ .context_menu(move |extension_id, authors, window, cx| {
+ let this = weak_self.upgrade()?;
+ Some(Self::render_remote_extension_context_menu(
+ &this,
+ extension_id,
+ authors,
+ window,
+ cx,
+ ))
+ }),
+ )
+ }
+
+ fn render_remote_extension_context_menu(
+ this: &Entity<Self>,
+ extension_id: Arc<str>,
+ authors: SharedString,
+ window: &mut Window,
+ cx: &mut App,
+ ) -> Entity<ContextMenu> {
+ ContextMenu::build(window, cx, |context_menu, window, _| {
+ context_menu
+ .entry(
+ "Install Another Version...",
+ None,
+ window.handler_for(this, {
let extension_id = extension_id.clone();
- move |_, cx| {
- cx.write_to_clipboard(ClipboardItem::new_string(
- extension_id.to_string(),
- ));
+ move |this, window, cx| {
+ this.show_extension_version_list(extension_id.clone(), window, cx)
}
- })
- .entry("Copy Author Info", None, move |_, cx| {
- cx.write_to_clipboard(ClipboardItem::new_string(authors.to_string()));
- })
- }))
+ }),
+ )
+ .entry("Copy Extension ID", None, {
+ let extension_id = extension_id.clone();
+ move |_, cx| {
+ cx.write_to_clipboard(ClipboardItem::new_string(extension_id.to_string()));
+ }
+ })
+ .entry("Copy Author Info", None, move |_, cx| {
+ cx.write_to_clipboard(ClipboardItem::new_string(authors.to_string()));
+ })
})
}
@@ -738,10 +833,8 @@ impl ExtensionsPage {
};
cx.spawn_in(window, async move |this, cx| {
- let extension_versions_task = this.update(cx, |_, cx| {
- let extension_store = ExtensionStore::global(cx);
-
- extension_store.update(cx, |store, cx| {
+ let extension_versions_task = this.update(cx, |this, cx| {
+ this.extension_store.update(cx, |store, cx| {
store.fetch_extension_versions(&extension_id, cx)
})
})?;
@@ -788,7 +881,27 @@ impl ExtensionsPage {
.border_color(editor_border)
.rounded_md()
.child(Icon::new(IconName::MagnifyingGlass).color(Color::Muted))
- .child(self.render_text_input(&self.query_editor, cx))
+ .child(
+ div()
+ .flex_1()
+ .child(self.render_text_input(&self.query_editor, cx)),
+ )
+ .when(self.fetch_state == ExtensionFetchState::Fetching, |this| {
+ this.child(
+ Icon::new(IconName::LoadCircle)
+ .size(IconSize::Small)
+ .color(Color::Muted)
+ .with_rotate_animation(2),
+ )
+ })
+ }
+
+ fn retry_button(&self, cx: &mut Context<Self>) -> Button {
+ Button::new("retry-fetch-extensions", "Retry")
+ .style(ButtonStyle::Outlined)
+ .on_click(cx.listener(|this, _, _, cx| {
+ this.fetch_extensions(FetchDebounce::Immediate, None, cx);
+ }))
}
fn render_text_input(
@@ -836,7 +949,9 @@ impl ExtensionsPage {
}
fn refresh_search(&mut self, cx: &mut Context<Self>) {
- self.fetch_extensions_debounced(
+ self.update_local_search_results(cx);
+ self.fetch_extensions(
+ FetchDebounce::WhenSearching,
Some(Box::new(|this, cx| {
this.scroll_to_top(cx);
})),
@@ -861,41 +976,6 @@ impl ExtensionsPage {
self.refresh_search(cx);
}
- fn fetch_extensions_debounced(
- &mut self,
- on_complete: Option<Box<dyn FnOnce(&mut Self, &mut Context<Self>) + Send>>,
- cx: &mut Context<ExtensionsPage>,
- ) {
- self.extension_fetch_task = Some(cx.spawn(async move |this, cx| {
- let search = this
- .update(cx, |this, cx| this.search_query(cx))
- .ok()
- .flatten();
-
- // Only debounce the fetching of extensions if we have a search
- // query.
- //
- // If the search was just cleared then we can just reload the list
- // of extensions without a debounce, which allows us to avoid seeing
- // an intermittent flash of a "no extensions" state.
- if search.is_some() {
- cx.background_executor()
- .timer(Duration::from_millis(250))
- .await;
- };
-
- this.update(cx, |this, cx| {
- this.fetch_extensions(
- search,
- Some(BTreeSet::from_iter(this.provides_filter)),
- on_complete,
- cx,
- );
- })
- .ok();
- }));
- }
-
pub fn search_query(&self, cx: &mut App) -> Option<String> {
let search = self.query_editor.read(cx).text(cx);
if search.trim().is_empty() {
@@ -908,9 +988,15 @@ impl ExtensionsPage {
fn render_empty_state(&self, cx: &mut Context<Self>) -> impl IntoElement {
let has_search = self.search_query(cx).is_some();
- let message = if self.is_fetching_extensions {
+ // The `Installed` filter is fully local, so fetch progress and failure are
+ // only relevant to the other filters.
+ let fetch_is_relevant = self.filter != ExtensionFilter::Installed;
+ let fetch_failure_is_relevant =
+ self.fetch_state == ExtensionFetchState::Failed && fetch_is_relevant;
+ let is_loading = self.fetch_state == ExtensionFetchState::Fetching && fetch_is_relevant;
+ let message = if is_loading {
"Loading extensions…"
- } else if self.fetch_failed {
+ } else if fetch_failure_is_relevant {
"Failed to load extensions. Please check your connection and try again."
} else {
match self.filter {
@@ -938,23 +1024,39 @@ impl ExtensionsPage {
}
};
- h_flex()
- .py_4()
- .gap_1p5()
- .when(self.fetch_failed, |this| {
- this.child(
- Icon::new(IconName::Warning)
- .size(IconSize::Small)
- .color(Color::Warning),
- )
+ v_flex()
+ .size_full()
+ .items_center()
+ .justify_center()
+ .gap_3()
+ .child(
+ h_flex()
+ .gap_1p5()
+ .when(is_loading, |this| {
+ this.child(
+ Icon::new(IconName::LoadCircle)
+ .size(IconSize::Small)
+ .color(Color::Accent)
+ .with_rotate_animation(3),
+ )
+ })
+ .when(fetch_failure_is_relevant, |this| {
+ this.child(
+ Icon::new(IconName::Warning)
+ .size(IconSize::Small)
+ .color(Color::Warning),
+ )
+ })
+ .child(Label::new(message)),
+ )
+ .when(fetch_failure_is_relevant, |this| {
+ this.child(self.retry_button(cx))
})
- .child(Label::new(message))
}
fn update_settings(
&mut self,
selection: &ToggleState,
-
cx: &mut Context<Self>,
callback: impl 'static + Send + Fn(&mut SettingsContent, bool),
) {
@@ -1408,7 +1510,7 @@ impl Render for ExtensionsPage {
"All",
cx.listener(|this, _event, _, cx| {
this.filter = ExtensionFilter::All;
- this.filter_extension_entries(cx);
+ this.rebuild_displayed_extensions(cx);
this.scroll_to_top(cx);
}),
),
@@ -1416,7 +1518,7 @@ impl Render for ExtensionsPage {
"Installed",
cx.listener(|this, _event, _, cx| {
this.filter = ExtensionFilter::Installed;
- this.filter_extension_entries(cx);
+ this.rebuild_displayed_extensions(cx);
this.scroll_to_top(cx);
}),
),
@@ -1424,7 +1526,7 @@ impl Render for ExtensionsPage {
"Not Installed",
cx.listener(|this, _event, _, cx| {
this.filter = ExtensionFilter::NotInstalled;
- this.filter_extension_entries(cx);
+ this.rebuild_displayed_extensions(cx);
this.scroll_to_top(cx);
}),
),
@@ -1497,16 +1599,32 @@ impl Render for ExtensionsPage {
)
.child(self.render_feature_upsells(cx))
.child(v_flex().px_4().size_full().overflow_y_hidden().map(|this| {
- let mut count = self.filtered_remote_extension_indices.len();
- if self.filter.include_dev_extensions() {
- count += self.filtered_dev_extension_indices.len();
- }
+ let count = self.displayed_extensions.len();
if count == 0 {
this.child(self.render_empty_state(cx)).into_any_element()
} else {
let scroll_handle = &self.list;
- this.child(
+ this.when(
+ self.fetch_state == ExtensionFetchState::Failed
+ && self.filter == ExtensionFilter::All,
+ |this| {
+ this.child(
+ div().pt_4().child(
+ Banner::new()
+ .severity(Severity::Warning)
+ .child(
+ Label::new(
+ "Failed to load extensions. Showing installed extensions only.",
+ )
+ .mt_0p5(),
+ )
+ .action_slot(self.retry_button(cx)),
+ ),
+ )
+ },
+ )
+ .child(
uniform_list("entries", count, cx.processor(Self::render_extensions))
.flex_grow_1()
.pb_4()