mirrors/helix
1
0
Fork 0
mirror of https://github.com/helix-editor/helix.git synced 2025-04-04 03:17:45 +03:00
Code Issues Projects Releases Packages Wiki Activity

Merge d561230a52 into 7ebf650029

Browse source
This commit is contained in:
rhogenson 2025-04-01 09:15:15 +02:00 • committed by GitHub
commit 7110df3089
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 272 additions and 158 deletions
Download patch file Download diff file Expand all files Collapse all files

9
helix-core/src/command_line.rs
View file

@ -366,6 +366,15 @@ impl Token<'_> {
is_terminated: false,
}
}
pub fn deep_clone(&self) -> Token<'static> {
Token {
kind: self.kind,
content_start: self.content_start,
content: Cow::Owned(self.content.to_string()),
is_terminated: self.is_terminated,
}
}
}
#[derive(Debug)]

46
helix-term/src/commands/typed.rs
View file

@ -15,7 +15,7 @@ use helix_view::document::{read_to_string, DEFAULT_LANGUAGE_NAME};
use helix_view::editor::{CloseError, ConfigEvent};
use helix_view::expansion;
use serde_json::Value;
use ui::completers::{self, Completer};
use ui::completers::{self, Completer, CompletionResult};
#[derive(Clone)]
pub struct TypableCommand {
@ -3698,7 +3698,7 @@ fn command_line_doc(input: &str) -> Option<Cow<str>> {
Some(Cow::Owned(doc))
}
fn complete_command_line(editor: &Editor, input: &str) -> Vec<ui::prompt::Completion> {
fn complete_command_line(editor: &Editor, input: &str) -> CompletionResult {
let (command, rest, complete_command) = command_line::split(input);
if complete_command {
@ -3713,7 +3713,7 @@ fn complete_command_line(editor: &Editor, input: &str) -> Vec<ui::prompt::Comple
} else {
TYPABLE_COMMAND_MAP
.get(command)
.map_or_else(Vec::new, |cmd| {
.map_or(CompletionResult::Immediate(Vec::new()), |cmd| {
let args_offset = command.len() + 1;
complete_command_args(editor, cmd, rest, args_offset)
})
@ -3725,7 +3725,7 @@ fn complete_command_args(
command: &TypableCommand,
input: &str,
offset: usize,
) -> Vec<ui::prompt::Completion> {
) -> CompletionResult {
use command_line::{CompletionState, ExpansionKind, Tokenizer};
// TODO: completion should depend on the location of the cursor instead of the end of the
@ -3765,7 +3765,7 @@ fn complete_command_args(
// Don't complete on closed tokens, for example after writing a closing double quote.
if token.is_terminated {
return Vec::new();
return CompletionResult::Immediate(Vec::new());
}
match token.kind {
@ -3780,10 +3780,15 @@ fn complete_command_args(
.expect("completion state to be positional");
let completer = command.completer_for_argument_number(n);
completer(editor, &token.content)
.into_iter()
.map(|(range, span)| quote_completion(&token, range, span, offset))
.collect()
completer(editor, &token.content).map({
let token = token.deep_clone();
move |completions| {
completions
.into_iter()
.map(|(range, span)| quote_completion(&token, range, span, offset))
.collect()
}
})
}
CompletionState::Flag(_) => fuzzy_match(
token.content.trim_start_matches('-'),
@ -3819,7 +3824,7 @@ fn complete_command_args(
TokenKind::Expansion(ExpansionKind::Variable) => {
complete_variable_expansion(&token.content, offset + token.content_start)
}
TokenKind::Expansion(ExpansionKind::Unicode) => Vec::new(),
TokenKind::Expansion(ExpansionKind::Unicode) => CompletionResult::Immediate(Vec::new()),
TokenKind::ExpansionKind => {
complete_expansion_kind(&token.content, offset + token.content_start)
}
@ -3877,7 +3882,7 @@ fn complete_expand(
token: &Token,
completer: Option<&Completer>,
offset: usize,
) -> Vec<ui::prompt::Completion> {
) -> CompletionResult {
use command_line::{ExpansionKind, Tokenizer};
let mut start = 0;
@ -3922,15 +3927,20 @@ fn complete_expand(
match completer {
// If no expansions were found and an argument is being completed,
Some(completer) if start == 0 => completer(editor, &token.content)
.into_iter()
.map(|(range, span)| quote_completion(token, range, span, offset))
.collect(),
_ => Vec::new(),
Some(completer) if start == 0 => completer(editor, &token.content).map({
let token = token.deep_clone();
move |completions| {
completions
.into_iter()
.map(|(range, span)| quote_completion(&token, range, span, offset))
.collect()
}
}),
_ => CompletionResult::Immediate(Vec::new()),
}
}
fn complete_variable_expansion(content: &str, offset: usize) -> Vec<ui::prompt::Completion> {
fn complete_variable_expansion(content: &str, offset: usize) -> CompletionResult {
use expansion::Variable;
fuzzy_match(
@ -3943,7 +3953,7 @@ fn complete_variable_expansion(content: &str, offset: usize) -> Vec<ui::prompt::
.collect()
}
fn complete_expansion_kind(content: &str, offset: usize) -> Vec<ui::prompt::Completion> {
fn complete_expansion_kind(content: &str, offset: usize) -> CompletionResult {
use command_line::ExpansionKind;
fuzzy_match(

284
helix-term/src/ui/mod.rs
View file

@ -17,6 +17,7 @@ mod text_decorations;
use crate::compositor::Compositor;
use crate::filter_picker_entry;
use crate::job::{self, Callback};
use crate::ui::completers::CompletionResult;
pub use completion::Completion;
pub use editor::EditorView;
use helix_stdx::rope;
@ -50,7 +51,7 @@ pub fn prompt(
cx: &mut crate::commands::Context,
prompt: std::borrow::Cow<'static, str>,
history_register: Option<char>,
completion_fn: impl FnMut(&Editor, &str) -> Vec<prompt::Completion> + 'static,
completion_fn: impl FnMut(&Editor, &str) -> CompletionResult + 'static,
callback_fn: impl FnMut(&mut crate::compositor::Context, &str, PromptEvent) + 'static,
) {
let mut prompt = Prompt::new(prompt, history_register, completion_fn, callback_fn);
@ -59,24 +60,11 @@ pub fn prompt(
cx.push_layer(Box::new(prompt));
}
pub fn prompt_with_input(
cx: &mut crate::commands::Context,
prompt: std::borrow::Cow<'static, str>,
input: String,
history_register: Option<char>,
completion_fn: impl FnMut(&Editor, &str) -> Vec<prompt::Completion> + 'static,
callback_fn: impl FnMut(&mut crate::compositor::Context, &str, PromptEvent) + 'static,
) {
let prompt = Prompt::new(prompt, history_register, completion_fn, callback_fn)
.with_line(input, cx.editor);
cx.push_layer(Box::new(prompt));
}
pub fn regex_prompt(
cx: &mut crate::commands::Context,
prompt: std::borrow::Cow<'static, str>,
history_register: Option<char>,
completion_fn: impl FnMut(&Editor, &str) -> Vec<prompt::Completion> + 'static,
completion_fn: impl FnMut(&Editor, &str) -> CompletionResult + 'static,
fun: impl Fn(&mut crate::compositor::Context, rope::Regex, PromptEvent) + 'static,
) {
raw_regex_prompt(
@ -91,7 +79,7 @@ pub fn raw_regex_prompt(
cx: &mut crate::commands::Context,
prompt: std::borrow::Cow<'static, str>,
history_register: Option<char>,
completion_fn: impl FnMut(&Editor, &str) -> Vec<prompt::Completion> + 'static,
completion_fn: impl FnMut(&Editor, &str) -> CompletionResult + 'static,
fun: impl Fn(&mut crate::compositor::Context, rope::Regex, &str, PromptEvent) + 'static,
) {
let (view, doc) = current!(cx.editor);
@ -380,13 +368,40 @@ pub mod completers {
use std::borrow::Cow;
use tui::text::Span;
pub type Completer = fn(&Editor, &str) -> Vec<Completion>;
pub fn none(_editor: &Editor, _input: &str) -> Vec<Completion> {
Vec::new()
pub enum CompletionResult {
Immediate(Vec<Completion>),
Callback(Box<dyn FnOnce() -> Vec<Completion> + Send + Sync>),
}
pub fn buffer(editor: &Editor, input: &str) -> Vec<Completion> {
fn callback(f: impl FnOnce() -> Vec<Completion> + Send + Sync + 'static) -> CompletionResult {
CompletionResult::Callback(Box::new(f))
}
impl CompletionResult {
pub fn map(
self,
f: impl FnOnce(Vec<Completion>) -> Vec<Completion> + Send + Sync + 'static,
) -> CompletionResult {
match self {
CompletionResult::Immediate(v) => CompletionResult::Immediate(f(v)),
CompletionResult::Callback(v) => callback(move || f(v())),
}
}
}
impl FromIterator<Completion> for CompletionResult {
fn from_iter<T: IntoIterator<Item = Completion>>(items: T) -> Self {
Self::Immediate(items.into_iter().collect())
}
}
pub type Completer = fn(&Editor, &str) -> CompletionResult;
pub fn none(_editor: &Editor, _input: &str) -> CompletionResult {
CompletionResult::Immediate(Vec::new())
}
pub fn buffer(editor: &Editor, input: &str) -> CompletionResult {
let names = editor.documents.values().map(|doc| {
doc.relative_path()
.map(|p| p.display().to_string().into())
@ -399,20 +414,23 @@ pub mod completers {
.collect()
}
pub fn theme(_editor: &Editor, input: &str) -> Vec<Completion> {
let mut names = theme::Loader::read_names(&helix_loader::config_dir().join("themes"));
for rt_dir in helix_loader::runtime_dirs() {
names.extend(theme::Loader::read_names(&rt_dir.join("themes")));
}
names.push("default".into());
names.push("base16_default".into());
names.sort();
names.dedup();
pub fn theme(_editor: &Editor, input: &str) -> CompletionResult {
let input = String::from(input);
callback(move || {
let mut names = theme::Loader::read_names(&helix_loader::config_dir().join("themes"));
for rt_dir in helix_loader::runtime_dirs() {
names.extend(theme::Loader::read_names(&rt_dir.join("themes")));
}
names.push("default".into());
names.push("base16_default".into());
names.sort();
names.dedup();
fuzzy_match(input, names, false)
.into_iter()
.map(|(name, _)| ((0..), name.into()))
.collect()
fuzzy_match(&input, names, false)
.into_iter()
.map(|(name, _)| ((0..), name.into()))
.collect()
})
}
/// Recursive function to get all keys from this value and add them to vec
@ -432,7 +450,7 @@ pub mod completers {
}
/// Completes names of language servers which are running for the current document.
pub fn active_language_servers(editor: &Editor, input: &str) -> Vec<Completion> {
pub fn active_language_servers(editor: &Editor, input: &str) -> CompletionResult {
let language_servers = doc!(editor).language_servers().map(|ls| ls.name());
fuzzy_match(input, language_servers, false)
@ -443,7 +461,7 @@ pub mod completers {
/// Completes names of language servers which are configured for the language of the current
/// document.
pub fn configured_language_servers(editor: &Editor, input: &str) -> Vec<Completion> {
pub fn configured_language_servers(editor: &Editor, input: &str) -> CompletionResult {
let language_servers = doc!(editor)
.language_config()
.into_iter()
@ -456,7 +474,7 @@ pub mod completers {
.collect()
}
pub fn setting(_editor: &Editor, input: &str) -> Vec<Completion> {
pub fn setting(_editor: &Editor, input: &str) -> CompletionResult {
static KEYS: Lazy<Vec<String>> = Lazy::new(|| {
let mut keys = Vec::new();
let json = serde_json::json!(Config::default());
@ -470,7 +488,7 @@ pub mod completers {
.collect()
}
pub fn filename(editor: &Editor, input: &str) -> Vec<Completion> {
pub fn filename(editor: &Editor, input: &str) -> CompletionResult {
filename_with_git_ignore(editor, input, true)
}
@ -478,7 +496,7 @@ pub mod completers {
editor: &Editor,
input: &str,
git_ignore: bool,
) -> Vec<Completion> {
) -> CompletionResult {
filename_impl(editor, input, git_ignore, |entry| {
let is_dir = entry.file_type().is_some_and(|entry| entry.is_dir());
@ -490,7 +508,7 @@ pub mod completers {
})
}
pub fn language(editor: &Editor, input: &str) -> Vec<Completion> {
pub fn language(editor: &Editor, input: &str) -> CompletionResult {
let text: String = "text".into();
let loader = editor.syn_loader.load();
@ -505,7 +523,7 @@ pub mod completers {
.collect()
}
pub fn lsp_workspace_command(editor: &Editor, input: &str) -> Vec<Completion> {
pub fn lsp_workspace_command(editor: &Editor, input: &str) -> CompletionResult {
let commands = doc!(editor)
.language_servers_with_feature(LanguageServerFeature::WorkspaceCommand)
.flat_map(|ls| {
@ -521,7 +539,7 @@ pub mod completers {
.collect()
}
pub fn directory(editor: &Editor, input: &str) -> Vec<Completion> {
pub fn directory(editor: &Editor, input: &str) -> CompletionResult {
directory_with_git_ignore(editor, input, true)
}
@ -529,7 +547,7 @@ pub mod completers {
editor: &Editor,
input: &str,
git_ignore: bool,
) -> Vec<Completion> {
) -> CompletionResult {
filename_impl(editor, input, git_ignore, |entry| {
let is_dir = entry.file_type().is_some_and(|entry| entry.is_dir());
@ -558,113 +576,117 @@ pub mod completers {
input: &str,
git_ignore: bool,
filter_fn: F,
) -> Vec<Completion>
) -> CompletionResult
where
F: Fn(&ignore::DirEntry) -> FileMatch,
F: Fn(&ignore::DirEntry) -> FileMatch + Send + Sync + 'static,
{
// Rust's filename handling is really annoying.
use ignore::WalkBuilder;
use std::path::Path;
let is_tilde = input == "~";
let path = helix_stdx::path::expand_tilde(Path::new(input));
let input = String::from(input);
let directory_color = editor.theme.get("ui.text.directory");
let (dir, file_name) = if input.ends_with(std::path::MAIN_SEPARATOR) {
(path, None)
} else {
let is_period = (input.ends_with((format!("{}.", std::path::MAIN_SEPARATOR)).as_str())
&& input.len() > 2)
|| input == ".";
let file_name = if is_period {
Some(String::from("."))
callback(move || {
let is_tilde = input == "~";
let path = helix_stdx::path::expand_tilde(Path::new(&input));
let (dir, file_name) = if input.ends_with(std::path::MAIN_SEPARATOR) {
(path, None)
} else {
path.file_name()
.and_then(|file| file.to_str().map(|path| path.to_owned()))
let is_period = (input
.ends_with((format!("{}.", std::path::MAIN_SEPARATOR)).as_str())
&& input.len() > 2)
|| input == ".";
let file_name = if is_period {
Some(String::from("."))
} else {
path.file_name()
.and_then(|file| file.to_str().map(|path| path.to_owned()))
};
let path = if is_period {
path
} else {
match path.parent() {
Some(path) if !path.as_os_str().is_empty() => Cow::Borrowed(path),
// Path::new("h")'s parent is Some("")...
_ => Cow::Owned(helix_stdx::env::current_working_dir()),
}
};
(path, file_name)
};
let path = if is_period {
path
} else {
match path.parent() {
Some(path) if !path.as_os_str().is_empty() => Cow::Borrowed(path),
// Path::new("h")'s parent is Some("")...
_ => Cow::Owned(helix_stdx::env::current_working_dir()),
let end = input.len()..;
let files = WalkBuilder::new(&dir)
.hidden(false)
.follow_links(false) // We're scanning over depth 1
.git_ignore(git_ignore)
.max_depth(Some(1))
.build()
.filter_map(|file| {
file.ok().and_then(|entry| {
let fmatch = filter_fn(&entry);
if fmatch == FileMatch::Reject {
return None;
}
let is_dir = entry.file_type().is_some_and(|entry| entry.is_dir());
let path = entry.path();
let mut path = if is_tilde {
// if it's a single tilde an absolute path is displayed so that when `TAB` is pressed on
// one of the directories the tilde will be replaced with a valid path not with a relative
// home directory name.
// ~ -> <TAB> -> /home/user
// ~/ -> <TAB> -> ~/first_entry
path.to_path_buf()
} else {
path.strip_prefix(&dir).unwrap_or(path).to_path_buf()
};
if fmatch == FileMatch::AcceptIncomplete {
path.push("");
}
let path = path.into_os_string().into_string().ok()?;
Some(Utf8PathBuf { path, is_dir })
})
}) // TODO: unwrap or skip
.filter(|path| !path.path.is_empty());
let style_from_file = |file: Utf8PathBuf| {
if file.is_dir {
Span::styled(file.path, directory_color)
} else {
Span::raw(file.path)
}
};
(path, file_name)
};
// if empty, return a list of dirs and files in current dir
if let Some(file_name) = file_name {
let range = (input.len().saturating_sub(file_name.len()))..;
fuzzy_match(&file_name, files, true)
.into_iter()
.map(|(name, _)| (range.clone(), style_from_file(name)))
.collect()
let end = input.len()..;
let files = WalkBuilder::new(&dir)
.hidden(false)
.follow_links(false) // We're scanning over depth 1
.git_ignore(git_ignore)
.max_depth(Some(1))
.build()
.filter_map(|file| {
file.ok().and_then(|entry| {
let fmatch = filter_fn(&entry);
if fmatch == FileMatch::Reject {
return None;
}
let is_dir = entry.file_type().is_some_and(|entry| entry.is_dir());
let path = entry.path();
let mut path = if is_tilde {
// if it's a single tilde an absolute path is displayed so that when `TAB` is pressed on
// one of the directories the tilde will be replaced with a valid path not with a relative
// home directory name.
// ~ -> <TAB> -> /home/user
// ~/ -> <TAB> -> ~/first_entry
path.to_path_buf()
} else {
path.strip_prefix(&dir).unwrap_or(path).to_path_buf()
};
if fmatch == FileMatch::AcceptIncomplete {
path.push("");
}
let path = path.into_os_string().into_string().ok()?;
Some(Utf8PathBuf { path, is_dir })
})
}) // TODO: unwrap or skip
.filter(|path| !path.path.is_empty());
let directory_color = editor.theme.get("ui.text.directory");
let style_from_file = |file: Utf8PathBuf| {
if file.is_dir {
Span::styled(file.path, directory_color)
// TODO: complete to longest common match
} else {
Span::raw(file.path)
let mut files: Vec<_> = files
.map(|file| (end.clone(), style_from_file(file)))
.collect();
files.sort_unstable_by(|(_, path1), (_, path2)| path1.content.cmp(&path2.content));
files
}
};
// if empty, return a list of dirs and files in current dir
if let Some(file_name) = file_name {
let range = (input.len().saturating_sub(file_name.len()))..;
fuzzy_match(&file_name, files, true)
.into_iter()
.map(|(name, _)| (range.clone(), style_from_file(name)))
.collect()
// TODO: complete to longest common match
} else {
let mut files: Vec<_> = files
.map(|file| (end.clone(), style_from_file(file)))
.collect();
files.sort_unstable_by(|(_, path1), (_, path2)| path1.content.cmp(&path2.content));
files
}
})
}
pub fn register(editor: &Editor, input: &str) -> Vec<Completion> {
pub fn register(editor: &Editor, input: &str) -> CompletionResult {
let iter = editor
.registers
.iter_preview()

91
helix-term/src/ui/prompt.rs
View file

@ -1,12 +1,16 @@
use crate::compositor::{Component, Compositor, Context, Event, EventResult};
use crate::{alt, ctrl, key, shift, ui};
use crate::ui::completers::CompletionResult;
use crate::{alt, ctrl, job, key, shift, ui};
use arc_swap::ArcSwap;
use helix_core::syntax;
use helix_event::{AsyncHook, TaskController, TaskHandle};
use helix_view::document::Mode;
use helix_view::input::KeyEvent;
use helix_view::keyboard::KeyCode;
use std::sync::Arc;
use std::time::Duration;
use std::{borrow::Cow, ops::RangeFrom};
use tokio::time::Instant;
use tui::buffer::Buffer as Surface;
use tui::text::Span;
use tui::widgets::{Block, Widget};
@ -19,10 +23,39 @@ use helix_view::{
Editor,
};
type PromptCharHandler = Box<dyn Fn(&mut Prompt, char, &Context)>;
pub type Completion = (RangeFrom<usize>, Span<'static>);
type CompletionFn = Box<dyn FnMut(&Editor, &str) -> Vec<Completion>>;
struct CompletionEvent {
cancel: TaskHandle,
callback: Box<dyn FnOnce() -> Vec<Completion> + Send + Sync>,
send: std::sync::mpsc::SyncSender<Vec<Completion>>,
}
struct CompletionHandler {}
impl helix_event::AsyncHook for CompletionHandler {
type Event = CompletionEvent;
fn handle_event(&mut self, event: CompletionEvent, _: Option<Instant>) -> Option<Instant> {
if event.cancel.is_canceled() {
return None;
};
let completion = (event.callback)();
if event.send.send(completion).is_err() {
return None;
}
job::dispatch_blocking(move |_editor, compositor| {
if let Some(prompt) = compositor.find::<Prompt>() {
prompt.process_async_completion();
}
});
None
}
fn finish_debounce(&mut self) {}
}
type PromptCharHandler = Box<dyn Fn(&mut Prompt, char, &Context)>;
type CompletionFn = Box<dyn FnMut(&Editor, &str) -> CompletionResult>;
type CallbackFn = Box<dyn FnMut(&mut Context, &str, PromptEvent)>;
pub type DocFn = Box<dyn Fn(&str) -> Option<Cow<str>>>;
@ -36,11 +69,14 @@ pub struct Prompt {
truncate_start: bool,
truncate_end: bool,
// ---
completion_fn: CompletionFn,
completion_hook: tokio::sync::mpsc::Sender<CompletionEvent>,
task_controller: TaskController,
receive_completion: Option<std::sync::mpsc::Receiver<Vec<Completion>>>,
completion: Vec<Completion>,
selection: Option<usize>,
history_register: Option<char>,
history_pos: Option<usize>,
completion_fn: CompletionFn,
callback_fn: CallbackFn,
pub doc_fn: DocFn,
next_char_handler: Option<PromptCharHandler>,
@ -81,7 +117,7 @@ impl Prompt {
pub fn new(
prompt: Cow<'static, str>,
history_register: Option<char>,
completion_fn: impl FnMut(&Editor, &str) -> Vec<Completion> + 'static,
completion_fn: impl FnMut(&Editor, &str) -> CompletionResult + 'static,
callback_fn: impl FnMut(&mut Context, &str, PromptEvent) + 'static,
) -> Self {
Self {
@ -92,11 +128,14 @@ impl Prompt {
anchor: 0,
truncate_start: false,
truncate_end: false,
completion_fn: Box::new(completion_fn),
completion_hook: CompletionHandler {}.spawn(),
task_controller: TaskController::new(),
receive_completion: None,
completion: Vec::new(),
selection: None,
history_register,
history_pos: None,
completion_fn: Box::new(completion_fn),
callback_fn: Box::new(callback_fn),
doc_fn: Box::new(|_| None),
next_char_handler: None,
@ -153,8 +192,33 @@ impl Prompt {
}
pub fn recalculate_completion(&mut self, editor: &Editor) {
// Cancel any pending async completions.
let handle = self.task_controller.restart();
self.receive_completion = None;
self.exit_selection();
self.completion = (self.completion_fn)(editor, &self.line);
match (self.completion_fn)(editor, &self.line) {
CompletionResult::Immediate(completion) => self.completion = completion,
CompletionResult::Callback(f) => {
let (send_completion, recv_completion) = std::sync::mpsc::sync_channel(1);
helix_event::send_blocking(
&self.completion_hook,
CompletionEvent {
cancel: handle,
callback: f,
send: send_completion,
},
);
// To avoid flicker, give the completion handler a small timeout to
// complete immediately.
if let Ok(completion) = recv_completion.recv_timeout(Duration::from_millis(50)) {
self.completion = completion;
return;
}
self.completion.clear();
self.receive_completion = Some(recv_completion);
}
}
}
/// Compute the cursor position after applying movement
@ -394,6 +458,16 @@ impl Prompt {
pub fn exit_selection(&mut self) {
self.selection = None;
}
fn process_async_completion(&mut self) {
let Some(receive_completion) = &self.receive_completion else {
return;
};
if let Ok(completion) = receive_completion.try_recv() {
self.completion = completion;
helix_event::request_redraw();
}
}
}
const BASE_WIDTH: u16 = 30;
@ -406,7 +480,6 @@ impl Prompt {
let selected_color = theme.get("ui.menu.selected");
let suggestion_color = theme.get("ui.text.inactive");
let background = theme.get("ui.background");
// completion
let max_len = self
.completion