]

[[package]]

name = "helix-loader"

version = "0.6.0"

dependencies = [

"cassowary",

"crossterm",

"helix-core",

"serde",

"unicode-segmentation",

]

"futures-util",

"helix-core",

"helix-dap",

"helix-lsp",

"log",

"once_cell",

"serde",

"helix-view",

"helix-term",

"helix-tui",

"helix-ui",

"helix-lsp",

"helix-dap",

use crate::{

args::Args,

config::Config,

keymap::Keymaps,

ui::{self, overlay::overlayed},

};

use std::{

io::{stdin, stdout, Write},

sync::Arc,

// let area = *surface.area();

editor: &self.editor,

surface,

scroll: None,

}

pub fn handle_idle_timeout(&mut self) {

let editor_view = self

.compositor

.find::<ui::EditorView>()

.expect("expected at least one EditorView");

editor: &mut self.editor,

jobs: &mut self.jobs,

};

&mut self,

event: Option<Result<CrosstermEvent, crossterm::ErrorKind>>,

) {

editor: &mut self.editor,

jobs: &mut self.jobs,

};

Document, DocumentId, Editor, ViewId,

};

use anyhow::{anyhow, bail, ensure, Context as _};

use fuzzy_matcher::FuzzyMatcher;

use insert::*;

use crate::{

args,

ui::{self, overlay::overlayed, FilePicker, Picker, Popup, Prompt, PromptEvent},

};

use futures_util::{FutureExt, StreamExt};

use std::{collections::HashMap, fmt, future::Future};

use std::{collections::HashSet, num::NonZeroUsize};

pub count: Option<NonZeroUsize>,

pub editor: &'a mut Editor,

pub on_next_key_callback: Option<Box<dyn FnOnce(&mut Context, KeyEvent)>>,

pub jobs: &'a mut Jobs,

}

use super::{Context, Editor};

use helix_core::syntax::{DebugArgumentValue, DebugConfigCompletion};

use helix_dap::{self as dap, Client};

use helix_lsp::block_on;

use helix_view::editor::Breakpoint;

use serde_json::{to_value, Value};

use tokio_stream::wrappers::UnboundedReceiverStream;

use helix_core::Selection;

use helix_view::editor::Action;

use std::borrow::Cow;

pub mod application;

pub mod args;

pub mod commands;

pub mod config;

pub mod health;

pub mod keymap;

pub mod ui;

pub use keymap::macros::*;

use helix_view::editor::CompleteAction;

use std::borrow::Cow;

use crate::{

keymap::{KeymapResult, Keymaps},

ui::{Completion, ProgressSpinners},

};

use helix_core::{

coords_at_pos, encoding,

graphemes::{

editor.clear_idle_timer(); // don't retrigger

}

if self.completion.is_some()

|| !cx.editor.config().auto_completion

|| doc!(cx.editor).mode != Mode::Insert

fn handle_event(

&mut self,

event: Event,

) -> EventResult {

let mut cx = commands::Context {

editor: context.editor,

use tui::text::{Span, Spans, Text};

use std::sync::Arc;

};

use tui::widgets::Table;

mod completion;

pub(crate) mod editor;

mod markdown;

pub mod menu;

pub mod overlay;

prompt: std::borrow::Cow<'static, str>,

history_register: Option<char>,

completion_fn: impl FnMut(&Editor, &str) -> Vec<prompt::Completion> + 'static,

) {

let mut prompt = Prompt::new(prompt, history_register, completion_fn, callback_fn);

// Calculate initial completion

prompt,

history_register,

completion_fn,

match event {

PromptEvent::Abort => {

let (view, doc) = current!(cx.editor);

Editor,

};

/// Contains a component placed in the center of the parent component

pub struct Overlay<T> {

use crate::{

ctrl, key, shift,

ui::{self, EditorView},

};

use tui::widgets::{Block, BorderType, Borders};

use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;

use helix_core::Position;

use helix_view::{

use crate::{alt, ctrl, key, shift, ui};

use helix_view::input::KeyEvent;

use helix_view::keyboard::KeyCode;

use helix_view::graphics::Rect;

unicode-segmentation = "1.9"

crossterm = { version = "0.23", optional = true }

serde = { version = "1", "optional" = true, features = ["derive"]}

helix-core = { version = "0.6", path = "../helix-core" }

},

terminal::{self, Clear, ClearType},

};

use std::io::{self, Write};

pub struct CrosstermBackend<W: Write> {

use crate::buffer::Cell;

#[cfg(feature = "crossterm")]

mod crossterm;

buffer::{Buffer, Cell},

};

use helix_core::unicode::width::UnicodeWidthStr;

use std::{fmt::Write, io};

/// A backend used for the integration tests.

use std::cmp::min;

use unicode_segmentation::UnicodeSegmentation;

/// A buffer cell

#[derive(Debug, Clone, PartialEq)]

///

/// ```

/// use helix_tui::buffer::{Buffer, Cell};

///

/// let mut buf = Buffer::empty(Rect{x: 0, y: 0, width: 10, height: 5});

/// buf[(0, 2)].set_symbol("x");

///

/// ```

/// # use helix_tui::buffer::Buffer;

/// let rect = Rect::new(200, 100, 10, 10);

/// let buffer = Buffer::empty(rect);

/// // Global coordinates inside the Buffer's area

///

/// ```

/// # use helix_tui::buffer::Buffer;

/// let rect = Rect::new(200, 100, 10, 10);

/// let buffer = Buffer::empty(rect);

/// // Global coordinates to the top corner of this Buffer's area

///

/// ```

/// # use helix_tui::buffer::Buffer;

/// let rect = Rect::new(200, 100, 10, 10);

/// let buffer = Buffer::empty(rect);

/// assert_eq!(buffer.pos_of(0), (200, 100));

use cassowary::WeightedRelation::*;

use cassowary::{Constraint as CassowaryConstraint, Expression, Solver, Variable};

#[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]

pub enum Corner {

/// # Examples

/// ```

/// # use helix_tui::layout::{Constraint, Direction, Layout};

/// let chunks = Layout::default()

/// .direction(Direction::Vertical)

/// .constraints([Constraint::Length(5), Constraint::Min(0)].as_ref())

use crate::{backend::Backend, buffer::Buffer};

use std::io;

#[derive(Debug, Clone, PartialEq)]

//! ```rust

//! # use helix_tui::widgets::Block;

//! # use helix_tui::text::{Span, Spans};

//! // A simple string with no styling.

//! // Converted to Spans(vec![

//! // Span { content: Cow::Borrowed("My title"), style: Style { .. } }

//! ```

use helix_core::line_ending::str_is_line_ending;

use helix_core::unicode::width::UnicodeWidthStr;

use std::borrow::Cow;

use unicode_segmentation::UnicodeSegmentation;

///

/// ```rust

/// # use helix_tui::text::Span;

/// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);

/// Span::styled("My text", style);

/// Span::styled(String::from("My text"), style);

///

/// ```rust

/// # use helix_tui::text::{Span, StyledGrapheme};

/// # use std::iter::Iterator;

/// let style = Style::default().fg(Color::Yellow);

/// let span = Span::styled("Text", style);

///

/// ```rust

/// # use helix_tui::text::{Span, Spans};

/// let spans = Spans::from(vec![

/// Span::styled("My", Style::default().fg(Color::Yellow)),

/// Span::raw(" text"),

///

/// ```rust

/// # use helix_tui::text::Text;

/// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);

///

/// // An initial two lines of `Text` built from a `&str`

///

/// ```rust

/// # use helix_tui::text::Text;

/// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);

/// Text::styled("The first line\nThe second line", style);

/// Text::styled(String::from("The first line\nThe second line"), style);

///

/// ```rust

/// # use helix_tui::text::Text;

/// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);

/// let mut raw_text = Text::raw("The first line\nThe second line");

/// let styled_text = Text::styled(String::from("The first line\nThe second line"), style);

text::{Span, Spans},

widgets::{Borders, Widget},

};

#[derive(Debug, Clone, Copy, PartialEq)]

pub enum BorderType {

///

/// ```

/// # use helix_tui::widgets::{Block, BorderType, Borders};

/// Block::default()

/// .title("Block")

/// .borders(Borders::LEFT | Borders::RIGHT)

use crate::buffer::Buffer;

use bitflags::bitflags;

bitflags! {

/// Bitflags that can be composed to set the visible borders essentially on the block widget.

},

};

use helix_core::unicode::width::UnicodeWidthStr;

use std::iter;

fn get_line_offset(line_width: u16, text_area_width: u16, alignment: Alignment) -> u16 {

/// # use helix_tui::text::{Text, Spans, Span};

/// # use helix_tui::widgets::{Block, Borders, Paragraph, Wrap};

/// # use helix_tui::layout::{Alignment};

/// let text = vec![

/// Spans::from(vec![

/// Span::raw("First"),

{Expression, Solver},

};

use helix_core::unicode::width::UnicodeWidthStr;

use std::collections::HashMap;

/// A [`Cell`] contains the [`Text`] to be displayed in a [`Row`] of a [`Table`].

/// ```rust

/// # use helix_tui::widgets::Cell;

/// # use helix_tui::text::{Span, Spans, Text};

/// Cell::from("simple string");

///

/// Cell::from(Span::from("span"));

/// But if you need a bit more control over individual cells, you can explicitly create [`Cell`]s:

/// ```rust

/// # use helix_tui::widgets::{Row, Cell};

/// Row::new(vec![

/// Cell::from("Cell1"),

/// Cell::from("Cell2").style(Style::default().fg(Color::Yellow)),

/// ```rust

/// # use helix_tui::widgets::{Block, Borders, Table, Row, Cell};

/// # use helix_tui::layout::Constraint;

/// # use helix_tui::text::{Text, Spans, Span};

/// Table::new(vec![

/// // Row can be created from simple strings.

lsp = ["helix-lsp", "tokio-runtime"]

dap = ["helix-dap", "tokio-stream", "tokio-runtime"]

tokio-runtime = ["tokio"]

[dependencies]

bitflags = "1.3"

anyhow = "1"

helix-core = { version = "0.6", path = "../helix-core" }

helix-lsp = { version = "0.6", path = "../helix-lsp", optional = true }

helix-dap = { version = "0.6", path = "../helix-dap", optional = true }

tokio-stream = { version = "0.1", optional = true }

tokio = { version = "1", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot", "sync"], optional = true }

crossterm = { version = "0.23", optional = true }

# Conversion traits

once_cell = "1.10"

[target.'cfg(windows)'.dependencies]

clipboard-win = { version = "4.4", features = ["std"] }

// Each component declares it's own size constraints and gets fitted based on it's parent.

// Q: how does this work with popups?

// cursive does compositor.screen_mut().add_layer_at(pos::absolute(x, y), <component>)

use helix_core::Position;

pub type Callback = Box<dyn FnOnce(&mut Compositor, &mut Context)>;

}

use crate::job::Jobs;

pub struct Context<'a> {

pub editor: &'a mut Editor,

pub jobs: &'a mut Jobs,

}

mod term {

use super::*;

pub use tui::buffer::Buffer as Surface;

}

}

pub use term::*;

pub trait Component: Any + AnyComponent {

layers: Vec<Box<dyn Component>>,

area: Rect,

}

impl Compositor {

infobox

}

}

use crate::compositor::Compositor;

use futures_util::future::{self, BoxFuture, Future, FutureExt};

use futures_util::stream::{FuturesUnordered, StreamExt};

pub mod term;

}

pub mod clipboard;

pub mod document;

pub mod editor;

pub mod gutter;

pub mod handlers {

#[cfg(feature = "dap")]

pub mod dap;