mroot/yazi
1
0
Fork 0
mirror of https://github.com/sxyazi/yazi.git synced 2026-07-21 14:51:03 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor: switch to ratatui-core (#4050)

Browse source
This commit is contained in:
三咲雅 misaki masa 2026-06-18 16:18:01 +08:00 • committed by sxyazi
parent 446a5721bf
commit 53d36b5186
No known key found for this signature in database
101 changed files with 566 additions and 1203 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

936
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

4
Cargo.toml
View file

@ -62,7 +62,8 @@ parking_lot = "0.12.5"
paste = "1.0.15"
percent-encoding = "2.3.2"
rand = { version = "0.10.1", default-features = false, features = [ "std", "sys_rng" ] }
ratatui = { version = "0.30.1", default-features = false, features = [ "std", "layout-cache", "serde", "underline-color", "unstable-rendered-line-info", "unstable-widget-ref" ] }
ratatui-core = { version = "0.1.1", default-features = false, features = [ "std", "layout-cache", "serde", "underline-color" ] }
ratatui-widgets = { version = "0.3.1", default-features = false, features = [ "std", "unstable-rendered-line-info" ] }
regex = "1.12.4"
russh = { version = "0.61.2", default-features = false, features = [ "ring", "rsa" ] }
scopeguard = "1.2.0"
@ -94,6 +95,5 @@ unit_arg = "allow"
use_self = "warn"
[patch.crates-io]
ratatui = { git = "https://github.com/yazi-rs/ratatui.git", package = "ratatui", rev = "a1c4922a242861d755163ae85d7e41b85ed277d2" }
ratatui-core = { git = "https://github.com/yazi-rs/ratatui.git", package = "ratatui-core", rev = "a1c4922a242861d755163ae85d7e41b85ed277d2" }
ratatui-widgets = { git = "https://github.com/yazi-rs/ratatui.git", package = "ratatui-widgets", rev = "a1c4922a242861d755163ae85d7e41b85ed277d2" }

3
nix/yazi-unwrapped.nix
View file

@ -29,7 +29,8 @@ rustPlatform.buildRustPackage (finalAttrs: {
cargoLock = {
lockFile = "${src}/Cargo.lock";
outputHashes = {
"ratatui-0.30.1" = "sha256-wkEOgwAhW0ObtPDlJmOOoY5qf9c/P79ktN4b43jtcGw=";
"ratatui-core-0.1.1" = "sha256-wkEOgwAhW0ObtPDlJmOOoY5qf9c/P79ktN4b43jtcGw=";
"ratatui-widgets-0.3.1" = "sha256-wkEOgwAhW0ObtPDlJmOOoY5qf9c/P79ktN4b43jtcGw=";
};
};

3
yazi-actor/Cargo.toml
View file

@ -48,7 +48,8 @@ indexmap = { workspace = true }
mlua = { workspace = true }
parking_lot = { workspace = true }
paste = { workspace = true }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
ratatui-widgets = { workspace = true }
scopeguard = { workspace = true }
tokio = { workspace = true }
tokio-stream = { workspace = true }

2
yazi-actor/src/app/reflow.rs
View file

@ -1,6 +1,6 @@
use anyhow::Result;
use mlua::Value;
use ratatui::layout::Position;
use ratatui_core::layout::Position;
use tracing::error;
use yazi_actor::lives::Lives;
use yazi_config::LAYOUT;

2
yazi-actor/src/input/show.rs
View file

@ -1,5 +1,5 @@
use anyhow::Result;
use ratatui::widgets::Padding;
use ratatui_widgets::block::Padding;
use yazi_config::{THEME, YAZI};
use yazi_macro::{act, render, succ};
use yazi_parser::input::ShowForm;

2
yazi-actor/src/notify/tick.rs
View file

@ -1,7 +1,7 @@
use std::time::Duration;
use anyhow::Result;
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
use yazi_core::notify::Notify;
use yazi_macro::{render, render_partial, succ};
use yazi_parser::notify::TickForm;

2
yazi-adapter/Cargo.toml
View file

@ -31,7 +31,7 @@ inventory = { workspace = true }
moxcms = "0.8.1"
palette = { version = "0.7.6", default-features = false }
quantette = { version = "0.6.0", default-features = false }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
strum = { workspace = true }
tokio = { workspace = true }
tracing = { workspace = true }

2
yazi-adapter/src/adapter.rs
View file

@ -1,7 +1,7 @@
use std::{fmt::{self, Debug}, ops::Deref};
use anyhow::Result;
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
use yazi_emulator::EMULATOR;
use yazi_shim::cell::SyncCell;
use yazi_widgets::clear::ClearInventory;

2
yazi-adapter/src/drivers/chafa.rs
View file

@ -2,7 +2,7 @@ use std::{io::Write, path::PathBuf, process::Stdio};
use ansi_to_tui::IntoText;
use anyhow::{Result, anyhow, bail};
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
use tokio::process::Command;
use yazi_config::THEME;
use yazi_emulator::Emulator;

2
yazi-adapter/src/drivers/driver.rs
View file

@ -1,7 +1,7 @@
use std::path::PathBuf;
use anyhow::Result;
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
use strum::{Display, IntoStaticStr};
use crate::drivers::{Chafa, Iip, Kgp, KgpOld, Sixel, Ueberzug};

2
yazi-adapter/src/drivers/iip.rs
View file

@ -3,7 +3,7 @@ use std::{fmt::Write as _, io::Write as _, path::PathBuf};
use anyhow::Result;
use base64::{Engine, engine::{Config, general_purpose::STANDARD}};
use image::{DynamicImage, ExtendedColorType, ImageEncoder, codecs::{jpeg::JpegEncoder, png::PngEncoder}};
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
use yazi_config::{THEME, YAZI};
use yazi_emulator::{CLOSE, Emulator, START};
use yazi_tty::sequence::{MoveTo, ResetAttrs, SetBg};

2
yazi-adapter/src/drivers/kgp.rs
View file

@ -4,7 +4,7 @@ use std::{io::Write, path::PathBuf};
use anyhow::Result;
use base64::{Engine, engine::general_purpose};
use image::DynamicImage;
use ratatui::{layout::Rect, style::Color};
use ratatui_core::{layout::Rect, style::Color};
use yazi_config::THEME;
use yazi_emulator::{CLOSE, ESCAPE, Emulator, START};
use yazi_shim::cell::SyncCell;

2
yazi-adapter/src/drivers/kgp_old.rs
View file

@ -4,7 +4,7 @@ use std::{io::Write, path::PathBuf};
use anyhow::Result;
use base64::{Engine, engine::general_purpose};
use image::DynamicImage;
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
use yazi_emulator::{CLOSE, ESCAPE, Emulator, START};
use yazi_tty::TTY;

2
yazi-adapter/src/drivers/sixel.rs
View file

@ -4,7 +4,7 @@ use anyhow::{Result, bail};
use image::{DynamicImage, GenericImageView, RgbImage};
use palette::{Srgb, cast::ComponentsAs};
use quantette::{PaletteSize, color_map::IndexedColorMap, wu::{BinnerU8x3, WuU8x3}};
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
use yazi_config::THEME;
use yazi_emulator::{CLOSE, ESCAPE, Emulator, START};
use yazi_tty::sequence::{MoveTo, ResetAttrs, SetBg};

2
yazi-adapter/src/drivers/ueberzug.rs
View file

@ -2,7 +2,7 @@ use std::{path::PathBuf, process::Stdio};
use anyhow::{Result, bail};
use image::ImageReader;
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
use tokio::{io::AsyncWriteExt, process::{Child, Command}, sync::mpsc::{self, UnboundedSender}};
use tracing::{debug, warn};
use yazi_config::YAZI;

2
yazi-adapter/src/image.rs
View file

@ -2,7 +2,7 @@ use std::path::{Path, PathBuf};
use anyhow::Result;
use image::{DynamicImage, ImageDecoder, ImageError, ImageReader, Limits, codecs::{jpeg::JpegEncoder, png::PngEncoder}, imageops::FilterType, metadata::Orientation};
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
use yazi_config::YAZI;
use yazi_emulator::Dimension;
use yazi_fs::provider::{Provider, local::Local};

6
yazi-binding/Cargo.toml
View file

@ -27,15 +27,13 @@ anyhow = { workspace = true }
futures = { workspace = true }
hashbrown = { workspace = true }
image = { workspace = true }
inventory = { workspace = true }
mlua = { workspace = true }
ordered-float = { workspace = true }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
ratatui-widgets = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
strum = { workspace = true }
tokio = { workspace = true }
tracing = { workspace = true }
unicode-width = { workspace = true }
[target.'cfg(unix)'.dependencies]

10
yazi-binding/src/elements/align.rs
View file

@ -3,10 +3,10 @@ use std::ops::Deref;
use mlua::{FromLua, IntoLua, Lua, Value};
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct Align(pub(super) ratatui::layout::Alignment);
pub struct Align(pub(super) ratatui_core::layout::Alignment);
impl Deref for Align {
type Target = ratatui::layout::Alignment;
type Target = ratatui_core::layout::Alignment;
fn deref(&self) -> &Self::Target { &self.0 }
}
@ -27,9 +27,9 @@ impl FromLua for Align {
});
};
Ok(Self(match n {
0 => ratatui::layout::Alignment::Left,
1 => ratatui::layout::Alignment::Center,
2 => ratatui::layout::Alignment::Right,
0 => ratatui_core::layout::Alignment::Left,
1 => ratatui_core::layout::Alignment::Center,
2 => ratatui_core::layout::Alignment::Right,
_ => Err(mlua::Error::FromLuaConversionError {
from: value.type_name(),
to: "Align".to_string(),

14
yazi-binding/src/elements/area.rs
View file

@ -27,14 +27,14 @@ impl Debug for Area {
}
impl Area {
pub fn size(self) -> ratatui::layout::Size {
pub fn size(self) -> ratatui_core::layout::Size {
match self {
Self::Rect(rect) => (*rect).into(),
Self::Pos(pos) => ratatui::layout::Size { width: pos.width, height: pos.height },
Self::Pos(pos) => ratatui_core::layout::Size { width: pos.width, height: pos.height },
}
}
pub fn inner(self, padding: ratatui::widgets::Padding) -> Self {
pub fn inner(self, padding: ratatui_widgets::block::Padding) -> Self {
match self {
Self::Rect(rect) => Self::Rect(rect.pad(padding.into())),
Self::Pos(mut pos) => {
@ -46,8 +46,8 @@ impl Area {
pub fn transform(
self,
f: impl FnOnce(Position) -> ratatui::layout::Rect,
) -> ratatui::layout::Rect {
f: impl FnOnce(Position) -> ratatui_core::layout::Rect,
) -> ratatui_core::layout::Rect {
match self {
Self::Rect(rect) => *rect,
Self::Pos(pos) => *Rect(f(*pos)).pad(pos.pad),
@ -59,8 +59,8 @@ impl From<Rect> for Area {
fn from(rect: Rect) -> Self { Self::Rect(rect) }
}
impl From<ratatui::layout::Rect> for Area {
fn from(rect: ratatui::layout::Rect) -> Self { Self::Rect(rect.into()) }
impl From<ratatui_core::layout::Rect> for Area {
fn from(rect: ratatui_core::layout::Rect) -> Self { Self::Rect(rect.into()) }
}
impl From<Position> for Area {

7
yazi-binding/src/elements/bar.rs
View file

@ -1,5 +1,6 @@
use mlua::{AnyUserData, IntoLua, Lua, MetaMethod, Table, UserData, UserDataMethods, Value};
use ratatui::widgets::{Borders, Widget};
use ratatui_core::widgets::Widget;
use ratatui_widgets::borders::Borders;
use super::{Area, Edge};
use crate::elements::Spatial;
@ -10,7 +11,7 @@ pub struct Bar {
edge: Edge,
symbol: String,
style: ratatui::style::Style,
style: ratatui_core::style::Style,
}
impl Bar {
@ -37,7 +38,7 @@ impl Spatial for Bar {
}
impl Widget for &Bar {
fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{

43
yazi-binding/src/elements/border.rs
View file

@ -1,5 +1,6 @@
use mlua::{AnyUserData, IntoLua, Lua, MetaMethod, Table, UserData, UserDataMethods, Value};
use ratatui::widgets::{Borders, Widget};
use ratatui_core::widgets::Widget;
use ratatui_widgets::borders::Borders;
use super::{Area, Edge};
use crate::elements::{Line, Spatial};
@ -17,17 +18,17 @@ pub struct Border {
pub area: Area,
pub edge: Edge,
pub r#type: ratatui::widgets::BorderType,
pub style: ratatui::style::Style,
pub merge: ratatui::symbols::merge::MergeStrategy,
pub r#type: ratatui_widgets::borders::BorderType,
pub style: ratatui_core::style::Style,
pub merge: ratatui_core::symbols::merge::MergeStrategy,
pub titles: Vec<(ratatui::widgets::TitlePosition, ratatui::text::Line<'static>)>,
pub titles: Vec<(ratatui_widgets::block::TitlePosition, ratatui_core::text::Line<'static>)>,
}
impl Border {
pub fn compose(lua: &Lua) -> mlua::Result<Value> {
let new = lua.create_function(|_, (_, edge): (Table, Edge)| {
Ok(Self { edge, r#type: ratatui::widgets::BorderType::Rounded, ..Default::default() })
Ok(Self { edge, r#type: ratatui_widgets::borders::BorderType::Rounded, ..Default::default() })
})?;
let border = lua.create_table_from([
@ -58,11 +59,11 @@ impl Spatial for Border {
}
impl Widget for Border {
fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{
let mut block = ratatui::widgets::Block::default()
let mut block = ratatui_widgets::block::Block::default()
.borders(self.edge.0)
.border_type(self.r#type)
.border_style(self.style)
@ -70,8 +71,8 @@ impl Widget for Border {
for title in self.titles {
block = match title {
(ratatui::widgets::TitlePosition::Top, line) => block.title_top(line),
(ratatui::widgets::TitlePosition::Bottom, line) => block.title_bottom(line),
(ratatui_widgets::block::TitlePosition::Top, line) => block.title_top(line),
(ratatui_widgets::block::TitlePosition::Bottom, line) => block.title_bottom(line),
};
}
@ -80,7 +81,7 @@ impl Widget for Border {
}
impl Widget for &Border {
fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{
@ -95,20 +96,20 @@ impl UserData for Border {
methods.add_function("type", |_, (ud, value): (AnyUserData, u8)| {
ud.borrow_mut::<Self>()?.r#type = match value {
ROUNDED => ratatui::widgets::BorderType::Rounded,
DOUBLE => ratatui::widgets::BorderType::Double,
THICK => ratatui::widgets::BorderType::Thick,
QUADRANT_INSIDE => ratatui::widgets::BorderType::QuadrantInside,
QUADRANT_OUTSIDE => ratatui::widgets::BorderType::QuadrantOutside,
_ => ratatui::widgets::BorderType::Plain,
ROUNDED => ratatui_widgets::borders::BorderType::Rounded,
DOUBLE => ratatui_widgets::borders::BorderType::Double,
THICK => ratatui_widgets::borders::BorderType::Thick,
QUADRANT_INSIDE => ratatui_widgets::borders::BorderType::QuadrantInside,
QUADRANT_OUTSIDE => ratatui_widgets::borders::BorderType::QuadrantOutside,
_ => ratatui_widgets::borders::BorderType::Plain,
};
Ok(ud)
});
methods.add_function("title", |_, (ud, line, position): (AnyUserData, Line, Option<u8>)| {
let position = if position == Some(Borders::BOTTOM.bits()) {
ratatui::widgets::TitlePosition::Bottom
ratatui_widgets::block::TitlePosition::Bottom
} else {
ratatui::widgets::TitlePosition::Top
ratatui_widgets::block::TitlePosition::Top
};
ud.borrow_mut::<Self>()?.titles.push((position, line.inner));
@ -120,9 +121,9 @@ impl UserData for Border {
});
methods.add_function("merge", |_, (ud, exact): (AnyUserData, bool)| {
ud.borrow_mut::<Self>()?.merge = if exact {
ratatui::symbols::merge::MergeStrategy::Exact
ratatui_core::symbols::merge::MergeStrategy::Exact
} else {
ratatui::symbols::merge::MergeStrategy::Fuzzy
ratatui_core::symbols::merge::MergeStrategy::Fuzzy
};
Ok(ud)
});

4
yazi-binding/src/elements/cell.rs
View file

@ -4,10 +4,10 @@ use super::Text;
#[derive(Clone, Debug)]
pub struct Cell {
pub(super) text: ratatui::text::Text<'static>,
pub(super) text: ratatui_core::text::Text<'static>,
}
impl From<Cell> for ratatui::widgets::Cell<'static> {
impl From<Cell> for ratatui_widgets::table::Cell<'static> {
fn from(value: Cell) -> Self { Self::new(value.text) }
}

6
yazi-binding/src/elements/color.rs
View file

@ -3,7 +3,7 @@ use std::str::FromStr;
use mlua::{AnyUserData, ExternalError, ExternalResult, FromLua, IntoLua, Lua, MetaMethod, Table, UserData, Value};
#[derive(Clone, Copy, Default)]
pub struct Color(pub ratatui::style::Color);
pub struct Color(pub ratatui_core::style::Color);
impl Color {
pub fn compose(lua: &Lua) -> mlua::Result<Value> {
@ -25,8 +25,8 @@ impl TryFrom<&AnyUserData> for Color {
impl FromLua for Color {
fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
Ok(Self(match value {
Value::Nil => ratatui::style::Color::Reset,
Value::String(s) => ratatui::style::Color::from_str(&s.to_str()?).into_lua_err()?,
Value::Nil => ratatui_core::style::Color::Reset,
Value::String(s) => ratatui_core::style::Color::from_str(&s.to_str()?).into_lua_err()?,
Value::UserData(ud) => return Self::try_from(&ud),
_ => Err("expected a Color".into_lua_err())?,
}))

6
yazi-binding/src/elements/constraint.rs
View file

@ -1,11 +1,11 @@
use mlua::{FromLua, IntoLua, Lua, UserData, Value};
#[derive(Clone, Copy, Default, FromLua)]
pub struct Constraint(pub(super) ratatui::layout::Constraint);
pub struct Constraint(pub(super) ratatui_core::layout::Constraint);
impl Constraint {
pub fn compose(lua: &Lua) -> mlua::Result<Value> {
use ratatui::layout::Constraint as C;
use ratatui_core::layout::Constraint as C;
lua
.create_table_from([
@ -20,7 +20,7 @@ impl Constraint {
}
}
impl From<Constraint> for ratatui::layout::Constraint {
impl From<Constraint> for ratatui_core::layout::Constraint {
fn from(value: Constraint) -> Self { value.0 }
}

2
yazi-binding/src/elements/edge.rs
View file

@ -1,7 +1,7 @@
use std::ops::Deref;
use mlua::{FromLua, IntoLua, Lua, Value};
use ratatui::widgets::Borders;
use ratatui_widgets::borders::Borders;
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct Edge(pub Borders);

6
yazi-binding/src/elements/fill.rs
View file

@ -1,5 +1,5 @@
use mlua::{AnyUserData, IntoLua, Lua, MetaMethod, Table, UserData, UserDataMethods, Value};
use ratatui::widgets::Widget;
use ratatui_core::widgets::Widget;
use super::Area;
use crate::elements::Spatial;
@ -8,7 +8,7 @@ use crate::elements::Spatial;
pub struct Fill {
area: Area,
style: ratatui::style::Style,
style: ratatui_core::style::Style,
}
impl Fill {
@ -36,7 +36,7 @@ impl Spatial for Fill {
}
impl Widget for &Fill {
fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{

14
yazi-binding/src/elements/gauge.rs
View file

@ -1,5 +1,5 @@
use mlua::{AnyUserData, ExternalError, IntoLua, Lua, MetaMethod, Table, UserData, UserDataMethods, Value};
use ratatui::widgets::Widget;
use ratatui_core::widgets::Widget;
use super::{Area, Span};
use crate::{elements::Spatial, style::Style};
@ -9,9 +9,9 @@ pub struct Gauge {
area: Area,
ratio: f64,
label: Option<ratatui::text::Span<'static>>,
style: ratatui::style::Style,
gauge_style: ratatui::style::Style,
label: Option<ratatui_core::text::Span<'static>>,
style: ratatui_core::style::Style,
gauge_style: ratatui_core::style::Style,
}
impl Gauge {
@ -38,11 +38,11 @@ impl Spatial for Gauge {
}
impl Widget for Gauge {
fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{
let mut gauge = ratatui::widgets::Gauge::default()
let mut gauge = ratatui_widgets::gauge::Gauge::default()
.ratio(self.ratio)
.style(self.style)
.gauge_style(self.gauge_style);
@ -56,7 +56,7 @@ impl Widget for Gauge {
}
impl Widget for &Gauge {
fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{

16
yazi-binding/src/elements/layout.rs
View file

@ -8,8 +8,8 @@ const VERTICAL: bool = false;
#[derive(Clone, Default)]
pub struct Layout {
direction: bool,
margin: Option<ratatui::layout::Margin>,
constraints: Vec<ratatui::layout::Constraint>,
margin: Option<ratatui_core::layout::Margin>,
constraints: Vec<ratatui_core::layout::Constraint>,
}
impl Layout {
@ -30,7 +30,7 @@ impl UserData for Layout {
Ok(ud)
});
methods.add_function("margin", |_, (ud, value): (AnyUserData, u16)| {
ud.borrow_mut::<Self>()?.margin = Some(ratatui::layout::Margin::new(value, value));
ud.borrow_mut::<Self>()?.margin = Some(ratatui_core::layout::Margin::new(value, value));
Ok(ud)
});
methods.add_function("margin_h", |_, (ud, value): (AnyUserData, u16)| {
@ -39,7 +39,7 @@ impl UserData for Layout {
if let Some(margin) = &mut me.margin {
margin.horizontal = value;
} else {
me.margin = Some(ratatui::layout::Margin::new(value, 0));
me.margin = Some(ratatui_core::layout::Margin::new(value, 0));
}
}
Ok(ud)
@ -50,7 +50,7 @@ impl UserData for Layout {
if let Some(margin) = &mut me.margin {
margin.vertical = value;
} else {
me.margin = Some(ratatui::layout::Margin::new(0, value));
me.margin = Some(ratatui_core::layout::Margin::new(0, value));
}
}
Ok(ud)
@ -60,11 +60,11 @@ impl UserData for Layout {
Ok(ud)
});
methods.add_method("split", |lua, me, value: Rect| {
let mut layout = ratatui::layout::Layout::new(
let mut layout = ratatui_core::layout::Layout::new(
if me.direction == VERTICAL {
ratatui::layout::Direction::Vertical
ratatui_core::layout::Direction::Vertical
} else {
ratatui::layout::Direction::Horizontal
ratatui_core::layout::Direction::Horizontal
},
&me.constraints,
);

16
yazi-binding/src/elements/line.rs
View file

@ -2,7 +2,7 @@ use std::{borrow::Cow, mem, ops::{Deref, DerefMut}};
use ansi_to_tui::IntoText;
use mlua::{AnyUserData, ExternalError, ExternalResult, FromLua, Function, IntoLua, Lua, MetaMethod, Table, UserData, UserDataMethods, Value};
use ratatui::widgets::Widget;
use ratatui_core::widgets::Widget;
use unicode_width::UnicodeWidthChar;
use super::{Area, Span};
@ -14,11 +14,11 @@ const EXPECTED: &str = "expected a string, Span, Line, or a table of them";
pub struct Line {
area: Area,
pub(super) inner: ratatui::text::Line<'static>,
pub(super) inner: ratatui_core::text::Line<'static>,
}
impl Deref for Line {
type Target = ratatui::text::Line<'static>;
type Target = ratatui_core::text::Line<'static>;
fn deref(&self) -> &Self::Target { &self.inner }
}
@ -51,8 +51,8 @@ impl Line {
}
}
impl From<ratatui::text::Line<'static>> for Line {
fn from(value: ratatui::text::Line<'static>) -> Self {
impl From<ratatui_core::text::Line<'static>> for Line {
fn from(value: ratatui_core::text::Line<'static>) -> Self {
Self { inner: value, ..Default::default() }
}
}
@ -96,7 +96,7 @@ impl TryFrom<Table> for Line {
}
}
impl From<Line> for ratatui::text::Line<'static> {
impl From<Line> for ratatui_core::text::Line<'static> {
fn from(value: Line) -> Self { value.inner }
}
@ -107,7 +107,7 @@ impl Spatial for Line {
}
impl Widget for &Line {
fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{
@ -157,7 +157,7 @@ impl UserData for Line {
}
let ellipsis = match t.raw_get::<Value>("ellipsis")? {
Value::Nil => (1, ratatui::text::Span::raw("…")),
Value::Nil => (1, ratatui_core::text::Span::raw("…")),
v => {
let mut span = Span::from_lua(v, lua)?;
(span.truncate(max), span.0)

8
yazi-binding/src/elements/list.rs
View file

@ -1,5 +1,5 @@
use mlua::{AnyUserData, IntoLua, Lua, MetaMethod, Table, UserData, UserDataMethods, Value};
use ratatui::widgets::Widget;
use ratatui_core::widgets::Widget;
use super::{Area, Text};
use crate::elements::Spatial;
@ -9,13 +9,13 @@ use crate::elements::Spatial;
pub struct List {
area: Area,
inner: ratatui::widgets::List<'static>,
inner: ratatui_widgets::list::List<'static>,
}
impl List {
pub fn compose(lua: &Lua) -> mlua::Result<Value> {
let new = lua.create_function(|_, (_, items): (Table, Vec<Text>)| {
Ok(Self { inner: ratatui::widgets::List::new(items), ..Default::default() })
Ok(Self { inner: ratatui_widgets::list::List::new(items), ..Default::default() })
})?;
let list = lua.create_table()?;
@ -38,7 +38,7 @@ impl Spatial for List {
}
impl Widget for &List {
fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{

56
yazi-binding/src/elements/pad.rs
View file

@ -3,46 +3,64 @@ use std::ops::{Add, AddAssign, Deref};
use mlua::{FromLua, IntoLua, Lua, MetaMethod, Table, UserData, UserDataFields, Value};
#[derive(Clone, Copy, Default, FromLua)]
pub struct Pad(ratatui::widgets::Padding);
pub struct Pad(ratatui_widgets::block::Padding);
impl Deref for Pad {
type Target = ratatui::widgets::Padding;
type Target = ratatui_widgets::block::Padding;
fn deref(&self) -> &Self::Target { &self.0 }
}
impl From<ratatui::widgets::Padding> for Pad {
fn from(pad: ratatui::widgets::Padding) -> Self { Self(pad) }
impl From<ratatui_widgets::block::Padding> for Pad {
fn from(pad: ratatui_widgets::block::Padding) -> Self { Self(pad) }
}
impl Pad {
pub fn compose(lua: &Lua) -> mlua::Result<Value> {
let new =
lua.create_function(|_, (_, top, right, bottom, left): (Table, u16, u16, u16, u16)| {
Ok(Self(ratatui::widgets::Padding::new(left, right, top, bottom)))
Ok(Self(ratatui_widgets::block::Padding::new(left, right, top, bottom)))
})?;
let pad = lua.create_table_from([
(
"left",
lua.create_function(|_, left: u16| Ok(Self(ratatui::widgets::Padding::left(left))))?,
lua
.create_function(|_, left: u16| Ok(Self(ratatui_widgets::block::Padding::left(left))))?,
),
(
"right",
lua.create_function(|_, right: u16| Ok(Self(ratatui::widgets::Padding::right(right))))?,
lua.create_function(|_, right: u16| {
Ok(Self(ratatui_widgets::block::Padding::right(right)))
})?,
),
(
"top",
lua.create_function(|_, top: u16| Ok(Self(ratatui_widgets::block::Padding::top(top))))?,
),
("top", lua.create_function(|_, top: u16| Ok(Self(ratatui::widgets::Padding::top(top))))?),
(
"bottom",
lua
.create_function(|_, bottom: u16| Ok(Self(ratatui::widgets::Padding::bottom(bottom))))?,
lua.create_function(|_, bottom: u16| {
Ok(Self(ratatui_widgets::block::Padding::bottom(bottom)))
})?,
),
(
"x",
lua.create_function(|_, x: u16| {
Ok(Self(ratatui_widgets::block::Padding::new(x, x, 0, 0)))
})?,
),
(
"y",
lua.create_function(|_, y: u16| {
Ok(Self(ratatui_widgets::block::Padding::new(0, 0, y, y)))
})?,
),
("x", lua.create_function(|_, x: u16| Ok(Self(ratatui::widgets::Padding::new(x, x, 0, 0))))?),
("y", lua.create_function(|_, y: u16| Ok(Self(ratatui::widgets::Padding::new(0, 0, y, y))))?),
(
"xy",
lua
.create_function(|_, xy: u16| Ok(Self(ratatui::widgets::Padding::new(xy, xy, xy, xy))))?,
lua.create_function(|_, xy: u16| {
Ok(Self(ratatui_widgets::block::Padding::new(xy, xy, xy, xy)))
})?,
),
])?;
@ -60,11 +78,11 @@ impl UserData for Pad {
}
}
impl Add<ratatui::widgets::Padding> for Pad {
impl Add<ratatui_widgets::block::Padding> for Pad {
type Output = Self;
fn add(self, rhs: ratatui::widgets::Padding) -> Self::Output {
Self(ratatui::widgets::Padding::new(
fn add(self, rhs: ratatui_widgets::block::Padding) -> Self::Output {
Self(ratatui_widgets::block::Padding::new(
self.left.saturating_add(rhs.left),
self.right.saturating_add(rhs.right),
self.top.saturating_add(rhs.top),
@ -73,6 +91,6 @@ impl Add<ratatui::widgets::Padding> for Pad {
}
}
impl AddAssign<ratatui::widgets::Padding> for Pad {
fn add_assign(&mut self, rhs: ratatui::widgets::Padding) { *self = *self + rhs; }
impl AddAssign<ratatui_widgets::block::Padding> for Pad {
fn add_assign(&mut self, rhs: ratatui_widgets::block::Padding) { *self = *self + rhs; }
}

23
yazi-binding/src/elements/rect.rs
View file

@ -5,28 +5,33 @@ use mlua::{FromLua, IntoLua, Lua, MetaMethod, Table, UserData, UserDataFields, U
use super::Pad;
#[derive(Clone, Copy, Debug, Default, FromLua)]
pub struct Rect(pub ratatui::layout::Rect);
pub struct Rect(pub ratatui_core::layout::Rect);
impl Deref for Rect {
type Target = ratatui::layout::Rect;
type Target = ratatui_core::layout::Rect;
fn deref(&self) -> &Self::Target { &self.0 }
}
impl From<ratatui::layout::Rect> for Rect {
fn from(rect: ratatui::layout::Rect) -> Self { Self(rect) }
impl From<ratatui_core::layout::Rect> for Rect {
fn from(rect: ratatui_core::layout::Rect) -> Self { Self(rect) }
}
impl From<ratatui::layout::Size> for Rect {
fn from(size: ratatui::layout::Size) -> Self {
Self(ratatui::layout::Rect { x: 0, y: 0, width: size.width, height: size.height })
impl From<ratatui_core::layout::Size> for Rect {
fn from(size: ratatui_core::layout::Size) -> Self {
Self(ratatui_core::layout::Rect {
x: 0,
y: 0,
width: size.width,
height: size.height,
})
}
}
impl Rect {
pub fn compose(lua: &Lua) -> mlua::Result<Value> {
let new = lua.create_function(|_, (_, args): (Table, Table)| {
Ok(Self(ratatui::layout::Rect {
Ok(Self(ratatui_core::layout::Rect {
x: args.raw_get("x").unwrap_or_default(),
y: args.raw_get("y").unwrap_or_default(),
width: args.raw_get("w").unwrap_or_default(),
@ -50,7 +55,7 @@ impl Rect {
}
fn patch(self, t: Table) -> mlua::Result<Self> {
Ok(Self(ratatui::layout::Rect {
Ok(Self(ratatui_core::layout::Rect {
x: t.raw_get::<Option<_>>("x")?.unwrap_or(self.x),
y: t.raw_get::<Option<_>>("y")?.unwrap_or(self.y),
width: t.raw_get::<Option<_>>("w")?.unwrap_or(self.width),

4
yazi-binding/src/elements/row.rs
View file

@ -10,7 +10,7 @@ pub struct Row {
height: u16,
top_margin: u16,
bottom_margin: u16,
style: ratatui::style::Style,
style: ratatui_core::style::Style,
}
impl Row {
@ -26,7 +26,7 @@ impl Row {
}
}
impl From<Row> for ratatui::widgets::Row<'static> {
impl From<Row> for ratatui_widgets::table::Row<'static> {
fn from(value: Row) -> Self {
Self::new(value.cells)
.height(value.height.max(1))

4
yazi-binding/src/elements/span.rs
View file

@ -5,10 +5,10 @@ use unicode_width::UnicodeWidthChar;
const EXPECTED: &str = "expected a string or Span";
pub struct Span(pub(super) ratatui::text::Span<'static>);
pub struct Span(pub(super) ratatui_core::text::Span<'static>);
impl Deref for Span {
type Target = ratatui::text::Span<'static>;
type Target = ratatui_core::text::Span<'static>;
fn deref(&self) -> &Self::Target { &self.0 }
}

34
yazi-binding/src/elements/table.rs
View file

@ -1,5 +1,5 @@
use mlua::{AnyUserData, IntoLua, Lua, MetaMethod, UserData, UserDataMethods, Value};
use ratatui::widgets::{StatefulWidget, Widget};
use ratatui_core::widgets::{StatefulWidget, Widget};
use super::{Area, Row};
use crate::{elements::{Constraint, Spatial}, style::Style};
@ -10,23 +10,23 @@ pub struct Table {
area: Area,
rows: Vec<Row>,
header: Option<ratatui::widgets::Row<'static>>,
footer: Option<ratatui::widgets::Row<'static>>,
widths: Vec<ratatui::layout::Constraint>,
header: Option<ratatui_widgets::table::Row<'static>>,
footer: Option<ratatui_widgets::table::Row<'static>>,
widths: Vec<ratatui_core::layout::Constraint>,
column_spacing: u16,
block: Option<ratatui::widgets::Block<'static>>, // TODO
block: Option<ratatui_widgets::block::Block<'static>>, // TODO
style: ratatui::style::Style,
row_highlight_style: ratatui::style::Style,
column_highlight_style: ratatui::style::Style,
cell_highlight_style: ratatui::style::Style,
style: ratatui_core::style::Style,
row_highlight_style: ratatui_core::style::Style,
column_highlight_style: ratatui_core::style::Style,
cell_highlight_style: ratatui_core::style::Style,
highlight_symbol: ratatui::text::Text<'static>, // TODO
highlight_spacing: ratatui::widgets::HighlightSpacing, // TODO
highlight_symbol: ratatui_core::text::Text<'static>, // TODO
highlight_spacing: ratatui_widgets::table::HighlightSpacing, // TODO
flex: ratatui::layout::Flex,
flex: ratatui_core::layout::Flex,
state: ratatui::widgets::TableState,
state: ratatui_widgets::table::TableState,
}
impl Table {
@ -41,7 +41,7 @@ impl Table {
table.into_lua(lua)
}
pub fn selected_cell(&self) -> Option<&ratatui::text::Text<'_>> {
pub fn selected_cell(&self) -> Option<&ratatui_core::text::Text<'_>> {
let row = &self.rows[self.selected()?];
let col = self.state.selected_column()?;
if row.cells.is_empty() { None } else { Some(&row.cells[col.min(row.cells.len() - 1)].text) }
@ -73,11 +73,11 @@ impl Spatial for Table {
}
impl Widget for Table {
fn render(mut self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(mut self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{
let mut table = ratatui::widgets::Table::new(self.rows, self.widths)
let mut table = ratatui_widgets::table::Table::new(self.rows, self.widths)
.column_spacing(self.column_spacing)
.style(self.style)
.row_highlight_style(self.row_highlight_style)
@ -102,7 +102,7 @@ impl Widget for Table {
}
impl Widget for &Table {
fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{

26
yazi-binding/src/elements/text.rs
View file

@ -2,7 +2,7 @@ use std::{any::TypeId, mem};
use ansi_to_tui::IntoText;
use mlua::{AnyUserData, ExternalError, ExternalResult, FromLua, IntoLua, Lua, MetaMethod, Table, UserData, UserDataMethods, Value};
use ratatui::widgets::Widget;
use ratatui_core::widgets::Widget;
use yazi_shim::SStr;
use super::{Area, Line, Span, Wrap};
@ -15,9 +15,9 @@ pub struct Text {
area: Area,
// TODO: block
pub inner: ratatui::text::Text<'static>,
pub inner: ratatui_core::text::Text<'static>,
pub wrap: Wrap,
pub scroll: ratatui::layout::Position,
pub scroll: ratatui_core::layout::Position,
}
impl Text {
@ -39,8 +39,8 @@ impl Text {
}
}
impl From<ratatui::text::Text<'static>> for Text {
fn from(inner: ratatui::text::Text<'static>) -> Self { Self { inner, ..Default::default() } }
impl From<ratatui_core::text::Text<'static>> for Text {
fn from(inner: ratatui_core::text::Text<'static>) -> Self { Self { inner, ..Default::default() } }
}
impl From<SStr> for Text {
@ -68,16 +68,16 @@ impl TryFrom<Table> for Text {
}
}
impl From<Text> for ratatui::text::Text<'static> {
impl From<Text> for ratatui_core::text::Text<'static> {
fn from(value: Text) -> Self { value.inner }
}
impl From<Text> for ratatui::widgets::Paragraph<'static> {
impl From<Text> for ratatui_widgets::paragraph::Paragraph<'static> {
fn from(mut value: Text) -> Self {
let align = value.inner.alignment.take();
let style = mem::take(&mut value.inner.style);
let mut p = ratatui::widgets::Paragraph::new(value.inner).style(style);
let mut p = ratatui_widgets::paragraph::Paragraph::new(value.inner).style(style);
if let Some(align) = align {
p = p.alignment(align);
}
@ -95,27 +95,27 @@ impl Spatial for Text {
}
impl Widget for Text {
fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{
if self.wrap.is_none() && self.scroll == Default::default() {
self.inner.render(rect, buf);
} else {
ratatui::widgets::Paragraph::from(self).render(rect, buf);
ratatui_widgets::paragraph::Paragraph::from(self).render(rect, buf);
}
}
}
impl Widget for &Text {
fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{
if self.wrap.is_none() && self.scroll == Default::default() {
(&self.inner).render(rect, buf);
} else {
ratatui::widgets::Paragraph::from(self.clone()).render(rect, buf);
ratatui_widgets::paragraph::Paragraph::from(self.clone()).render(rect, buf);
}
}
}
@ -162,7 +162,7 @@ impl UserData for Text {
Ok(ud)
});
methods.add_function("scroll", |_, (ud, x, y): (AnyUserData, u16, u16)| {
ud.borrow_mut::<Self>()?.scroll = ratatui::layout::Position { x, y };
ud.borrow_mut::<Self>()?.scroll = ratatui_core::layout::Position { x, y };
Ok(ud)
});
methods.add_method("max_width", |_, me, ()| {

18
yazi-binding/src/elements/wrap.rs
View file

@ -3,10 +3,10 @@ use std::ops::Deref;
use mlua::{FromLua, IntoLua, Lua, Value};
#[derive(Clone, Copy, Debug, Default)]
pub struct Wrap(pub Option<ratatui::widgets::Wrap>);
pub struct Wrap(pub Option<ratatui_widgets::paragraph::Wrap>);
impl Deref for Wrap {
type Target = Option<ratatui::widgets::Wrap>;
type Target = Option<ratatui_widgets::paragraph::Wrap>;
fn deref(&self) -> &Self::Target { &self.0 }
}
@ -17,12 +17,12 @@ impl Wrap {
}
}
impl From<Wrap> for Option<ratatui::widgets::Wrap> {
impl From<Wrap> for Option<ratatui_widgets::paragraph::Wrap> {
fn from(value: Wrap) -> Self { value.0 }
}
impl From<ratatui::widgets::Wrap> for Wrap {
fn from(value: ratatui::widgets::Wrap) -> Self { Self(Some(value)) }
impl From<ratatui_widgets::paragraph::Wrap> for Wrap {
fn from(value: ratatui_widgets::paragraph::Wrap) -> Self { Self(Some(value)) }
}
impl FromLua for Wrap {
@ -36,8 +36,8 @@ impl FromLua for Wrap {
};
Ok(Self(match n {
0 => None,
1 => Some(ratatui::widgets::Wrap { trim: false }),
2 => Some(ratatui::widgets::Wrap { trim: true }),
1 => Some(ratatui_widgets::paragraph::Wrap { trim: false }),
2 => Some(ratatui_widgets::paragraph::Wrap { trim: true }),
_ => Err(mlua::Error::FromLuaConversionError {
from: value.type_name(),
to: "Wrap".to_string(),
@ -51,8 +51,8 @@ impl IntoLua for Wrap {
fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {
match self.0 {
None => 0.into_lua(lua),
Some(ratatui::widgets::Wrap { trim: false }) => 1.into_lua(lua),
Some(ratatui::widgets::Wrap { trim: true }) => 2.into_lua(lua),
Some(ratatui_widgets::paragraph::Wrap { trim: false }) => 1.into_lua(lua),
Some(ratatui_widgets::paragraph::Wrap { trim: true }) => 2.into_lua(lua),
}
}
}

42
yazi-binding/src/macros.rs
View file

@ -79,7 +79,7 @@ macro_rules! impl_style_shorthands {
$methods.add_function("fg", |lua, (ud, value): (mlua::AnyUserData, mlua::Value)| {
use $crate::elements::Color;
use mlua::FromLua;
use ratatui::style::Modifier;
use ratatui_core::style::Modifier;
let me = &mut ud.borrow_mut::<Self>()?.$($field).+;
match value {
@ -98,7 +98,7 @@ macro_rules! impl_style_shorthands {
$methods.add_function("bg", |lua, (ud, value): (mlua::AnyUserData, mlua::Value)| {
use $crate::elements::Color;
use mlua::FromLua;
use ratatui::style::Modifier;
use ratatui_core::style::Modifier;
let me = &mut ud.borrow_mut::<Self>()?.$($field).+;
match value {
@ -117,86 +117,86 @@ macro_rules! impl_style_shorthands {
$methods.add_function("bold", |_, (ud, remove): (mlua::AnyUserData, bool)| {
let me = &mut ud.borrow_mut::<Self>()?.$($field).+;
if remove {
*me = me.remove_modifier(ratatui::style::Modifier::BOLD);
*me = me.remove_modifier(ratatui_core::style::Modifier::BOLD);
} else {
*me = me.add_modifier(ratatui::style::Modifier::BOLD);
*me = me.add_modifier(ratatui_core::style::Modifier::BOLD);
}
Ok(ud)
});
$methods.add_function("dim", |_, (ud, remove): (mlua::AnyUserData, bool)| {
let me = &mut ud.borrow_mut::<Self>()?.$($field).+;
if remove {
*me = me.remove_modifier(ratatui::style::Modifier::DIM);
*me = me.remove_modifier(ratatui_core::style::Modifier::DIM);
} else {
*me = me.add_modifier(ratatui::style::Modifier::DIM);
*me = me.add_modifier(ratatui_core::style::Modifier::DIM);
}
Ok(ud)
});
$methods.add_function("italic", |_, (ud, remove): (mlua::AnyUserData, bool)| {
let me = &mut ud.borrow_mut::<Self>()?.$($field).+;
if remove {
*me = me.remove_modifier(ratatui::style::Modifier::ITALIC);
*me = me.remove_modifier(ratatui_core::style::Modifier::ITALIC);
} else {
*me = me.add_modifier(ratatui::style::Modifier::ITALIC);
*me = me.add_modifier(ratatui_core::style::Modifier::ITALIC);
}
Ok(ud)
});
$methods.add_function("underline", |_, (ud, remove): (mlua::AnyUserData, bool)| {
let me = &mut ud.borrow_mut::<Self>()?.$($field).+;
if remove {
*me = me.remove_modifier(ratatui::style::Modifier::UNDERLINED);
*me = me.remove_modifier(ratatui_core::style::Modifier::UNDERLINED);
} else {
*me = me.add_modifier(ratatui::style::Modifier::UNDERLINED);
*me = me.add_modifier(ratatui_core::style::Modifier::UNDERLINED);
}
Ok(ud)
});
$methods.add_function("blink", |_, (ud, remove): (mlua::AnyUserData, bool)| {
let me = &mut ud.borrow_mut::<Self>()?.$($field).+;
if remove {
*me = me.remove_modifier(ratatui::style::Modifier::SLOW_BLINK);
*me = me.remove_modifier(ratatui_core::style::Modifier::SLOW_BLINK);
} else {
*me = me.add_modifier(ratatui::style::Modifier::SLOW_BLINK);
*me = me.add_modifier(ratatui_core::style::Modifier::SLOW_BLINK);
}
Ok(ud)
});
$methods.add_function("blink_rapid", |_, (ud, remove): (mlua::AnyUserData, bool)| {
let me = &mut ud.borrow_mut::<Self>()?.$($field).+;
if remove {
*me = me.remove_modifier(ratatui::style::Modifier::RAPID_BLINK);
*me = me.remove_modifier(ratatui_core::style::Modifier::RAPID_BLINK);
} else {
*me = me.add_modifier(ratatui::style::Modifier::RAPID_BLINK);
*me = me.add_modifier(ratatui_core::style::Modifier::RAPID_BLINK);
}
Ok(ud)
});
$methods.add_function("reverse", |_, (ud, remove): (mlua::AnyUserData, bool)| {
let me = &mut ud.borrow_mut::<Self>()?.$($field).+;
if remove {
*me = me.remove_modifier(ratatui::style::Modifier::REVERSED);
*me = me.remove_modifier(ratatui_core::style::Modifier::REVERSED);
} else {
*me = me.add_modifier(ratatui::style::Modifier::REVERSED);
*me = me.add_modifier(ratatui_core::style::Modifier::REVERSED);
}
Ok(ud)
});
$methods.add_function("hidden", |_, (ud, remove): (mlua::AnyUserData, bool)| {
let me = &mut ud.borrow_mut::<Self>()?.$($field).+;
if remove {
*me = me.remove_modifier(ratatui::style::Modifier::HIDDEN);
*me = me.remove_modifier(ratatui_core::style::Modifier::HIDDEN);
} else {
*me = me.add_modifier(ratatui::style::Modifier::HIDDEN);
*me = me.add_modifier(ratatui_core::style::Modifier::HIDDEN);
}
Ok(ud)
});
$methods.add_function("crossed", |_, (ud, remove): (mlua::AnyUserData, bool)| {
let me = &mut ud.borrow_mut::<Self>()?.$($field).+;
if remove {
*me = me.remove_modifier(ratatui::style::Modifier::CROSSED_OUT);
*me = me.remove_modifier(ratatui_core::style::Modifier::CROSSED_OUT);
} else {
*me = me.add_modifier(ratatui::style::Modifier::CROSSED_OUT);
*me = me.add_modifier(ratatui_core::style::Modifier::CROSSED_OUT);
}
Ok(ud)
});
$methods.add_function("reset", |_, ud: mlua::AnyUserData| {
ud.borrow_mut::<Self>()?.$($field).+ = ratatui::style::Style::reset();
ud.borrow_mut::<Self>()?.$($field).+ = ratatui_core::style::Style::reset();
Ok(ud)
});
};

3
yazi-binding/src/position/position.rs
View file

@ -1,6 +1,7 @@
use std::ops::{Deref, DerefMut};
use ratatui::{layout::Rect, widgets::Padding};
use ratatui_core::layout::Rect;
use ratatui_widgets::block::Padding;
use super::{Offset, Origin};

8
yazi-binding/src/style/style.rs
View file

@ -1,16 +1,16 @@
use std::ops::Deref;
use mlua::{ExternalError, FromLua, IntoLua, Lua, LuaSerdeExt, MetaMethod, Table, UserData, UserDataMethods, Value};
use ratatui::style::Modifier;
use ratatui_core::style::Modifier;
use yazi_shim::{cell::SyncCell, mlua::SER_OPT};
use crate::{elements::Color, style::StyleFlat};
#[derive(Clone, Copy, Default)]
pub struct Style(pub ratatui::style::Style);
pub struct Style(pub ratatui_core::style::Style);
impl Deref for Style {
type Target = ratatui::style::Style;
type Target = ratatui_core::style::Style;
fn deref(&self) -> &Self::Target { &self.0 }
}
@ -23,7 +23,7 @@ impl From<&SyncCell<StyleFlat>> for Style {
fn from(value: &SyncCell<StyleFlat>) -> Self { value.get().into() }
}
impl From<Style> for ratatui::style::Style {
impl From<Style> for ratatui_core::style::Style {
fn from(value: Style) -> Self { value.0 }
}

16
yazi-binding/src/style/style_flat.rs
View file

@ -1,4 +1,4 @@
use ratatui::style::Color;
use ratatui_core::style::Color;
use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, Default, Deserialize, Serialize)]
@ -16,10 +16,10 @@ pub struct StyleFlat {
pub crossed: Option<bool>,
}
impl From<ratatui::style::Style> for StyleFlat {
impl From<ratatui_core::style::Style> for StyleFlat {
#[rustfmt::skip]
fn from(value: ratatui::style::Style) -> Self {
use ratatui::style::Modifier as M;
fn from(value: ratatui_core::style::Style) -> Self {
use ratatui_core::style::Modifier as M;
let sub = value.sub_modifier;
let all = value.add_modifier - sub;
@ -40,10 +40,10 @@ impl From<ratatui::style::Style> for StyleFlat {
}
}
impl From<StyleFlat> for ratatui::style::Style {
impl From<StyleFlat> for ratatui_core::style::Style {
#[rustfmt::skip]
fn from(value: StyleFlat) -> Self {
use ratatui::style::Modifier as M;
use ratatui_core::style::Modifier as M;
let (mut add, mut sub) = (M::empty(), M::empty());
if let Some(b) = value.bold {
@ -85,7 +85,7 @@ impl From<StyleFlat> for ratatui::style::Style {
}
impl StyleFlat {
pub fn derive(self, other: ratatui::style::Style) -> ratatui::style::Style {
ratatui::style::Style::from(self).patch(other)
pub fn derive(self, other: ratatui_core::style::Style) -> ratatui_core::style::Style {
ratatui_core::style::Style::from(self).patch(other)
}
}

3
yazi-config/Cargo.toml
View file

@ -32,7 +32,8 @@ hashbrown = { workspace = true }
indexmap = { workspace = true }
inventory = { workspace = true }
mlua = { workspace = true }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
ratatui-widgets = { workspace = true }
regex = { workspace = true }
serde = { workspace = true }
serde_with = { workspace = true }

2
yazi-config/src/layout.rs
View file

@ -1,4 +1,4 @@
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
#[derive(Clone, Copy, Default, Eq, PartialEq)]
pub struct Layout {

3
yazi-config/src/popup/options.rs
View file

@ -1,4 +1,5 @@
use ratatui::{text::{Line, Text}, widgets::{Paragraph, Wrap}};
use ratatui_core::text::{Line, Text};
use ratatui_widgets::paragraph::{Paragraph, Wrap};
use yazi_binding::position::Position;
use yazi_macro::impl_data_any;
use yazi_shared::{strand::ToStrand, url::UrlBuf};

6
yazi-config/src/preview/wrap.rs
View file

@ -7,11 +7,11 @@ pub enum PreviewWrap {
Yes,
}
impl From<PreviewWrap> for Option<ratatui::widgets::Wrap> {
impl From<PreviewWrap> for Option<ratatui_widgets::paragraph::Wrap> {
fn from(wrap: PreviewWrap) -> Self {
match wrap {
PreviewWrap::No => None,
PreviewWrap::Yes => Some(ratatui::widgets::Wrap { trim: false }),
PreviewWrap::Yes => Some(ratatui_widgets::paragraph::Wrap { trim: false }),
}
}
}
@ -20,7 +20,7 @@ impl From<PreviewWrap> for yazi_binding::elements::Wrap {
fn from(value: PreviewWrap) -> Self {
Self(match value {
PreviewWrap::No => None,
PreviewWrap::Yes => Some(ratatui::widgets::Wrap { trim: false }),
PreviewWrap::Yes => Some(ratatui_widgets::paragraph::Wrap { trim: false }),
})
}
}

3
yazi-core/Cargo.toml
View file

@ -40,7 +40,8 @@ hashbrown = { workspace = true }
indexmap = { workspace = true }
mlua = { workspace = true }
parking_lot = { workspace = true }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
ratatui-widgets = { workspace = true }
serde = { workspace = true }
serde_with = { workspace = true }
strum = { workspace = true }

3
yazi-core/src/confirm/confirm.rs
View file

@ -1,4 +1,5 @@
use ratatui::{text::Line, widgets::Paragraph};
use ratatui_core::text::Line;
use ratatui_widgets::paragraph::Paragraph;
use yazi_binding::position::Position;
use yazi_shared::CompletionToken;

2
yazi-core/src/core.rs
View file

@ -1,4 +1,4 @@
use ratatui::layout::{Margin, Position, Rect};
use ratatui_core::layout::{Margin, Position, Rect};
use yazi_shared::Layer;
use yazi_tty::sequence::SetCursorStyle;

34
yazi-core/src/highlighter.rs
View file

@ -1,7 +1,7 @@
use std::{io::{BufRead, BufReader, Cursor, Seek}, path::PathBuf, sync::OnceLock};
use anyhow::{Result, anyhow, bail};
use ratatui::{layout::Size, text::{Line, Span, Text}};
use ratatui_core::{layout::Size, text::{Line, Span, Text}};
use syntect::{LoadingError, dumps, easy::HighlightLines, highlighting::{self, Theme, ThemeSet}, parsing::{SyntaxReference, SyntaxSet}};
use yazi_config::{THEME, YAZI};
use yazi_runner::previewer::PeekError;
@ -207,20 +207,20 @@ impl Highlighter {
impl Highlighter {
fn to_line_widget<'a>(regions: Vec<(highlighting::Style, &'a str)>) -> Line<'a> {
Line::from_iter(regions.into_iter().map(|(style, s)| {
let mut modifier = ratatui::style::Modifier::empty();
let mut modifier = ratatui_core::style::Modifier::empty();
if style.font_style.contains(highlighting::FontStyle::BOLD) {
modifier |= ratatui::style::Modifier::BOLD;
modifier |= ratatui_core::style::Modifier::BOLD;
}
if style.font_style.contains(highlighting::FontStyle::ITALIC) {
modifier |= ratatui::style::Modifier::ITALIC;
modifier |= ratatui_core::style::Modifier::ITALIC;
}
if style.font_style.contains(highlighting::FontStyle::UNDERLINE) {
modifier |= ratatui::style::Modifier::UNDERLINED;
modifier |= ratatui_core::style::Modifier::UNDERLINED;
}
Span {
content: s.into(),
style: ratatui::style::Style {
style: ratatui_core::style::Style {
fg: Self::to_ansi_color(style.foreground),
// bg: Self::to_ansi_color(style.background),
add_modifier: modifier,
@ -231,7 +231,7 @@ impl Highlighter {
}
// Copied from https://github.com/sharkdp/bat/blob/master/src/terminal.rs
fn to_ansi_color(color: highlighting::Color) -> Option<ratatui::style::Color> {
fn to_ansi_color(color: highlighting::Color) -> Option<ratatui_core::style::Color> {
if color.a == 0 {
// Themes can specify one of the user-configurable terminal colors by
// encoding them as #RRGGBBAA with AA set to 00 (transparent) and RR set
@ -242,14 +242,14 @@ impl Highlighter {
// sequences using codes 30-37 (foreground) and 40-47 (background).
// For example, red foreground is \x1b[31m. This works on terminals
// without 256-color support.
0x00 => ratatui::style::Color::Black,
0x01 => ratatui::style::Color::Red,
0x02 => ratatui::style::Color::Green,
0x03 => ratatui::style::Color::Yellow,
0x04 => ratatui::style::Color::Blue,
0x05 => ratatui::style::Color::Magenta,
0x06 => ratatui::style::Color::Cyan,
0x07 => ratatui::style::Color::White,
0x00 => ratatui_core::style::Color::Black,
0x01 => ratatui_core::style::Color::Red,
0x02 => ratatui_core::style::Color::Green,
0x03 => ratatui_core::style::Color::Yellow,
0x04 => ratatui_core::style::Color::Blue,
0x05 => ratatui_core::style::Color::Magenta,
0x06 => ratatui_core::style::Color::Cyan,
0x07 => ratatui_core::style::Color::White,
// For all other colors, use Fixed to produce escape sequences using
// codes 38;5 (foreground) and 48;5 (background). For example,
// bright red foreground is \x1b[38;5;9m. This only works on
@ -258,7 +258,7 @@ impl Highlighter {
// TODO: When ansi_term adds support for bright variants using codes
// 90-97 (foreground) and 100-107 (background), we should use those
// for values 0x08 to 0x0f and only use Fixed for 0x10 to 0xff.
n => ratatui::style::Color::Indexed(n),
n => ratatui_core::style::Color::Indexed(n),
})
} else if color.a == 1 {
// Themes can specify the terminal's default foreground/background color
@ -266,7 +266,7 @@ impl Highlighter {
// 01. The built-in theme ansi uses this.
None
} else {
Some(ratatui::style::Color::Rgb(color.r, color.g, color.b))
Some(ratatui_core::style::Color::Rgb(color.r, color.g, color.b))
}
}
}

2
yazi-core/src/mgr/mgr.rs
View file

@ -1,6 +1,6 @@
use std::iter;
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
use yazi_binding::position::{Origin, Position};
use yazi_fs::Splatable;
use yazi_shared::url::{AsUrl, Url, UrlBuf};

4
yazi-core/src/notify/message.rs
View file

@ -52,8 +52,8 @@ impl Message {
}
pub fn height(&self, width: u16) -> usize {
let lines = ratatui::widgets::Paragraph::new(self.content.as_str())
.wrap(ratatui::widgets::Wrap { trim: false })
let lines = ratatui_widgets::paragraph::Paragraph::new(self.content.as_str())
.wrap(ratatui_widgets::paragraph::Wrap { trim: false })
.line_count(width.saturating_sub(NOTIFY_BORDER));
lines + NOTIFY_BORDER as usize

2
yazi-core/src/notify/notify.rs
View file

@ -1,6 +1,6 @@
use std::ops::ControlFlow;
use ratatui::layout::{Constraint, Layout, Rect};
use ratatui_core::layout::{Constraint, Layout, Rect};
use tokio::task::JoinHandle;
use super::{Message, NOTIFY_SPACING};

2
yazi-core/src/tab/tab.rs
View file

@ -1,7 +1,7 @@
use std::borrow::Cow;
use anyhow::Result;
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
use tokio::task::JoinHandle;
use yazi_binding::position::{Origin, Position};
use yazi_config::LAYOUT;

2
yazi-emulator/Cargo.toml
View file

@ -22,7 +22,7 @@ yazi-tty = { path = "../yazi-tty", version = "26.5.9" }
# External dependencies
anyhow = { workspace = true }
either = { workspace = true }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
scopeguard = { workspace = true }
tokio = { workspace = true }
tracing = { workspace = true }

2
yazi-emulator/src/emulator.rs
View file

@ -2,7 +2,7 @@ use std::{io::{self, BufWriter, Write}, time::Duration};
use anyhow::Result;
use either::Either;
use ratatui::style::Color;
use ratatui_core::style::Color;
use scopeguard::defer;
use tokio::time::sleep;
use tracing::{debug, error, warn};

3
yazi-fm/Cargo.toml
View file

@ -46,7 +46,8 @@ better-panic = "0.3.0"
fdlimit = "0.3.0"
mlua = { workspace = true }
paste = { workspace = true }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
ratatui-widgets = { workspace = true }
tokio = { workspace = true }
tokio-stream = { workspace = true }
tracing = { workspace = true }

2
yazi-fm/src/app/sync_guard.rs
View file

@ -1,6 +1,6 @@
use std::{io::Write, sync::atomic::{AtomicU8, Ordering}};
use ratatui::layout::Position;
use ratatui_core::layout::Position;
use yazi_macro::writef;
use yazi_tty::{TTY, sequence::{BeginSyncUpdate, EndSyncUpdate, MoveTo, SetCursorStyle, ShowCursor}};

3
yazi-fm/src/cmp/cmp.rs
View file

@ -1,6 +1,7 @@
use std::path::MAIN_SEPARATOR_STR;
use ratatui::{buffer::Buffer, layout::Rect, widgets::{Block, BorderType, List, ListItem, Widget}};
use ratatui_core::{buffer::Buffer, layout::Rect, widgets::Widget};
use ratatui_widgets::{block::Block, borders::BorderType, list::{List, ListItem}};
use yazi_binding::position::{Offset, Position};
use yazi_config::THEME;
use yazi_core::Core;

5
yazi-fm/src/confirm/body.rs
View file

@ -1,4 +1,5 @@
use ratatui::{buffer::Buffer, layout::{Margin, Rect}, style::Styled, widgets::{Block, Borders, Widget}};
use ratatui_core::{buffer::Buffer, layout::{Margin, Rect}, style::Styled, widgets::Widget};
use ratatui_widgets::{block::Block, borders::Borders};
use yazi_config::THEME;
use yazi_core::Core;
@ -28,7 +29,7 @@ impl Widget for Body<'_> {
confirm
.body
.clone()
.alignment(ratatui::layout::Alignment::Center)
.alignment(ratatui_core::layout::Alignment::Center)
.block(block)
.style(THEME.confirm.body.get().derive(Styled::style(&confirm.body)))
.render(inner, buf);

6
yazi-fm/src/confirm/buttons.rs
View file

@ -1,4 +1,5 @@
use ratatui::{buffer::Buffer, layout::{Constraint, Rect}, text::Span, widgets::{Paragraph, Widget}};
use ratatui_core::{buffer::Buffer, layout::{Constraint, Rect}, text::Span, widgets::Widget};
use ratatui_widgets::paragraph::Paragraph;
use yazi_config::THEME;
pub(crate) struct Buttons;
@ -6,7 +7,8 @@ pub(crate) struct Buttons;
impl Widget for Buttons {
fn render(self, area: Rect, buf: &mut Buffer) {
let chunks =
ratatui::layout::Layout::horizontal([Constraint::Fill(1), Constraint::Fill(1)]).split(area);
ratatui_core::layout::Layout::horizontal([Constraint::Fill(1), Constraint::Fill(1)])
.split(area);
let labels = THEME.confirm.btn_labels.load();
Paragraph::new(Span::raw(&labels[0]).style(THEME.confirm.btn_yes.get()))

3
yazi-fm/src/confirm/confirm.rs
View file

@ -1,4 +1,5 @@
use ratatui::{buffer::Buffer, layout::{Alignment, Constraint, Layout, Margin, Rect}, widgets::{Block, BorderType, Widget}};
use ratatui_core::{buffer::Buffer, layout::{Alignment, Constraint, Layout, Margin, Rect}, widgets::Widget};
use ratatui_widgets::{block::Block, borders::BorderType};
use yazi_config::THEME;
use yazi_core::Core;

3
yazi-fm/src/confirm/list.rs
View file

@ -1,4 +1,5 @@
use ratatui::{buffer::Buffer, layout::{Margin, Rect}, widgets::{Block, Borders, Scrollbar, ScrollbarOrientation, ScrollbarState, StatefulWidget, Widget, Wrap}};
use ratatui_core::{buffer::Buffer, layout::{Margin, Rect}, widgets::{StatefulWidget, Widget}};
use ratatui_widgets::{block::Block, borders::Borders, paragraph::Wrap, scrollbar::{Scrollbar, ScrollbarOrientation, ScrollbarState}};
use yazi_config::THEME;
use yazi_core::Core;

3
yazi-fm/src/help/bindings.rs
View file

@ -1,4 +1,5 @@
use ratatui::{buffer::Buffer, layout::{self, Constraint, Rect}, widgets::{List, ListItem, Widget}};
use ratatui_core::{buffer::Buffer, layout::{self, Constraint, Rect}, widgets::Widget};
use ratatui_widgets::list::{List, ListItem};
use yazi_config::THEME;
use yazi_core::Core;

2
yazi-fm/src/help/help.rs
View file

@ -1,4 +1,4 @@
use ratatui::{buffer::Buffer, layout::{self, Constraint, Rect}, text::Line, widgets::Widget};
use ratatui_core::{buffer::Buffer, layout::{self, Constraint, Rect}, text::Line, widgets::Widget};
use yazi_config::{KEYMAP, THEME};
use yazi_core::Core;

3
yazi-fm/src/input/input.rs
View file

@ -1,4 +1,5 @@
use ratatui::{buffer::Buffer, layout::{Margin, Rect}, text::Line, widgets::{Block, BorderType, Widget}};
use ratatui_core::{buffer::Buffer, layout::{Margin, Rect}, text::Line, widgets::Widget};
use ratatui_widgets::{block::Block, borders::BorderType};
use yazi_config::THEME;
use yazi_core::Core;

2
yazi-fm/src/logs.rs
View file

@ -1,7 +1,7 @@
use std::{fs::File, io};
use anyhow::Context;
use ratatui::style::Color;
use ratatui_core::style::Color;
use tracing_appender::non_blocking::WorkerGuard;
use tracing_subscriber::EnvFilter;
use yazi_fs::Xdg;

2
yazi-fm/src/mgr/modal.rs
View file

@ -1,4 +1,4 @@
use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
use ratatui_core::{buffer::Buffer, layout::Rect, widgets::Widget};
use tracing::error;
use yazi_core::Core;

4
yazi-fm/src/mgr/preview.rs
View file

@ -1,4 +1,4 @@
use ratatui::{buffer::Buffer, widgets::Widget};
use ratatui_core::{buffer::Buffer, widgets::Widget};
use yazi_binding::elements::Spatial;
use yazi_config::LAYOUT;
use yazi_core::Core;
@ -13,7 +13,7 @@ impl<'a> Preview<'a> {
}
impl Widget for Preview<'_> {
fn render(self, win: ratatui::layout::Rect, buf: &mut Buffer) {
fn render(self, win: ratatui_core::layout::Rect, buf: &mut Buffer) {
let Some(lock) = &self.core.active().preview.lock else {
return;
};

3
yazi-fm/src/notify/notify.rs
View file

@ -1,4 +1,5 @@
use ratatui::{buffer::Buffer, layout::{self, Constraint, Offset, Rect}, widgets::{Block, BorderType, Paragraph, Widget, Wrap}};
use ratatui_core::{buffer::Buffer, layout::{self, Constraint, Offset, Rect}, widgets::Widget};
use ratatui_widgets::{block::Block, borders::BorderType, paragraph::{Paragraph, Wrap}};
use yazi_core::{Core, notify::Message};
pub(crate) struct Notify<'a> {

5
yazi-fm/src/pick/list.rs
View file

@ -1,4 +1,5 @@
use ratatui::{buffer::Buffer, layout::{Margin, Rect}, widgets::{ListItem, Scrollbar, ScrollbarOrientation, ScrollbarState, StatefulWidget, Widget}};
use ratatui_core::{buffer::Buffer, layout::{Margin, Rect}, widgets::{StatefulWidget, Widget}};
use ratatui_widgets::{list::ListItem, scrollbar::{Scrollbar, ScrollbarOrientation, ScrollbarState}};
use yazi_config::THEME;
use yazi_core::Core;
use yazi_widgets::Scrollable;
@ -33,6 +34,6 @@ impl Widget for List<'_> {
ListItem::new(format!(" {v}")).style(THEME.pick.inactive.get())
}
});
Widget::render(ratatui::widgets::List::new(items), inner, buf);
Widget::render(ratatui_widgets::list::List::new(items), inner, buf);
}
}

3
yazi-fm/src/pick/pick.rs
View file

@ -1,4 +1,5 @@
use ratatui::{buffer::Buffer, layout::{Margin, Rect}, widgets::{Block, BorderType, Widget}};
use ratatui_core::{buffer::Buffer, layout::{Margin, Rect}, widgets::Widget};
use ratatui_widgets::{block::Block, borders::BorderType};
use yazi_config::THEME;
use yazi_core::Core;

2
yazi-fm/src/renderer.rs
View file

@ -1,5 +1,5 @@
use mlua::{ObjectLike, Table};
use ratatui::{buffer::Buffer, layout::Rect};
use ratatui_core::{buffer::Buffer, layout::Rect};
use yazi_core::Core;
use yazi_plugin::LUA;
use yazi_widgets::{Renderable, Renderables};

2
yazi-fm/src/root.rs
View file

@ -1,5 +1,5 @@
use mlua::{ObjectLike, Table};
use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
use ratatui_core::{buffer::Buffer, layout::Rect, widgets::Widget};
use tracing::error;
use yazi_core::Core;
use yazi_plugin::LUA;

2
yazi-fm/src/spot/spot.rs
View file

@ -1,4 +1,4 @@
use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
use ratatui_core::{buffer::Buffer, layout::Rect, widgets::Widget};
use yazi_binding::elements::Spatial;
use yazi_core::Core;

2
yazi-fm/src/tasks/list.rs
View file

@ -1,4 +1,4 @@
use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
use ratatui_core::{buffer::Buffer, layout::Rect, widgets::Widget};
use tracing::error;
use yazi_core::Core;

2
yazi-fm/src/tasks/progress.rs
View file

@ -1,4 +1,4 @@
use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
use ratatui_core::{buffer::Buffer, layout::Rect, widgets::Widget};
use tracing::error;
use yazi_config::LAYOUT;
use yazi_core::Core;

3
yazi-fm/src/tasks/tasks.rs
View file

@ -1,4 +1,5 @@
use ratatui::{buffer::Buffer, layout::{self, Alignment, Constraint, Rect}, text::Line, widgets::{Block, BorderType, Widget}};
use ratatui_core::{buffer::Buffer, layout::{self, Alignment, Constraint, Rect}, text::Line, widgets::Widget};
use ratatui_widgets::{block::Block, borders::BorderType};
use yazi_config::THEME;
use yazi_core::{Core, tasks::TASKS_PERCENT};

2
yazi-fm/src/which/cand.rs
View file

@ -1,4 +1,4 @@
use ratatui::{buffer::Buffer, layout::Rect, text::{Line, Span}, widgets::Widget};
use ratatui_core::{buffer::Buffer, layout::Rect, text::{Line, Span}, widgets::Widget};
use yazi_config::{THEME, keymap::Chord};
pub(super) struct Cand<'a> {

3
yazi-fm/src/which/which.rs
View file

@ -1,4 +1,5 @@
use ratatui::{buffer::Buffer, layout, layout::{Constraint, Rect}, widgets::{Block, Widget}};
use ratatui_core::{buffer::Buffer, layout, layout::{Constraint, Rect}, widgets::Widget};
use ratatui_widgets::block::Block;
use yazi_config::THEME;
use yazi_core::Core;

3
yazi-parser/Cargo.toml
View file

@ -17,7 +17,6 @@ default = [ "vendored-lua" ]
vendored-lua = [ "mlua/vendored" ]
[dependencies]
yazi-binding = { path = "../yazi-binding", version = "26.5.6" }
yazi-boot = { path = "../yazi-boot", version = "26.5.6" }
yazi-config = { path = "../yazi-config", version = "26.5.6" }
yazi-core = { path = "../yazi-core", version = "26.5.6" }
@ -37,7 +36,7 @@ bitflags = { workspace = true }
hashbrown = { workspace = true }
mlua = { workspace = true }
paste = { workspace = true }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
serde = { workspace = true }
serde_with = { workspace = true }
strum = { workspace = true }

2
yazi-parser/src/app/reflow.rs
View file

@ -1,5 +1,5 @@
use mlua::{ExternalError, FromLua, IntoLua, Lua, Table, Value};
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
#[derive(Debug)]
pub struct ReflowForm {

3
yazi-plugin/Cargo.toml
View file

@ -44,7 +44,8 @@ futures = { workspace = true }
inventory = { workspace = true }
mlua = { workspace = true }
percent-encoding = { workspace = true }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
ratatui-widgets = { workspace = true }
serde_json = { workspace = true }
tokio = { workspace = true }
tokio-stream = { workspace = true }

10
yazi-plugin/src/utils/spot.rs
View file

@ -14,19 +14,19 @@ impl Utils {
let mut table = yazi_binding::elements::Table::try_from(&table)?;
let area = table.area();
table.set_area(area.inner(ratatui::widgets::Padding::uniform(1)));
table.set_area(area.inner(ratatui_widgets::block::Padding::uniform(1)));
lock.data = vec![
Renderable::Clear(Default::default()).with_area(area),
Renderable::Border(yazi_binding::elements::Border {
area,
edge: Edge(ratatui::widgets::Borders::ALL),
r#type: ratatui::widgets::BorderType::Rounded,
edge: Edge(ratatui_widgets::borders::Borders::ALL),
r#type: ratatui_widgets::borders::BorderType::Rounded,
style: THEME.spot.border.get().into(),
merge: Default::default(),
titles: vec![(
ratatui::widgets::TitlePosition::Top,
ratatui::text::Line::raw("Spot").centered().style(THEME.spot.title.get()),
ratatui_widgets::block::TitlePosition::Top,
ratatui_core::text::Line::raw("Spot").centered().style(THEME.spot.title.get()),
)],
}),
Renderable::Table(Box::new(table)),

3
yazi-shim/Cargo.toml
View file

@ -26,7 +26,8 @@ base64 = { workspace = true }
hashbrown = { workspace = true }
mlua = { workspace = true }
percent-encoding = { workspace = true }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
ratatui-widgets = { workspace = true }
serde = { workspace = true }
thiserror = { workspace = true }
toml = { workspace = true }

3
yazi-shim/src/ratatui/line.rs
View file

@ -1,6 +1,7 @@
use std::{boxed::Box, iter, slice::Iter, str::{self, Lines}};
use ratatui::{layout::Alignment, style::Style, text::Line, widgets::Wrap};
use ratatui_core::{layout::Alignment, style::Style, text::Line};
use ratatui_widgets::paragraph::Wrap;
use super::wrapper::{LineComposer, WordWrapper};
use crate::ratatui::SpanIter;

2
yazi-shim/src/ratatui/span.rs
View file

@ -1,6 +1,6 @@
use std::slice::Iter;
use ratatui::{style::Style, text::{Line, Span, StyledGrapheme}};
use ratatui_core::{style::Style, text::{Line, Span, StyledGrapheme}};
use unicode_segmentation::{Graphemes, UnicodeSegmentation};
#[allow(private_interfaces)]

2
yazi-shim/src/ratatui/wrapper.rs
View file

@ -1,7 +1,7 @@
// Copied from https://github.com/ratatui/ratatui/blob/main/ratatui-widgets/src/reflow.rs
use std::{collections::VecDeque, mem};
use ratatui::{layout::Alignment, text::StyledGrapheme};
use ratatui_core::{layout::Alignment, text::StyledGrapheme};
use unicode_width::UnicodeWidthStr;
pub trait LineComposer<'a> {

2
yazi-tty/Cargo.toml
View file

@ -22,7 +22,7 @@ base64 = { workspace = true }
bitflags = { workspace = true }
mlua = { workspace = true }
parking_lot = { workspace = true }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
tracing = { workspace = true }
[target."cfg(unix)".dependencies]

2
yazi-tty/src/sequence/erase.rs
View file

@ -1,6 +1,6 @@
use std::fmt::{self, Display};
use ratatui::backend::ClearType;
use ratatui_core::backend::ClearType;
/// Erase entire display
pub struct EraseScreen;

2
yazi-tty/src/sequence/style.rs
View file

@ -1,6 +1,6 @@
use std::fmt::{self, Display};
use ratatui::style::Color;
use ratatui_core::style::Color;
/// Set foreground color from a `Color`.
pub struct SetFg(pub Color);

2
yazi-tui/Cargo.toml
View file

@ -23,5 +23,5 @@ yazi-tty = { path = "../yazi-tty", version = "26.5.9" }
# External dependencies
anyhow = { workspace = true }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
tokio = { workspace = true }

2
yazi-tui/src/backend.rs
View file

@ -1,6 +1,6 @@
use std::{io::{self, Write}, ops::{Deref, DerefMut}};
use ratatui::{backend::{Backend, ClearType, WindowSize}, buffer::Cell, layout::{Position, Size}, style::{Color, Modifier}};
use ratatui_core::{backend::{Backend, ClearType, WindowSize}, buffer::Cell, layout::{Position, Size}, style::{Color, Modifier}};
use yazi_macro::writef;
use yazi_term::TERM;
use yazi_tty::sequence::{EraseRegion, HideCursor, MoveTo, ResetAttrs, SetBg, SetFg, SetSgr, SetUnderlineColor, ShowCursor};

2
yazi-tui/src/raterm.rs
View file

@ -1,7 +1,7 @@
use std::{io::{self, Write}, ops::Deref};
use anyhow::Result;
use ratatui::{CompletedFrame, Frame, Terminal, buffer::Buffer, layout::Rect};
use ratatui_core::{buffer::Buffer, layout::Rect, terminal::{CompletedFrame, Frame, Terminal}};
use yazi_config::YAZI;
use yazi_emulator::{Emulator, Mux, TMUX};
use yazi_macro::writef;

3
yazi-widgets/Cargo.toml
View file

@ -31,7 +31,8 @@ futures = { workspace = true }
inventory = { workspace = true }
mlua = { workspace = true }
parking_lot = { workspace = true }
ratatui = { workspace = true }
ratatui-core = { workspace = true }
ratatui-widgets = { workspace = true }
serde = { workspace = true }
strum = { workspace = true }
tokio = { workspace = true }

4
yazi-widgets/src/clear/clear.rs
View file

@ -1,5 +1,5 @@
use mlua::{AnyUserData, IntoLua, Lua, MetaMethod, Table, UserData, UserDataMethods, Value};
use ratatui::{buffer::{Buffer, CellDiffOption}, layout::Rect, widgets::Widget};
use ratatui_core::{buffer::{Buffer, CellDiffOption}, layout::Rect, widgets::Widget};
use yazi_binding::{elements::{Area, Spatial}, impl_area_method};
use crate::clear::ClearInventory;
@ -37,7 +37,7 @@ impl Widget for Clear {
where
Self: Sized,
{
ratatui::widgets::Clear.render(area, buf);
ratatui_widgets::clear::Clear.render(area, buf);
for inv in inventory::iter::<ClearInventory> {
if let Some(overlap) = (inv.clear)(area) {

2
yazi-widgets/src/clear/inventory.rs
View file

@ -1,4 +1,4 @@
use ratatui::layout::Rect;
use ratatui_core::layout::Rect;
pub struct ClearInventory {
pub clear: fn(Rect) -> Option<Rect>,

4
yazi-widgets/src/input/input_arc.rs
View file

@ -2,7 +2,7 @@ use std::sync::Arc;
use mlua::{AnyUserData, IntoLua, Lua, MetaMethod, Table, UserData, UserDataMethods, Value};
use parking_lot::Mutex;
use ratatui::widgets::Widget;
use ratatui_core::widgets::Widget;
use yazi_binding::{elements::{Area, Spatial}, impl_area_method, position::{Offset, Origin, Position}};
use crate::input::{Input, InputOpt, InputStyles};
@ -66,7 +66,7 @@ impl Spatial for InputArc {
}
impl Widget for &InputArc {
fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer)
fn render(self, rect: ratatui_core::layout::Rect, buf: &mut ratatui_core::buffer::Buffer)
where
Self: Sized,
{

2
yazi-widgets/src/input/styles.rs
View file

@ -1,5 +1,5 @@
use mlua::{ExternalError, FromLua, Lua, Table, Value};
use ratatui::style::Style;
use ratatui_core::style::Style;
#[derive(Clone, Debug, Default)]
pub struct InputStyles {

2
yazi-widgets/src/input/widget.rs
View file

@ -1,6 +1,6 @@
use std::ops::Range;
use ratatui::{buffer::Buffer, layout::Rect, text::Line, widgets::Widget};
use ratatui_core::{buffer::Buffer, layout::Rect, text::Line, widgets::Widget};
use super::Input;

Some files were not shown because too many files have changed in this diff Show more