feat: dynamic keymap Lua API (#4031)

Author: sxyazi

CHANGELOG.md

@@ -16,6 +16,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/):
 
 - Drag and drop ([#4005])
 - Bulk create ([#3793])
+- Dynamic keymap Lua API ([#4031])
 - Image preview with Überzug++ on Niri ([#3990])
 - New gait for input `backward` and `forward` actions ([#4012])
 
@@ -1742,3 +1743,4 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/):
 [#4005]: https://github.com/sxyazi/yazi/pull/4005
 [#4012]: https://github.com/sxyazi/yazi/pull/4012
 [#4022]: https://github.com/sxyazi/yazi/pull/4022
+[#4031]: https://github.com/sxyazi/yazi/pull/4031

CONTRIBUTING.md

@@ -11,6 +11,7 @@ This guide will help you understand how to contribute to the project.
 3. [Development Setup](#development-setup)
 4. [How to Contribute](#how-to-contribute)
 5. [Pull Requests](#pull-requests)
+6. [AI Policy](#ai-policy)
 
 ## Getting Started
 

Cargo.lock

@@ -26,7 +26,7 @@ impl UserData for Which {
 		fields.add_cached_field("tx", |_, me| Ok(me.tx.clone().map(yazi_binding::MpscUnboundedTx)));
 		fields.add_field_method_get("times", |_, me| Ok(me.inner.times));
 		fields.add_cached_field("cands", |lua, me| {
-			lua.create_sequence_from(me.inner.cands.iter().cloned().map(yazi_binding::keymap::ChordCow))
+			lua.create_sequence_from(me.inner.cands.iter().map(yazi_binding::keymap::Chord::from))
 		});
 
 		fields.add_field_method_get("active", |_, me| Ok(me.inner.active));

yazi-actor/src/lives/which.rs

@@ -39,6 +39,7 @@ mlua          = { workspace = true }
 ordered-float = { workspace = true }
 paste         = { workspace = true }
 ratatui       = { workspace = true }
+serde         = { workspace = true }
 serde_json    = { workspace = true }
 tokio  	      = { workspace = true }
 tokio-stream  = { workspace = true }

yazi-binding/Cargo.toml

@@ -1,6 +1,6 @@
-use std::{mem, ops::{Deref, DerefMut}};
+use std::ops::{Deref, DerefMut};
 
-use mlua::{UserData, UserDataFields};
+use mlua::{FromLua, Lua, UserData, UserDataFields, Value};
 use yazi_shim::mlua::UserDataFieldsExt;
 
 use crate::event::Cmd;
@@ -19,12 +19,34 @@ impl DerefMut for Action {
 	fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner }
 }
 
+impl From<Action> for yazi_shared::event::Action {
+	fn from(value: Action) -> Self { value.inner }
+}
+
+impl From<Action> for yazi_shared::event::Actions {
+	fn from(value: Action) -> Self { Self::from(value.inner) }
+}
+
 impl Action {
 	pub fn new(inner: impl Into<yazi_shared::event::Action>) -> Self { Self { inner: inner.into() } }
 }
 
+impl FromLua for Action {
+	fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
+		Ok(match value {
+			Value::String(s) => Self { inner: s.to_str()?.parse()? },
+			Value::UserData(ud) => ud.take()?,
+			_ => Err(mlua::Error::FromLuaConversionError {
+				from:    value.type_name(),
+				to:      "Action".to_owned(),
+				message: Some("expected a string or an Action".to_string()),
+			})?,
+		})
+	}
+}
+
 impl UserData for Action {
 	fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
-		fields.add_cached_field_mut("cmd", |_, me| Ok(Cmd::new(mem::take(&mut me.cmd))));
+		fields.add_cached_field("cmd", |_, me| Ok(Cmd::new(me.cmd.clone())));
 	}
 }

yazi-binding/src/event/action.rs

@@ -0,0 +1,50 @@
+use std::ops::{Deref, DerefMut};
+
+use mlua::{ExternalError, FromLua, IntoLua, Lua, Value};
+
+use crate::event::Action;
+
+#[derive(Clone)]
+pub struct Actions {
+	inner: yazi_shared::event::Actions,
+}
+
+impl Deref for Actions {
+	type Target = yazi_shared::event::Actions;
+
+	fn deref(&self) -> &Self::Target { &self.inner }
+}
+
+impl DerefMut for Actions {
+	fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner }
+}
+
+impl From<Actions> for yazi_shared::event::Actions {
+	fn from(value: Actions) -> Self { value.inner }
+}
+
+impl Actions {
+	pub fn new(inner: yazi_shared::event::Actions) -> Self { Self { inner } }
+}
+
+impl FromLua for Actions {
+	fn from_lua(value: Value, lua: &Lua) -> mlua::Result<Self> {
+		let inner = match value {
+			Value::Table(t) => t
+				.sequence_values::<Action>()
+				.map(|a| a.map(Into::into))
+				.collect::<mlua::Result<Vec<_>>>()?
+				.into(),
+			v @ Value::String(_) => Action::from_lua(v, lua)?.into(),
+			_ => Err("expected a string or a table of actions".into_lua_err())?,
+		};
+
+		Ok(Self { inner })
+	}
+}
+
+impl IntoLua for Actions {
+	fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {
+		lua.create_sequence_from(self.inner.into_iter().map(Action::new))?.into_lua(lua)
+	}
+}

yazi-binding/src/event/actions.rs

@@ -1 +1 @@
-yazi_macro::mod_flat!(action cmd);
+yazi_macro::mod_flat!(action actions cmd);

yazi-binding/src/event/mod.rs

@@ -1,33 +1,61 @@
-use std::{ops::Deref, sync::Arc};
+use std::ops::Deref;
 
-use mlua::{ExternalError, FromLua, IntoLua, Lua, LuaSerdeExt, Table, UserData, UserDataFields, Value};
+use mlua::{ExternalError, FromLua, IntoLua, Lua, Table, UserData, UserDataFields, Value};
+use serde::Deserialize;
+use yazi_codegen::FromLuaOwned;
 use yazi_shim::mlua::UserDataFieldsExt;
 
-use crate::{Id, Iter, event::Action, keymap::Key};
+use crate::{Id, Iter, event::Actions, keymap::Key};
 
+#[derive(FromLuaOwned)]
 pub struct Chord {
-	inner: Arc<yazi_config::keymap::Chord>,
+	inner: yazi_config::keymap::ChordArc,
 }
 
 impl Deref for Chord {
-	type Target = Arc<yazi_config::keymap::Chord>;
+	type Target = yazi_config::keymap::ChordArc;
 
 	fn deref(&self) -> &Self::Target { &self.inner }
 }
 
-impl From<Chord> for Arc<yazi_config::keymap::Chord> {
+impl From<&yazi_config::keymap::ChordArc> for Chord {
+	fn from(value: &yazi_config::keymap::ChordArc) -> Self { Self { inner: value.clone() } }
+}
+
+impl From<Chord> for yazi_config::keymap::ChordArc {
 	fn from(value: Chord) -> Self { value.inner }
 }
 
 impl Chord {
-	pub fn new(inner: impl Into<Arc<yazi_config::keymap::Chord>>) -> Self {
+	pub fn new(inner: impl Into<yazi_config::keymap::ChordArc>) -> Self {
 		Self { inner: inner.into() }
 	}
 }
 
-impl FromLua for Chord {
-	fn from_lua(value: Value, lua: &Lua) -> mlua::Result<Self> {
-		Ok(Self::new(lua.from_value::<yazi_config::keymap::Chord>(value)?))
+impl TryFrom<(Value, yazi_shared::Layer)> for Chord {
+	type Error = mlua::Error;
+
+	fn try_from((value, layer): (Value, yazi_shared::Layer)) -> Result<Self, Self::Error> {
+		use yazi_config::keymap::Chord as C;
+		use yazi_shared::Layer as L;
+
+		let de = mlua::serde::Deserializer::new(value);
+		let inner = match layer {
+			L::Null => C::<{ L::Null as u8 }>::deserialize(de)?.into(),
+			L::App => C::<{ L::App as u8 }>::deserialize(de)?.into(),
+			L::Mgr => C::<{ L::Mgr as u8 }>::deserialize(de)?.into(),
+			L::Tasks => C::<{ L::Tasks as u8 }>::deserialize(de)?.into(),
+			L::Spot => C::<{ L::Spot as u8 }>::deserialize(de)?.into(),
+			L::Pick => C::<{ L::Pick as u8 }>::deserialize(de)?.into(),
+			L::Input => C::<{ L::Input as u8 }>::deserialize(de)?.into(),
+			L::Confirm => C::<{ L::Confirm as u8 }>::deserialize(de)?.into(),
+			L::Help => C::<{ L::Help as u8 }>::deserialize(de)?.into(),
+			L::Cmp => C::<{ L::Cmp as u8 }>::deserialize(de)?.into(),
+			L::Which => C::<{ L::Which as u8 }>::deserialize(de)?.into(),
+			L::Notify => C::<{ L::Notify as u8 }>::deserialize(de)?.into(),
+		};
+
+		Ok(Self { inner })
 	}
 }
 
@@ -38,9 +66,7 @@ impl UserData for Chord {
 		fields
 			.add_cached_field("on", |lua, me| lua.create_sequence_from(me.on.iter().copied().map(Key)));
 
-		fields.add_cached_field("run", |lua, me| {
-			lua.create_sequence_from(me.run.iter().cloned().map(Action::new))
-		});
+		fields.add_cached_field("run", |_, me| Ok(Actions::new(me.run.clone())));
 
 		fields.add_cached_field("desc", |lua, me| lua.create_string(&me.desc));
 	}