mod generated_json;
mod mark_node;
mod mark_state_extension;
#[cfg(feature = "extension")]
mod mark_state_inserted_text;
pub use mark_node::{MarkNode, create_mark_node, is_mark_node};
pub use mark_state_extension::{
MARK_STATE_IDS_ATTRIBUTE, MARK_STATE_KEY, MarkFlavor, MarkIDsMode, add_mark_id,
get_mark_ids_at_selection, get_node_mark_ids, is_inline_decorator_node,
migrate_mark_nodes_to_mark_state, remove_mark_id,
};
#[cfg(feature = "extension")]
pub use mark_state_extension::{
MarkBaseExtensionType, MarkBaseInit, MarkBaseOutput, MarkFlavorDefinition, MarkFlavorExtension,
MarkIDNodeKeys, MarkIDsChange, MarkIDsListener, MarkStateConfig, MarkStateConfigOverrides,
MarkStateInit, MarkStateOutput, MarkableNodeMatch, add_mark_id_for, default_markable_nodes,
define_mark_extension, get_mark_ids_at_selection_for, get_mark_ids_by_flavor,
get_node_mark_ids_for, mark_base_extension, mark_flavor, mark_state_extension,
migrate_mark_nodes_to_mark_state_for, register_mark_ids_listener, remove_mark_id_for,
};
use crate::lexical_selection::{SelectionRef, Which, create_range_selection};
use crate::node::NodeRef;
use crate::{LexicalError, NodeClass};
pub fn mark_nodes() -> Vec<NodeClass> {
vec![NodeClass::of::<MarkNode>()]
}
#[cfg(feature = "extension")]
pub use mark_extension::{MarkExtensionType, mark_extension};
#[cfg(feature = "extension")]
mod mark_extension {
use crate::extension_core::{LexicalExtension, define_extension};
use std::rc::Rc;
pub type MarkExtensionType = LexicalExtension;
thread_local! {
static MARK_EXTENSION: Rc<MarkExtensionType> = define_extension(LexicalExtension {
nodes: super::mark_nodes(),
..LexicalExtension::new("@lexical/mark", ())
});
}
pub fn mark_extension() -> Rc<MarkExtensionType> {
MARK_EXTENSION.with(Rc::clone)
}
}
pub fn unwrap_mark_node(node: &NodeRef) -> Result<(), LexicalError> {
let mut target: Option<NodeRef> = None;
for child in node.get_children() {
match &target {
None => node.insert_before(&child, true)?,
Some(target) => target.insert_after(&child, true)?,
};
target = Some(child);
}
node.remove(false)
}
type CreateNode = dyn Fn(&[String]) -> NodeRef;
pub fn wrap_selection_in_mark_node(
selection: &SelectionRef,
is_backward: bool,
id: &str,
create_node: Option<&CreateNode>,
) -> Result<(), LexicalError> {
let forward_selection = create_range_selection();
let (start, end) = if selection.is_backward()? {
(Which::Focus, Which::Anchor)
} else {
(Which::Anchor, Which::Focus)
};
for (which, from) in [(Which::Anchor, start), (Which::Focus, end)] {
let point = selection.point(from).expect("a range selection");
forward_selection.point_set(which, &point.key, point.offset, point.point_type)?;
}
let mut current_node_parent: Option<NodeRef> = None;
let mut last_created_mark_node: Option<NodeRef> = None;
for node in forward_selection.extract()? {
if last_created_mark_node
.as_ref()
.is_some_and(|mark| mark.is_parent_of(&node))
{
continue;
}
let target_node = if node.is_text() {
Some(node)
} else if is_mark_node(&node) {
continue;
} else if (node.is_element() || node.is_decorator()) && node.is_inline() {
Some(node)
} else {
None
};
let Some(target_node) = target_node else {
current_node_parent = None;
last_created_mark_node = None;
continue;
};
if current_node_parent.as_ref() == Some(&target_node) {
continue;
}
let parent_node = target_node.get_parent();
if parent_node.is_none() || parent_node != current_node_parent {
last_created_mark_node = None;
}
current_node_parent = parent_node;
let mark_node = match &last_created_mark_node {
Some(mark_node) => mark_node.clone(),
None => {
let ids = [id.to_owned()];
let mark_node = match create_node {
Some(create_node) => create_node(&ids),
None => create_mark_node(&ids),
};
target_node.insert_before(&mark_node, true)?;
last_created_mark_node = Some(mark_node.clone());
mark_node
}
};
mark_node.append(&[target_node])?;
}
if let Some(mark_node) = last_created_mark_node {
if is_backward {
mark_node.select_start()?;
} else {
mark_node.select_end()?;
}
}
Ok(())
}
pub fn get_mark_ids(node: &NodeRef, offset: usize) -> Option<Vec<String>> {
let mut current_node = Some(node.clone());
while let Some(current) = current_node {
if is_mark_node(¤t) {
return current.get_ids();
} else if current.is_text()
&& offset == current.get_text_content_size()
&& let Some(next_sibling) = current.get_next_sibling().filter(is_mark_node)
{
return next_sibling.get_ids();
}
current_node = current.get_parent();
}
None
}