//! Provides hooks for customizing the behavior of the command palette. #![deny(missing_docs)] use std::any::TypeId; use collections::HashSet;use derive_more::{Deref, DerefMut};use gpui::{Action, App, BorrowAppContext, Global}; /// Initializes the command palette hooks.pub fn init(cx: &mut App) {    cx.set_global(GlobalCommandPaletteFilter::default());    cx.set_global(GlobalCommandPaletteInterceptor::default());} /// A filter for the command palette.#[derive(Default)]pub struct CommandPaletteFilter {    hidden_namespaces: HashSet<&'static str>,    hidden_action_types: HashSet<TypeId>,    /// Actions that have explicitly been shown. These should be shown even if    /// they are in a hidden namespace.    shown_action_types: HashSet<TypeId>,} #[derive(Deref, DerefMut, Default)]struct GlobalCommandPaletteFilter(CommandPaletteFilter); impl Global for GlobalCommandPaletteFilter {} impl CommandPaletteFilter {    /// Returns the global [`CommandPaletteFilter`], if one is set.    pub fn try_global(cx: &App) -> Option<&CommandPaletteFilter> {        cx.try_global::<GlobalCommandPaletteFilter>()            .map(|filter| &filter.0)    }     /// Returns a mutable reference to the global [`CommandPaletteFilter`].    pub fn global_mut(cx: &mut App) -> &mut Self {        cx.global_mut::<GlobalCommandPaletteFilter>()    }     /// Updates the global [`CommandPaletteFilter`] using the given closure.    pub fn update_global<F>(cx: &mut App, update: F)    where        F: FnOnce(&mut Self, &mut App),    {        if cx.has_global::<GlobalCommandPaletteFilter>() {            cx.update_global(|this: &mut GlobalCommandPaletteFilter, cx| update(&mut this.0, cx))        }    }     /// Returns whether the given [`Action`] is hidden by the filter.    pub fn is_hidden(&self, action: &dyn Action) -> bool {        let name = action.name();        let namespace = name.split("::").next().unwrap_or("malformed action name");         // If this action has specifically been shown then it should be visible.        if self.shown_action_types.contains(&action.type_id()) {            return false;        }         self.hidden_namespaces.contains(namespace)            || self.hidden_action_types.contains(&action.type_id())    }     /// Hides all actions in the given namespace.    pub fn hide_namespace(&mut self, namespace: &'static str) {        self.hidden_namespaces.insert(namespace);    }     /// Shows all actions in the given namespace.    pub fn show_namespace(&mut self, namespace: &'static str) {        self.hidden_namespaces.remove(namespace);    }     /// Hides all actions with the given types.    pub fn hide_action_types(&mut self, action_types: &[TypeId]) {        for action_type in action_types {            self.hidden_action_types.insert(*action_type);            self.shown_action_types.remove(action_type);        }    }     /// Shows all actions with the given types.    pub fn show_action_types<'a>(&mut self, action_types: impl Iterator<Item = &'a TypeId>) {        for action_type in action_types {            self.shown_action_types.insert(*action_type);            self.hidden_action_types.remove(action_type);        }    }} /// The result of intercepting a command palette command.#[derive(Debug)]pub struct CommandInterceptResult {    /// The action produced as a result of the interception.    pub action: Box<dyn Action>,    // TODO: Document this field.    #[allow(missing_docs)]    pub string: String,    // TODO: Document this field.    #[allow(missing_docs)]    pub positions: Vec<usize>,} /// An interceptor for the command palette.#[derive(Default)]pub struct CommandPaletteInterceptor(    Option<Box<dyn Fn(&str, &App) -> Vec<CommandInterceptResult>>>,); #[derive(Default)]struct GlobalCommandPaletteInterceptor(CommandPaletteInterceptor); impl Global for GlobalCommandPaletteInterceptor {} impl CommandPaletteInterceptor {    /// Returns the global [`CommandPaletteInterceptor`], if one is set.    pub fn try_global(cx: &App) -> Option<&CommandPaletteInterceptor> {        cx.try_global::<GlobalCommandPaletteInterceptor>()            .map(|interceptor| &interceptor.0)    }     /// Updates the global [`CommandPaletteInterceptor`] using the given closure.    pub fn update_global<F, R>(cx: &mut App, update: F) -> R    where        F: FnOnce(&mut Self, &mut App) -> R,    {        cx.update_global(|this: &mut GlobalCommandPaletteInterceptor, cx| update(&mut this.0, cx))    }     /// Intercepts the given query from the command palette.    pub fn intercept(&self, query: &str, cx: &App) -> Vec<CommandInterceptResult> {        if let Some(handler) = self.0.as_ref() {            (handler)(query, cx)        } else {            Vec::new()        }    }     /// Clears the global interceptor.    pub fn clear(&mut self) {        self.0 = None;    }     /// Sets the global interceptor.    ///    /// This will override the previous interceptor, if it exists.    pub fn set(&mut self, handler: Box<dyn Fn(&str, &App) -> Vec<CommandInterceptResult>>) {        self.0 = Some(handler);    }}