feat: add support for basic icons

Cargo.lock

@@ -1560,6 +1560,7 @@ dependencies = [
  "serde",
  "serde_json",
  "slotmap",
+ "smartstring",
  "tempfile",
  "thiserror 2.0.12",
  "tokio",
@@ -2423,6 +2424,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3fb72c633efbaa2dd666986505016c32c3044395ceaf881518399d2f4127ee29"
 dependencies = [
  "autocfg",
+ "serde",
  "static_assertions",
  "version_check",
 ]

helix-term/src/commands.rs

@@ -44,6 +44,7 @@ use helix_core::{
 use helix_view::{
     document::{FormatterError, Mode, SCRATCH_BUFFER_NAME},
     editor::Action,
+    icons::ICONS,
     info::Info,
     input::KeyEvent,
     keyboard::KeyCode,
@@ -3296,12 +3297,28 @@ fn changed_file_picker(cx: &mut Context) {
 
     let columns = [
         PickerColumn::new("change", |change: &FileChange, data: &FileChangeData| {
+            let icons = ICONS.load();
             match change {
-                FileChange::Untracked { .. } => Span::styled("+ untracked", data.style_untracked),
+                FileChange::Untracked { .. } => Span::styled(
-                FileChange::Modified { .. } => Span::styled("~ modified", data.style_modified),
+                    format!("{}  untracked", icons.vcs().added()),
-                FileChange::Conflict { .. } => Span::styled("x conflict", data.style_conflict),
+                    data.style_untracked,
-                FileChange::Deleted { .. } => Span::styled("- deleted", data.style_deleted),
+                ),
-                FileChange::Renamed { .. } => Span::styled("> renamed", data.style_renamed),
+                FileChange::Modified { .. } => Span::styled(
+                    format!("{}  modified", icons.vcs().modified()),
+                    data.style_modified,
+                ),
+                FileChange::Conflict { .. } => Span::styled(
+                    format!("{}  conflict", icons.vcs().conflict()),
+                    data.style_conflict,
+                ),
+                FileChange::Deleted { .. } => Span::styled(
+                    format!("{}  deleted", icons.vcs().removed()),
+                    data.style_deleted,
+                ),
+                FileChange::Renamed { .. } => Span::styled(
+                    format!("{}  renamed", icons.vcs().renamed()),
+                    data.style_renamed,
+                ),
             }
             .into()
         }),

helix-term/src/commands/lsp.rs

@@ -22,6 +22,7 @@ use helix_view::{
     document::{DocumentInlayHints, DocumentInlayHintsId},
     editor::Action,
     handlers::lsp::SignatureHelpInvoked,
+    icons::ICONS,
     theme::Style,
     Document, View,
 };
@@ -242,11 +243,22 @@ fn diag_picker(
         ui::PickerColumn::new(
             "severity",
             |item: &PickerDiagnostic, styles: &DiagnosticStyles| {
+                let icons = ICONS.load();
                 match item.diag.severity {
-                    Some(DiagnosticSeverity::HINT) => Span::styled("HINT", styles.hint),
+                    Some(DiagnosticSeverity::HINT) => {
-                    Some(DiagnosticSeverity::INFORMATION) => Span::styled("INFO", styles.info),
+                        Span::styled(format!("{} HINT", icons.diagnostic().hint()), styles.hint)
-                    Some(DiagnosticSeverity::WARNING) => Span::styled("WARN", styles.warning),
+                    }
-                    Some(DiagnosticSeverity::ERROR) => Span::styled("ERROR", styles.error),
+                    Some(DiagnosticSeverity::INFORMATION) => {
+                        Span::styled(format!("{} INFO", icons.diagnostic().info()), styles.info)
+                    }
+                    Some(DiagnosticSeverity::WARNING) => Span::styled(
+                        format!("{} WARN", icons.diagnostic().warning()),
+                        styles.warning,
+                    ),
+                    Some(DiagnosticSeverity::ERROR) => Span::styled(
+                        format!("{} ERROR", icons.diagnostic().error()),
+                        styles.error,
+                    ),
                     _ => Span::raw(""),
                 }
                 .into()
@@ -397,7 +409,12 @@ pub fn symbol_picker(cx: &mut Context) {
         let call = move |_editor: &mut Editor, compositor: &mut Compositor| {
             let columns = [
                 ui::PickerColumn::new("kind", |item: &SymbolInformationItem, _| {
-                    display_symbol_kind(item.symbol.kind).into()
+                    let icons = ICONS.load();
+                    let name = display_symbol_kind(item.symbol.kind);
+                    icons
+                        .lsp()
+                        .get(name)
+                        .map_or_else(|| name.into(), |symbol| format!("{symbol}  {name}").into())
                 }),
                 // Some symbols in the document symbol picker may have a URI that isn't
                 // the current file. It should be rare though, so we concatenate that
@@ -515,7 +532,12 @@ pub fn workspace_symbol_picker(cx: &mut Context) {
     };
     let columns = [
         ui::PickerColumn::new("kind", |item: &SymbolInformationItem, _| {
-            display_symbol_kind(item.symbol.kind).into()
+            let icons = ICONS.load();
+            let name = display_symbol_kind(item.symbol.kind);
+            icons
+                .lsp()
+                .get(name)
+                .map_or_else(|| name.into(), |symbol| format!("{symbol}  {name}").into())
         }),
         ui::PickerColumn::new("name", |item: &SymbolInformationItem, _| {
             item.symbol.name.as_str().into()

helix-term/src/config.rs

@@ -2,11 +2,13 @@ use crate::keymap;
 use crate::keymap::{merge_keys, KeyTrie};
 use helix_loader::merge_toml_values;
 use helix_view::document::Mode;
+use helix_view::icons::{Icons, ICONS};
 use serde::Deserialize;
 use std::collections::HashMap;
 use std::fmt::Display;
 use std::fs;
 use std::io::Error as IOError;
+use std::sync::Arc;
 use toml::de::Error as TomlError;
 
 #[derive(Debug, Clone, PartialEq)]
@@ -22,6 +24,7 @@ pub struct ConfigRaw {
     pub theme: Option<String>,
     pub keys: Option<HashMap<Mode, KeyTrie>>,
     pub editor: Option<toml::Value>,
+    pub icons: Option<toml::Value>,
 }
 
 impl Default for Config {
@@ -64,6 +67,7 @@ impl Config {
             global.and_then(|file| toml::from_str(&file).map_err(ConfigLoadError::BadConfig));
         let local_config: Result<ConfigRaw, ConfigLoadError> =
             local.and_then(|file| toml::from_str(&file).map_err(ConfigLoadError::BadConfig));
+
         let res = match (global_config, local_config) {
             (Ok(global), Ok(local)) => {
                 let mut keys = keymap::default();
@@ -84,6 +88,18 @@ impl Config {
                         .map_err(ConfigLoadError::BadConfig)?,
                 };
 
+                let icons: Icons = match (global.icons, local.icons) {
+                    (None, None) => Icons::default(),
+                    (None, Some(val)) | (Some(val), None) => {
+                        val.try_into().map_err(ConfigLoadError::BadConfig)?
+                    }
+                    (Some(global), Some(local)) => merge_toml_values(global, local, 3)
+                        .try_into()
+                        .map_err(ConfigLoadError::BadConfig)?,
+                };
+
+                ICONS.store(Arc::new(icons));
+
                 Config {
                     theme: local.theme.or(global.theme),
                     keys,
@@ -100,6 +116,14 @@ impl Config {
                 if let Some(keymap) = config.keys {
                     merge_keys(&mut keys, keymap);
                 }
+
+                let icons = config.icons.map_or_else(
+                    || Ok(Icons::default()),
+                    |val| val.try_into().map_err(ConfigLoadError::BadConfig),
+                )?;
+
+                ICONS.store(Arc::new(icons));
+
                 Config {
                     theme: config.theme,
                     keys,

helix-term/src/handlers/document_colors.rs

@@ -8,6 +8,7 @@ use helix_view::{
     document::DocumentColorSwatches,
     events::{DocumentDidChange, DocumentDidOpen, LanguageServerExited, LanguageServerInitialized},
     handlers::{lsp::DocumentColorsEvent, Handlers},
+    icons::ICONS,
     DocumentId, Editor, Theme,
 };
 use tokio::time::Instant;
@@ -120,9 +121,11 @@ fn attach_document_colors(
     let mut color_swatches_padding = Vec::with_capacity(doc_colors.len());
     let mut colors = Vec::with_capacity(doc_colors.len());
 
+    let icons = ICONS.load();
+
     for (pos, color) in doc_colors {
         color_swatches_padding.push(InlineAnnotation::new(pos, " "));
-        color_swatches.push(InlineAnnotation::new(pos, "■"));
+        color_swatches.push(InlineAnnotation::new(pos, icons.lsp().color()));
         colors.push(Theme::rgb_highlight(
             (color.red * 255.) as u8,
             (color.green * 255.) as u8,

helix-term/src/ui/completion.rs

@@ -9,6 +9,7 @@ use crate::{
 use helix_core::snippets::{ActiveSnippet, RenderedSnippet, Snippet};
 use helix_core::{self as core, chars, fuzzy::MATCHER, Change, Transaction};
 use helix_lsp::{lsp, util, OffsetEncoding};
+use helix_view::icons::ICONS;
 use helix_view::{
     editor::CompleteAction,
     handlers::lsp::SignatureHelpInvoked,
@@ -45,7 +46,7 @@ impl menu::Item for CompletionItem {
             CompletionItem::Other(core::CompletionItem { label, .. }) => label,
         };
 
-        let kind = match self {
+        let mut kind = match self {
             CompletionItem::Lsp(LspCompletionItem { item, .. }) => match item.kind {
                 Some(lsp::CompletionItemKind::TEXT) => "text".into(),
                 Some(lsp::CompletionItemKind::METHOD) => "method".into(),
@@ -78,9 +79,13 @@ impl menu::Item for CompletionItem {
                     })
                     .and_then(Color::from_hex)
                     .map_or("color".into(), |color| {
+                        let icons = ICONS.load();
                         Spans::from(vec![
                             Span::raw("color "),
-                            Span::styled("■", Style::default().fg(color)),
+                            Span::styled(
+                                icons.lsp().color().to_string(),
+                                Style::default().fg(color),
+                            ),
                         ])
                     }),
                 Some(lsp::CompletionItemKind::FILE) => "file".into(),
@@ -101,6 +106,13 @@ impl menu::Item for CompletionItem {
             CompletionItem::Other(core::CompletionItem { kind, .. }) => kind.as_ref().into(),
         };
 
+        let icons = ICONS.load();
+        let name = &kind.0[0].content;
+
+        if let Some(icon) = icons.lsp().get(name) {
+            kind.0[0].content = format!("{icon}  {name}").into();
+        }
+
         let label = Span::styled(
             label,
             if deprecated {

helix-term/src/ui/editor.rs

@@ -24,9 +24,10 @@ use helix_core::{
 };
 use helix_view::{
     annotations::diagnostics::DiagnosticFilter,
-    document::{Mode, SCRATCH_BUFFER_NAME},
+    document::{Mode, DEFAULT_LANGUAGE_NAME, SCRATCH_BUFFER_NAME},
     editor::{CompleteAction, CursorShapeConfig},
     graphics::{Color, CursorKind, Modifier, Rect, Style},
+    icons::ICONS,
     input::{KeyEvent, MouseButton, MouseEvent, MouseEventKind},
     keyboard::{KeyCode, KeyModifiers},
     Document, Editor, Theme, View,
@@ -647,7 +648,21 @@ impl EditorView {
                 bufferline_inactive
             };
 
-            let text = format!(" {}{} ", fname, if doc.is_modified() { "[+]" } else { "" });
+            let lang = doc.language_name().unwrap_or(DEFAULT_LANGUAGE_NAME);
+
+            let icons = ICONS.load();
+            let icon = icons.mime().get(lang);
+
+            let text = if lang == icon {
+                format!(" {} {}", fname, if doc.is_modified() { "[+] " } else { "" })
+            } else {
+                format!(
+                    " {icon} {} {}",
+                    fname,
+                    if doc.is_modified() { "[+] " } else { "" }
+                )
+            };
+
             let used_width = viewport.x.saturating_sub(x);
             let rem_width = surface.area.width.saturating_sub(used_width);
 

helix-term/src/ui/statusline.rs

@@ -1,6 +1,7 @@
 use helix_core::{coords_at_pos, encoding, Position};
 use helix_lsp::lsp::DiagnosticSeverity;
 use helix_view::document::DEFAULT_LANGUAGE_NAME;
+use helix_view::icons::ICONS;
 use helix_view::{
     document::{Mode, SCRATCH_BUFFER_NAME},
     graphics::Rect,
@@ -240,10 +241,12 @@ where
             counts
         });
 
+    let icons = ICONS.load();
+
     if warnings > 0 {
         write(
             context,
-            "●".to_string(),
+            icons.diagnostic().warning().to_string(),
             Some(context.editor.theme.get("warning")),
         );
         write(context, format!(" {} ", warnings), None);
@@ -252,7 +255,7 @@ where
     if errors > 0 {
         write(
             context,
-            "●".to_string(),
+            icons.diagnostic().error().to_string(),
             Some(context.editor.theme.get("error")),
         );
         write(context, format!(" {} ", errors), None);
@@ -282,10 +285,12 @@ where
         write(context, " W ".into(), None);
     }
 
+    let icons = ICONS.load();
+
     if warnings > 0 {
         write(
             context,
-            "●".to_string(),
+            icons.diagnostic().warning().to_string(),
             Some(context.editor.theme.get("warning")),
         );
         write(context, format!(" {} ", warnings), None);
@@ -294,7 +299,7 @@ where
     if errors > 0 {
         write(
             context,
-            "●".to_string(),
+            icons.diagnostic().error().to_string(),
             Some(context.editor.theme.get("error")),
         );
         write(context, format!(" {} ", errors), None);
@@ -410,9 +415,13 @@ fn render_file_type<F>(context: &mut RenderContext, write: F)
 where
     F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
 {
-    let file_type = context.doc.language_name().unwrap_or(DEFAULT_LANGUAGE_NAME);
+    let icons = ICONS.load();
 
-    write(context, format!(" {} ", file_type), None);
+    let icon = icons
+        .mime()
+        .get(context.doc.language_name().unwrap_or(DEFAULT_LANGUAGE_NAME));
+
+    write(context, format!(" {} ", icon), None);
 }
 
 fn render_file_name<F>(context: &mut RenderContext, write: F)
@@ -514,13 +523,18 @@ fn render_version_control<F>(context: &mut RenderContext, write: F)
 where
     F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
 {
-    let head = context
+    let head = context.doc.version_control_head().unwrap_or_default();
-        .doc
-        .version_control_head()
-        .unwrap_or_default()
-        .to_string();
 
-    write(context, head, None);
+    let icons = ICONS.load();
+    let icon = icons.vcs().icon();
+
+    let vcs = if head.is_empty() {
+        format!("{head}")
+    } else {
+        format!("{icon} {head}")
+    };
+
+    write(context, vcs, None);
 }
 
 fn render_register<F>(context: &mut RenderContext, write: F)

helix-term/src/ui/text_decorations/diagnostics.rs

@@ -9,6 +9,7 @@ use helix_view::annotations::diagnostics::{
     DiagnosticFilter, InlineDiagnosticAccumulator, InlineDiagnosticsConfig,
 };
 
+use helix_view::icons::ICONS;
 use helix_view::theme::Style;
 use helix_view::{Document, Theme};
 
@@ -102,6 +103,24 @@ impl Renderer<'_, '_> {
         let mut end_col = start_col;
         let mut draw_col = (col + 1) as u16;
 
+        // Draw the diagnostic indicator:
+        if !self.renderer.column_in_bounds(draw_col as usize, 2) {
+            return 0;
+        }
+
+        let icons = ICONS.load();
+
+        let symbol = match diag.severity() {
+            Severity::Hint => icons.diagnostic().hint(),
+            Severity::Info => icons.diagnostic().info(),
+            Severity::Warning => icons.diagnostic().warning(),
+            Severity::Error => icons.diagnostic().error(),
+        };
+
+        self.renderer
+            .set_string(self.renderer.viewport.x + draw_col, row, symbol, style);
+        draw_col += 2;
+
         for line in diag.message.lines() {
             if !self.renderer.column_in_bounds(draw_col as usize, 1) {
                 break;

helix-view/Cargo.toml

@@ -52,6 +52,8 @@ log = "~0.4"
 parking_lot.workspace = true
 thiserror.workspace = true
 
+smartstring = { version = "1.0.1", features = ["serde"]}
+
 [target.'cfg(windows)'.dependencies]
 clipboard-win = { version = "5.4", features = ["std"] }
 

helix-view/src/gutter.rs

@@ -5,6 +5,7 @@ use helix_core::syntax::LanguageServerFeature;
 use crate::{
     editor::GutterType,
     graphics::{Style, UnderlineStyle},
+    icons::ICONS,
     Document, Editor, Theme, View,
 };
 
@@ -46,7 +47,6 @@ impl GutterType {
 }
 
 pub fn diagnostic<'doc>(
-    _editor: &'doc Editor,
     doc: &'doc Document,
     _view: &View,
     theme: &Theme,
@@ -74,15 +74,20 @@ pub fn diagnostic<'doc>(
                                 .any(|ls| ls.id() == id)
                         })
                 });
-            diagnostics_on_line.max_by_key(|d| d.severity).map(|d| {
+
-                write!(out, "●").ok();
+            diagnostics_on_line
-                match d.severity {
+                .max_by_key(|d| d.severity)
-                    Some(Severity::Error) => error,
+                .map(move |d| {
-                    Some(Severity::Warning) | None => warning,
+                    let icons = ICONS.load();
-                    Some(Severity::Info) => info,
+                    let (style, symbol) = match d.severity {
-                    Some(Severity::Hint) => hint,
+                        Some(Severity::Error) => (error, icons.diagnostic().error()),
-                }
+                        Some(Severity::Warning) | None => (warning, icons.diagnostic().warning()),
-            })
+                        Some(Severity::Info) => (info, icons.diagnostic().info()),
+                        Some(Severity::Hint) => (hint, icons.diagnostic().hint()),
+                    };
+                    out.push_str(symbol);
+                    style
+                })
         },
     )
 }
@@ -264,7 +269,13 @@ pub fn breakpoints<'doc>(
                 breakpoint_style
             };
 
-            let sym = if breakpoint.verified { "●" } else { "◯" };
+            let icons = ICONS.load();
+
+            let sym = if breakpoint.verified {
+                icons.dap().verified()
+            } else {
+                icons.dap().unverified()
+            };
             write!(out, "{}", sym).unwrap();
             Some(style)
         },
@@ -313,7 +324,7 @@ pub fn diagnostics_or_breakpoints<'doc>(
     theme: &Theme,
     is_focused: bool,
 ) -> GutterFn<'doc> {
-    let mut diagnostics = diagnostic(editor, doc, view, theme, is_focused);
+    let mut diagnostics = diagnostic(doc, view, theme, is_focused);
     let mut breakpoints = breakpoints(editor, doc, view, theme, is_focused);
     let mut execution_pause_indicator = execution_pause_indicator(editor, doc, theme, is_focused);
 

helix-view/src/icons.rs

@@ -0,0 +1,649 @@
+use arc_swap::ArcSwap;
+use once_cell::sync::Lazy;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+use smartstring::{LazyCompact, SmartString};
+
+type String = SmartString<LazyCompact>;
+
+pub static ICONS: Lazy<ArcSwap<Icons>> = Lazy::new(ArcSwap::default);
+
+// TODO: Snippet {enabled, icon  }
+// TODO: Text/Spellcheck { enabled, icon 󰓆 }
+
+/// Centralized location for icons that can be used throughout the UI.
+#[derive(Debug, Default, Deserialize, PartialEq, Eq, Clone)]
+#[serde(default)]
+pub struct Icons {
+    mime: Mime,
+    lsp: Lsp,
+    diagnostic: Diagnostic,
+    vcs: Vcs,
+    dap: Dap,
+}
+
+impl Icons {
+    #[inline]
+    pub fn mime(&self) -> &Mime {
+        &self.mime
+    }
+
+    #[inline]
+    pub fn lsp(&self) -> &Lsp {
+        &self.lsp
+    }
+
+    #[inline]
+    pub fn diagnostic(&self) -> &Diagnostic {
+        &self.diagnostic
+    }
+
+    #[inline]
+    pub fn vcs(&self) -> &Vcs {
+        &self.vcs
+    }
+
+    #[inline]
+    pub fn dap(&self) -> &Dap {
+        &self.dap
+    }
+}
+
+// https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_documentSymbol
+#[derive(Debug, Serialize, Deserialize, Default, PartialEq, Eq, Clone)]
+pub struct Lsp {
+    enabled: bool,
+
+    file: Option<String>,
+    module: Option<String>,
+    namespace: Option<String>,
+    package: Option<String>,
+    class: Option<String>,
+    method: Option<String>,
+    property: Option<String>,
+    field: Option<String>,
+    constructor: Option<String>,
+    #[serde(rename = "enum")]
+    r#enum: Option<String>,
+    interface: Option<String>,
+    function: Option<String>,
+    variable: Option<String>,
+    constant: Option<String>,
+    string: Option<String>,
+    number: Option<String>,
+    boolean: Option<String>,
+    array: Option<String>,
+    object: Option<String>,
+    key: Option<String>,
+    null: Option<String>,
+    enum_member: Option<String>,
+    #[serde(rename = "struct")]
+    r#struct: Option<String>,
+    event: Option<String>,
+    operator: Option<String>,
+    type_parameter: Option<String>,
+
+    color: Option<String>,
+    keyword: Option<String>,
+    value: Option<String>,
+    snippet: Option<String>,
+}
+
+impl Lsp {
+    #[inline]
+    #[must_use]
+    pub fn get(&self, kind: &str) -> Option<String> {
+        if !self.enabled {
+            return None;
+        }
+
+        let symbol = match kind {
+            "file" => self.file(),
+            "module" => self.module(),
+            "namespace" => self.namespace(),
+            "package" => self.package(),
+            "class" => self.class(),
+            "method" => self.method(),
+            "property" => self.property(),
+            "field" => self.field(),
+            "construct" => self.constructor(),
+            "enum" => self.r#enum(),
+            "interface" => self.interface(),
+            "function" => self.function(),
+            "variable" => self.variable(),
+            "constant" => self.constant(),
+            "string" => self.string(),
+            "number" => self.number(),
+            "boolean" => self.boolean(),
+            "array" => self.array(),
+            "object" => self.object(),
+            "key" => self.key(),
+            "null" => self.null(),
+            "enummem" | "enum_member" => self.enum_member(),
+            "struct" => self.r#struct(),
+            "event" => self.event(),
+            "operator" => self.operator(),
+            "typeparam" => self.type_parameter(),
+
+            "color" => self.color(),
+            "keyword" => self.keyword(),
+            "value" => self.value(),
+            "snippet" => self.snippet(),
+
+            _ => return None,
+        };
+
+        Some(String::from(symbol))
+    }
+
+    #[inline]
+    pub fn file(&self) -> &str {
+        if self.enabled {
+            return self.file.as_ref().map_or("", |file| file);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn module(&self) -> &str {
+        if self.enabled {
+            return self.module.as_ref().map_or("", |module| module);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn namespace(&self) -> &str {
+        if self.enabled {
+            return self.namespace.as_ref().map_or("", |namespace| namespace);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn package(&self) -> &str {
+        if self.enabled {
+            return self.package.as_ref().map_or("", |package| package);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn class(&self) -> &str {
+        if self.enabled {
+            return self.class.as_ref().map_or("", |class| class);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn method(&self) -> &str {
+        if self.enabled {
+            return self.method.as_ref().map_or("", |method| method);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn property(&self) -> &str {
+        if self.enabled {
+            return self.property.as_ref().map_or("", |property| property);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn field(&self) -> &str {
+        if self.enabled {
+            return self.field.as_ref().map_or("", |field| field);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn constructor(&self) -> &str {
+        if self.enabled {
+            return self
+                .constructor
+                .as_ref()
+                .map_or("", |constructor| constructor);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn r#enum(&self) -> &str {
+        if self.enabled {
+            return self.r#enum.as_ref().map_or("", |r#enum| r#enum);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn interface(&self) -> &str {
+        if self.enabled {
+            return self.interface.as_ref().map_or("", |interface| interface);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn function(&self) -> &str {
+        if self.enabled {
+            return self.function.as_ref().map_or("", |function| function);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn variable(&self) -> &str {
+        if self.enabled {
+            return self.variable.as_ref().map_or("", |variable| variable);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn constant(&self) -> &str {
+        if self.enabled {
+            return self.constant.as_ref().map_or("", |constant| constant);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn string(&self) -> &str {
+        if self.enabled {
+            return self.string.as_ref().map_or("", |string| string);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn number(&self) -> &str {
+        if self.enabled {
+            return self.number.as_ref().map_or("", |number| number);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn boolean(&self) -> &str {
+        if self.enabled {
+            return self.boolean.as_ref().map_or("", |boolean| boolean);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn array(&self) -> &str {
+        if self.enabled {
+            return self.array.as_ref().map_or("", |array| array);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn object(&self) -> &str {
+        if self.enabled {
+            return self.object.as_ref().map_or("", |object| object);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn key(&self) -> &str {
+        if self.enabled {
+            return self.key.as_ref().map_or("", |key| key);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn null(&self) -> &str {
+        if self.enabled {
+            return self.null.as_ref().map_or("󰟢", |null| null);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn enum_member(&self) -> &str {
+        if self.enabled {
+            return self
+                .enum_member
+                .as_ref()
+                .map_or("", |enum_member| enum_member);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn r#struct(&self) -> &str {
+        if self.enabled {
+            return self.r#struct.as_ref().map_or("", |r#struct| r#struct);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn event(&self) -> &str {
+        if self.enabled {
+            return self.event.as_ref().map_or("", |event| event);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn operator(&self) -> &str {
+        if self.enabled {
+            return self.operator.as_ref().map_or("", |operator| operator);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn type_parameter(&self) -> &str {
+        if self.enabled {
+            return self
+                .type_parameter
+                .as_ref()
+                .map_or("", |type_parameter| type_parameter);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn color(&self) -> &str {
+        if self.enabled {
+            return self.color.as_ref().map_or("■", |color| color);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn keyword(&self) -> &str {
+        if self.enabled {
+            return self.keyword.as_ref().map_or("", |keyword| keyword);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn value(&self) -> &str {
+        if self.enabled {
+            return self.value.as_ref().map_or("󰎠", |value| value);
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn snippet(&self) -> &str {
+        if self.enabled {
+            return self.snippet.as_ref().map_or("", |snippet| snippet);
+        }
+        ""
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Default)]
+pub struct Diagnostic {
+    hint: Option<String>,
+    info: Option<String>,
+    warning: Option<String>,
+    error: Option<String>,
+}
+
+impl Diagnostic {
+    #[inline]
+    pub fn hint(&self) -> &str {
+        self.hint.as_ref().map_or("○", |hint| hint)
+    }
+
+    #[inline]
+    pub fn info(&self) -> &str {
+        self.info.as_ref().map_or("●", |info| info)
+    }
+
+    #[inline]
+    pub fn warning(&self) -> &str {
+        self.warning.as_ref().map_or("▲", |warning| warning)
+    }
+
+    #[inline]
+    pub fn error(&self) -> &str {
+        self.error.as_ref().map_or("■", |error| error)
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Default)]
+pub struct Vcs {
+    enabled: bool,
+    icon: Option<String>,
+    added: Option<String>,
+    removed: Option<String>,
+    ignored: Option<String>,
+    modified: Option<String>,
+    renamed: Option<String>,
+    conflict: Option<String>,
+}
+
+impl Vcs {
+    #[inline]
+    pub fn icon(&self) -> &str {
+        if self.enabled {
+            return self.icon.as_ref().map_or("", |icon| icon.as_str());
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn added(&self) -> &str {
+        if self.enabled {
+            return self.added.as_ref().map_or("", |added| added.as_str());
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn removed(&self) -> &str {
+        if self.enabled {
+            return self
+                .removed
+                .as_ref()
+                .map_or("", |removed| removed.as_str());
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn ignored(&self) -> &str {
+        if self.enabled {
+            return self
+                .ignored
+                .as_ref()
+                .map_or("", |ignored| ignored.as_str());
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn modified(&self) -> &str {
+        if self.enabled {
+            return self
+                .modified
+                .as_ref()
+                .map_or("", |modified| modified.as_str());
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn renamed(&self) -> &str {
+        if self.enabled {
+            return self
+                .renamed
+                .as_ref()
+                .map_or("", |renamed| renamed.as_str());
+        }
+        ""
+    }
+
+    #[inline]
+    pub fn conflict(&self) -> &str {
+        if self.enabled {
+            return self
+                .conflict
+                .as_ref()
+                .map_or("", |conflict| conflict.as_str());
+        }
+        ""
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Default)]
+pub struct Mime {
+    enabled: bool,
+    directory: Option<String>,
+    #[serde(flatten)]
+    mime: HashMap<String, String>,
+}
+
+static MIMES: once_cell::sync::Lazy<HashMap<String, String>> = once_cell::sync::Lazy::new(|| {
+    let mut mimes = HashMap::new();
+
+    mimes.insert(String::from("rust"), String::from("󱘗"));
+    mimes.insert(String::from("python"), String::from("󰌠"));
+    mimes.insert(String::from("c"), String::from(""));
+    mimes.insert(String::from("cpp"), String::from(""));
+    mimes.insert(String::from("c-sharp"), String::from("󰌛"));
+    mimes.insert(String::from("d"), String::from(""));
+    mimes.insert(String::from("elixir"), String::from(""));
+    mimes.insert(String::from("fsharp"), String::from(""));
+    mimes.insert(String::from("go"), String::from("󰟓"));
+    mimes.insert(String::from("haskell"), String::from("󰲒"));
+    mimes.insert(String::from("java"), String::from("󰬷"));
+    mimes.insert(String::from("javascript"), String::from("󰌞"));
+    mimes.insert(String::from("kotlin"), String::from("󱈙"));
+    mimes.insert(String::from("html"), String::from("󰌝"));
+    mimes.insert(String::from("css"), String::from("󰌜"));
+    mimes.insert(String::from("scss"), String::from("󰌜"));
+    mimes.insert(String::from("typescript"), String::from("󰛦"));
+    mimes.insert(String::from("bash"), String::from(""));
+    mimes.insert(String::from("php"), String::from("󰌟"));
+    mimes.insert(String::from("powershell"), String::from("󰨊"));
+    mimes.insert(String::from("dart"), String::from(""));
+    mimes.insert(String::from("ruby"), String::from("󰴭"));
+    mimes.insert(String::from("swift"), String::from("󰛥"));
+    mimes.insert(String::from("r"), String::from("󰟔"));
+    mimes.insert(String::from("groovy"), String::from(""));
+    mimes.insert(String::from("scala"), String::from(""));
+    mimes.insert(String::from("perl"), String::from(""));
+    mimes.insert(String::from("clojure"), String::from(""));
+    mimes.insert(String::from("julia"), String::from(""));
+    mimes.insert(String::from("zig"), String::from(""));
+    mimes.insert(String::from("fortran"), String::from("󱈚"));
+    mimes.insert(String::from("erlang"), String::from(""));
+    mimes.insert(String::from("ocaml"), String::from(""));
+    mimes.insert(String::from("crystal"), String::from(""));
+    mimes.insert(String::from("svelte"), String::from(""));
+    mimes.insert(String::from("gdscript"), String::from(""));
+    mimes.insert(String::from("nim"), String::from(""));
+    mimes.insert(String::from("jsx"), String::from(""));
+    mimes.insert(String::from("tsx"), String::from(""));
+    mimes.insert(String::from("twig"), String::from(""));
+    mimes.insert(String::from("lua"), String::from(""));
+    mimes.insert(String::from("vue"), String::from(""));
+    mimes.insert(String::from("prolog"), String::from(""));
+    mimes.insert(String::from("common-lisp"), String::from(""));
+    mimes.insert(String::from("elm"), String::from(""));
+    mimes.insert(String::from("rescript"), String::from(""));
+    mimes.insert(String::from("solidity"), String::from(""));
+    mimes.insert(String::from("vala"), String::from(""));
+    mimes.insert(String::from("scheme"), String::from(""));
+    mimes.insert(String::from("v"), String::from(""));
+    mimes.insert(String::from("prisma"), String::from(""));
+    mimes.insert(String::from("ada"), String::from(""));
+    mimes.insert(String::from("astro"), String::from(""));
+    mimes.insert(String::from("matlab"), String::from(""));
+    mimes.insert(String::from("rst"), String::from(""));
+    mimes.insert(String::from("opencl"), String::from(""));
+    mimes.insert(String::from("nunjuks"), String::from(""));
+    mimes.insert(String::from("jinja"), String::from(""));
+
+    mimes.insert(String::from("bicep"), String::from(""));
+
+    mimes.insert(String::from("wasm"), String::from(""));
+
+    mimes.insert(String::from("docker"), String::from("󰡨"));
+    mimes.insert(String::from("docker-compose"), String::from("󰡨"));
+    mimes.insert(String::from("make"), String::from(""));
+    mimes.insert(String::from("cmake"), String::from(""));
+    mimes.insert(String::from("nix"), String::from(""));
+    mimes.insert(String::from("awk"), String::from(""));
+    mimes.insert(String::from("llvm"), String::from(""));
+    mimes.insert(String::from("llvm-mir"), String::from(""));
+    mimes.insert(String::from("regex"), String::from(""));
+    mimes.insert(String::from("graphql"), String::from(""));
+
+    mimes.insert(String::from("text"), String::from(""));
+    mimes.insert(String::from("markdown"), String::from(""));
+    mimes.insert(String::from("typst"), String::from(""));
+    mimes.insert(String::from("json"), String::from("󰘦"));
+    mimes.insert(String::from("toml"), String::from(""));
+    mimes.insert(String::from("xml"), String::from("󰗀"));
+    mimes.insert(String::from("latex"), String::from(""));
+    mimes.insert(String::from("git-commit"), String::from(""));
+    mimes.insert(String::from("git-rebase"), String::from(""));
+    mimes.insert(String::from("git-config"), String::from(""));
+    mimes.insert(String::from("todotxt"), String::from(""));
+    mimes.insert(String::from("hyprlang"), String::from(""));
+    mimes.insert(String::from("helm"), String::from(""));
+    mimes.insert(String::from("nginx"), String::from(""));
+
+    mimes
+});
+
+impl Mime {
+    #[inline]
+    pub fn directory(&self) -> &str {
+        if self.enabled {
+            return self.directory.as_ref().map_or("󰉋", |directory| directory);
+        } else if let Some(directory) = &self.directory {
+            return directory;
+        }
+        ""
+    }
+
+    // Returns the symbol that matches the name, if any, otherwise returns the name back.
+    #[inline]
+    pub fn get<'name, 'mime: 'name>(&'mime self, name: &'name str) -> &'name str {
+        if self.enabled {
+            if let Some(symbol) = self.mime.get(name) {
+                return symbol;
+            } else if let Some(symbol) = MIMES.get(name) {
+                return symbol;
+            }
+        }
+        name
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Default)]
+pub struct Dap {
+    verified: Option<String>,
+    unverified: Option<String>,
+}
+
+impl Dap {
+    #[inline]
+    pub fn verified(&self) -> &str {
+        self.verified.as_ref().map_or("●", |verified| verified)
+    }
+
+    #[inline]
+    pub fn unverified(&self) -> &str {
+        self.verified.as_ref().map_or("◯", |verified| verified)
+    }
+}

helix-view/src/lib.rs

@@ -11,6 +11,7 @@ pub mod expansion;
 pub mod graphics;
 pub mod gutter;
 pub mod handlers;
+pub mod icons;
 pub mod info;
 pub mod input;
 pub mod keyboard;