use super::utils::{ComputedStyle, get_computed_style_for_element, get_computed_style_for_parent};
use crate::caret::{CaretDirection, RootMode, extend_caret_to_range, flip_direction};
use crate::caret_utils::{caret_from_point, is_extendable_text_point_caret};
use crate::error::invariant;
use crate::lexical_selection::{RangeSelection, get_selection, has_ancestor, set_selection};
use crate::lexical_utils::is_block;
use crate::nodes::line_break::LineBreakNode;
use crate::nodes::tab::TabNode;
use crate::selection_insert_nodes::{
find_matching_parent, get_previous_selection, is_block_container,
};
use crate::set_dom_style::get_style_object_from_css;
use crate::{
LexicalError, NodeRef, Point, PointType, SelectionAlter, SelectionGranularity, SelectionRef,
Which,
};
use std::collections::{HashMap, HashSet};
pub fn copy_block_format_indent(
src_node: &NodeRef,
dest_node: &NodeRef,
) -> Result<(), LexicalError> {
let format = src_node.element_data().get_format_type();
let indent = src_node.get_indent()?;
if format != dest_node.element_data().get_format_type() {
dest_node.set_element_format(format);
}
if indent != dest_node.get_indent()? {
dest_node.set_indent(indent)?;
}
Ok(())
}
pub fn is_at_edge_of_element(
point: &Point,
element: &NodeRef,
direction: CaretDirection,
) -> Result<bool, LexicalError> {
let mut caret = Some(caret_from_point(point, direction)?);
if caret.as_ref().is_some_and(is_extendable_text_point_caret) {
return Ok(false);
}
while let Some(c) = caret {
let Some(parent) = c.get_parent_at_caret() else {
return Ok(false);
};
if c.get_node_at_caret().is_some() {
return Ok(false);
}
if parent.get_key() == element.get_key() {
return Ok(true);
}
caret = c.get_parent_caret(RootMode::Root);
}
Ok(false)
}
fn is_point_at_block_edge(
point: &Point,
block: &NodeRef,
direction: CaretDirection,
) -> Result<bool, LexicalError> {
let node = point.get_node()?;
if node.is_element() && node.is_empty() {
return Ok(false);
}
is_at_edge_of_element(point, block, direction)
}
pub type AfterCreateElement = dyn Fn(&NodeRef, &NodeRef) -> Result<(), LexicalError>;
pub fn set_blocks_type(
selection: Option<&SelectionRef>,
create_element: impl Fn() -> NodeRef,
after_create_element: Option<&AfterCreateElement>,
) -> Result<(), LexicalError> {
let Some(selection) = selection else {
return Ok(());
};
let after_create_element = after_create_element.unwrap_or(©_block_format_indent);
let anchor_and_focus = selection.range().map(|range| (range.anchor, range.focus));
let mut skip_focus = false;
let mut focus_block: Option<NodeRef> = None;
let mut block_map: Vec<NodeRef> = Vec::new();
let mut set = |node: NodeRef| {
if !block_map.contains(&node) {
block_map.push(node);
}
};
if let Some((anchor, focus)) = &anchor_and_focus {
let anchor_block = find_matching_parent(&anchor.get_node()?, is_block);
focus_block = find_matching_parent(&focus.get_node()?, is_block);
let direction = if selection.is_backward()? {
CaretDirection::Previous
} else {
CaretDirection::Next
};
skip_focus = match &focus_block {
Some(block) if block.is_element() && anchor_block.as_ref() != Some(block) => {
is_point_at_block_edge(focus, block, flip_direction(direction))?
}
_ => false,
};
if let Some(block) = anchor_block.filter(NodeRef::is_element) {
set(block);
}
if let Some(block) = focus_block.clone().filter(NodeRef::is_element)
&& !skip_focus
{
set(block);
}
}
for node in selection.get_nodes()? {
if node.is_element() && is_block(&node) {
if skip_focus && focus_block.as_ref() == Some(&node) {
continue;
}
set(node);
} else if anchor_and_focus.is_none()
&& let Some(ancestor_block) =
find_matching_parent(&node, is_block).filter(NodeRef::is_element)
{
set(ancestor_block);
}
}
for prev_node in block_map {
if crate::slot::get_slot_host(&prev_node).is_some() {
continue;
}
if is_block_container(&prev_node) {
let mut selections = vec![selection.clone()];
if let Some(active) = get_selection()
&& !active.ptr_eq(selection)
{
selections.push(active);
}
let mut points: Vec<(SelectionRef, Which)> = Vec::new();
for s in selections.into_iter().filter(SelectionRef::is_range) {
for which in [Which::Anchor, Which::Focus] {
if s.point(which).is_some_and(|p| p.key == prev_node.get_key()) {
points.push((s.clone(), which));
}
}
}
if !points.is_empty() && prev_node.is_empty() {
let element = create_element();
prev_node.append(std::slice::from_ref(&element))?;
for (s, which) in points {
s.point_set(which, element.get_key(), 0, PointType::Element)?;
}
}
continue;
}
let element = create_element();
after_create_element(&prev_node, &element)?;
prev_node.replace(&element, true)?;
}
Ok(())
}
fn is_point_attached(point: &Point) -> Result<bool, LexicalError> {
Ok(point.get_node()?.is_attached())
}
fn is_leaf_node(node: &NodeRef) -> bool {
node.is_text() || node.get_latest().is::<LineBreakNode>() || node.is_decorator()
}
fn is_inline_content(node: &NodeRef) -> bool {
crate::internal_is_inline_content(node)
}
fn remove_parent_empty_elements(starting_node: &NodeRef) -> Result<(), LexicalError> {
let mut node = Some(starting_node.clone());
while let Some(n) = node.filter(|n| !is_block_container(n)) {
let parent_node = n.get_parent();
if n.get_children_size() == 0 {
n.remove(true)?;
}
node = parent_node;
}
Ok(())
}
fn wrapped_block(node: &NodeRef, cache: &mut HashMap<String, Option<NodeRef>>) -> Option<NodeRef> {
let mut walked: Vec<String> = Vec::new();
let mut block = Some(node.clone());
let found = loop {
let Some(b) = block else {
break None;
};
if let Some(found) = cache.get(b.get_key()) {
break found.clone();
}
if is_block_container(&b) || (b.is_element() && !is_inline_content(&b)) {
break Some(b);
}
walked.push(b.get_key().to_owned());
block = b.get_parent();
};
for key in walked {
cache.insert(key, found.clone());
}
found
}
fn is_block_leaf_in_element(node: &NodeRef, cache: &mut HashMap<String, bool>) -> bool {
let Some(parent) = node.get_parent() else {
return false;
};
if !is_leaf_node(node) || is_inline_content(node) || is_block_container(&parent) {
return false;
}
*cache
.entry(parent.get_key().to_owned())
.or_insert_with(|| parent.get_children().iter().all(|c| !is_inline_content(c)))
}
fn is_empty_block(node: &NodeRef) -> bool {
node.is_element() && node.get_children_size() == 0 && !is_inline_content(node)
}
fn child_in(container: &NodeRef, node: &NodeRef, cache: &mut HashMap<String, NodeRef>) -> NodeRef {
let mut walked: Vec<String> = Vec::new();
let mut child = node.clone();
let mut found = cache.get(child.get_key()).cloned();
while found.is_none() {
match child.get_parent() {
Some(parent) if parent != *container => {
walked.push(child.get_key().to_owned());
child = parent;
found = cache.get(child.get_key()).cloned();
}
_ => {
found = Some(child.clone());
}
}
}
let found = found.expect("set above");
for key in walked {
cache.insert(key, found.clone());
}
cache.insert(node.get_key().to_owned(), found.clone());
found
}
fn inline_run(child: &NodeRef) -> Vec<NodeRef> {
let mut first = child.clone();
while let Some(prev) = first.get_previous_sibling().filter(is_inline_content) {
first = prev;
}
let mut run = Vec::new();
let mut it = Some(first);
while let Some(node) = it.filter(is_inline_content) {
it = node.get_next_sibling();
run.push(node);
}
run
}
pub fn wrap_nodes(
selection: &SelectionRef,
create_element: impl Fn() -> NodeRef,
wrapping_element: Option<&NodeRef>,
) -> Result<(), LexicalError> {
let anchor = selection.point(Which::Anchor);
let nodes = selection.get_nodes()?;
let nodes_length = nodes.len();
if let Some(anchor) = &anchor
&& let Some(slot_frame) = crate::slot::get_slot_frame(&anchor.get_node()?)
&& !crate::selection_insert_nodes::is_block_container(&slot_frame)
{
return Ok(());
}
if let Some(anchor) = &anchor {
let anchor_node = anchor.get_node()?;
if nodes_length == 0
|| (nodes_length == 1
&& anchor.point_type == PointType::Element
&& anchor_node.get_children_size() == 0)
{
let Some(target) = wrapped_block(&anchor_node, &mut HashMap::new()) else {
return Ok(());
};
let children = target.get_children();
let mut element = create_element();
let into_container = is_block_container(&target);
if !into_container {
element.set_element_format(target.element_data().get_format_type());
element.set_indent(target.get_indent()?)?;
}
for child in children {
element.append(&[child])?;
}
if let Some(wrapping_element) = wrapping_element {
wrapping_element.append(std::slice::from_ref(&element))?;
element = wrapping_element.clone();
}
if into_container {
target.append(std::slice::from_ref(&element))?;
element.select_start()?;
} else {
target.replace(&element, false)?;
}
return Ok(());
}
}
let mut top_level_node: Option<NodeRef> = None;
let mut descendants: Vec<NodeRef> = Vec::new();
for node in nodes {
if is_block_container(&node) {
wrap_nodes_impl(selection, &descendants, &create_element, wrapping_element)?;
descendants = Vec::new();
top_level_node = Some(node);
} else if top_level_node
.as_ref()
.is_none_or(|top| has_ancestor(&node, top))
{
descendants.push(node);
} else {
wrap_nodes_impl(selection, &descendants, &create_element, wrapping_element)?;
descendants = vec![node];
}
}
wrap_nodes_impl(selection, &descendants, &create_element, wrapping_element)
}
#[derive(Clone)]
struct Unit {
block: NodeRef,
key: String,
run: Option<Vec<NodeRef>>,
}
enum Removal {
ParentEmptyElements(NodeRef),
Node(NodeRef),
}
fn wrap_nodes_impl(
selection: &SelectionRef,
nodes: &[NodeRef],
create_element: &dyn Fn() -> NodeRef,
wrapping_element: Option<&NodeRef>,
) -> Result<(), LexicalError> {
if nodes.is_empty() {
return Ok(());
}
let first_node = nodes
.iter()
.find(|node| (is_leaf_node(node) && node.get_parent().is_some()) || is_empty_block(node))
.unwrap_or(&nodes[0])
.clone();
let mut element_mapping: HashMap<String, NodeRef> = HashMap::new();
let mut elements: Vec<NodeRef> = Vec::new();
let mut block_of: HashMap<String, Option<NodeRef>> = HashMap::new();
let mut child_of: HashMap<String, NodeRef> = HashMap::new();
let mut block_leaf_parents: HashMap<String, bool> = HashMap::new();
let Some(first_node_block) = wrapped_block(&first_node, &mut block_of) else {
return Ok(());
};
let mut target = if is_block_container(&first_node_block) {
let child = child_in(&first_node_block, &first_node, &mut child_of);
if is_inline_content(&child) {
inline_run(&child).swap_remove(0)
} else {
child
}
} else if is_block_leaf_in_element(&first_node, &mut block_leaf_parents) {
first_node.clone()
} else {
first_node_block
};
let mut target_is_prev_sibling = false;
loop {
if let Some(prev_sibling) = target.get_previous_sibling() {
target = prev_sibling;
target_is_prev_sibling = true;
break;
}
target = target.get_parent_or_throw()?;
if is_block_container(&target) {
break;
}
}
let empty_elements: HashSet<String> = nodes
.iter()
.filter(|node| is_empty_block(node))
.map(|node| node.get_key().to_owned())
.collect();
let mut moved_nodes: HashSet<String> = HashSet::new();
let mut removals: Vec<Removal> = Vec::new();
let mut units: Vec<Option<Unit>> = Vec::new();
let mut run_of: HashMap<String, Unit> = HashMap::new();
for node in nodes {
let node_parent = node.get_parent();
if let Some(parent) = &node_parent
&& is_block_leaf_in_element(node, &mut block_leaf_parents)
{
units.push(Some(Unit {
block: parent.clone(),
key: node.get_key().to_owned(),
run: Some(vec![node.clone()]),
}));
continue;
}
let block = node_parent.and_then(|parent| wrapped_block(&parent, &mut block_of));
let Some(block) = block.clone().filter(is_block_container) else {
units.push(block.map(|block| Unit {
key: block.get_key().to_owned(),
block,
run: None,
}));
continue;
};
let child = child_in(&block, node, &mut child_of);
let inline = is_inline_content(&child);
if !inline && !is_leaf_node(&child) {
units.push(None);
continue;
}
let unit = match run_of.get(child.get_key()) {
Some(unit) => unit.clone(),
None => {
let run = if inline {
inline_run(&child)
} else {
vec![child.clone()]
};
let unit = Unit {
block,
key: run[0].get_key().to_owned(),
run: Some(run.clone()),
};
for node in &run {
run_of.insert(node.get_key().to_owned(), unit.clone());
}
unit
}
};
units.push(Some(unit));
}
for (node, unit) in nodes.iter().zip(&units) {
if let Some(unit) = unit
&& is_leaf_node(node)
&& !moved_nodes.contains(node.get_key())
{
let parent = &unit.block;
if !element_mapping.contains_key(&unit.key) {
let target_element = create_element();
if unit.run.is_none() {
target_element.set_element_format(parent.element_data().get_format_type());
target_element.set_indent(parent.get_indent()?)?;
}
elements.push(target_element.clone());
element_mapping.insert(unit.key.clone(), target_element.clone());
let children = match &unit.run {
Some(run) => run.clone(),
None => parent.get_children(),
};
target_element.splice(target_element.get_children_size(), 0, &children)?;
for child in &children {
moved_nodes.insert(child.get_key().to_owned());
if child.is_element() {
for grandchild in child.get_children() {
moved_nodes.insert(grandchild.get_key().to_owned());
}
}
}
removals.push(Removal::ParentEmptyElements(parent.clone()));
}
} else if empty_elements.contains(node.get_key()) {
invariant!(
node.is_element(),
"Expected node in emptyElements to be an ElementNode"
);
let target_element = create_element();
target_element.set_element_format(node.element_data().get_format_type());
target_element.set_indent(node.get_indent()?)?;
elements.push(target_element);
removals.push(Removal::Node(node.clone()));
}
}
if let Some(wrapping_element) = wrapping_element {
for element in &elements {
wrapping_element.append(std::slice::from_ref(element))?;
}
}
let mut last_element: Option<NodeRef> = None;
if is_block_container(&target) {
if target_is_prev_sibling {
if let Some(wrapping_element) = wrapping_element {
target.insert_after(wrapping_element, true)?;
} else {
for element in elements.iter().rev() {
target.insert_after(element, true)?;
}
}
} else {
let root_target = target.clone();
match root_target.get_first_child() {
None => {
if let Some(wrapping_element) = wrapping_element {
root_target.append(std::slice::from_ref(wrapping_element))?;
} else {
for element in &elements {
root_target.append(std::slice::from_ref(element))?;
last_element = Some(element.clone());
}
}
}
Some(first_child) => {
if let Some(wrapping_element) = wrapping_element {
first_child.insert_before(wrapping_element, true)?;
} else {
for element in &elements {
first_child.insert_before(element, true)?;
last_element = Some(element.clone());
}
}
}
}
}
} else if let Some(wrapping_element) = wrapping_element {
target.insert_after(wrapping_element, true)?;
} else {
for element in elements.iter().rev() {
target.insert_after(element, true)?;
last_element = Some(element.clone());
}
}
for removal in removals {
match removal {
Removal::ParentEmptyElements(parent) => remove_parent_empty_elements(&parent)?,
Removal::Node(node) => node.remove(true)?,
}
}
let prev_selection = get_previous_selection();
let prev_range = prev_selection.as_ref().and_then(SelectionRef::range);
if let (Some(prev_selection), Some(prev_range)) = (&prev_selection, &prev_range)
&& is_point_attached(&prev_range.anchor)?
&& is_point_attached(&prev_range.focus)?
{
set_selection(Some(prev_selection.clone_selection()));
} else if let Some(last_element) = last_element {
last_element.select_end()?;
} else {
selection.set_dirty(true);
}
Ok(())
}
fn is_editor_vertical_orientation(selection: &RangeSelection) -> bool {
get_computed_style(selection).is_some_and(|style| style.writing_mode == "vertical-rl")
}
fn get_computed_style(selection: &RangeSelection) -> Option<ComputedStyle> {
let anchor_node = selection.anchor.get_node().ok()?;
if anchor_node.is_element() {
return get_computed_style_for_element(&anchor_node);
}
get_computed_style_for_parent(&anchor_node)
}
pub fn should_override_default_character_selection(
selection: &RangeSelection,
is_backward: bool,
) -> Result<bool, LexicalError> {
let is_vertical = is_editor_vertical_orientation(selection);
let mut adjusted_is_backward = if is_vertical {
!is_backward
} else {
is_backward
};
if is_parent_element_rtl(selection) {
adjusted_is_backward = !adjusted_is_backward;
}
let focus_caret = caret_from_point(
&selection.focus,
if adjusted_is_backward {
CaretDirection::Previous
} else {
CaretDirection::Next
},
)?;
if is_extendable_text_point_caret(&focus_caret) {
return Ok(false);
}
let is_tab = |node: &NodeRef| node.get_latest().is::<TabNode>();
let origin = focus_caret.origin();
if focus_caret.is_text_point_caret() && !is_tab(origin) && origin.is_unmergeable() {
let sibling = focus_caret.get_node_at_caret();
if sibling.is_some_and(|s| s.is_text() && !is_tab(&s)) {
return Ok(true);
}
}
for next_caret in extend_caret_to_range(&focus_caret)?.iter() {
if next_caret.is_child_caret() {
return Ok(!next_caret.origin().is_inline());
} else if next_caret.origin().is_element() {
continue;
} else if next_caret.origin().is_decorator() {
return Ok(true);
}
break;
}
Ok(false)
}
pub fn move_caret_selection(
selection: &SelectionRef,
is_holding_shift: bool,
is_backward: bool,
granularity: SelectionGranularity,
) -> Result<(), LexicalError> {
selection.modify(
if is_holding_shift {
SelectionAlter::Extend
} else {
SelectionAlter::Move
},
is_backward,
granularity,
)
}
pub fn is_parent_element_rtl(selection: &RangeSelection) -> bool {
get_computed_style(selection).is_some_and(|style| style.direction == "rtl")
}
pub fn move_character(
selection: &SelectionRef,
is_holding_shift: bool,
is_backward: bool,
) -> Result<(), LexicalError> {
let (is_rtl, is_vertical) = match selection.range() {
Some(range) => (
is_parent_element_rtl(&range),
is_editor_vertical_orientation(&range),
),
None => (false, false),
};
let adjusted_is_backward = if is_vertical || is_rtl {
!is_backward
} else {
is_backward
};
move_caret_selection(
selection,
is_holding_shift,
adjusted_is_backward,
SelectionGranularity::Character,
)
}
fn get_node_style_value_for_property(
node: &NodeRef,
style_property: &str,
default_value: &str,
) -> String {
let css = node.text_data().style;
let style_object = get_style_object_from_css(&css);
style_object
.get(style_property)
.filter(|v| !v.is_empty())
.unwrap_or(default_value)
.to_owned()
}
pub fn get_selection_style_value_for_property(
selection: &SelectionRef,
style_property: &str,
default_value: &str,
) -> Result<String, LexicalError> {
let mut style_value: Option<String> = None;
let nodes = selection.get_nodes()?;
let mut start_node: Option<NodeRef> = None;
let mut end_node: Option<NodeRef> = None;
if let Some(range) = selection.range() {
if range.is_collapsed() && !range.style.is_empty() {
let style_object = get_style_object_from_css(&range.style);
if let Some(value) = style_object.get(style_property) {
return Ok(value.to_owned());
}
}
let is_backward = selection.is_backward()?;
let (first, last) = if is_backward {
(&range.focus, &range.anchor)
} else {
(&range.anchor, &range.focus)
};
let first_node = first.get_node()?;
let last_node = last.get_node()?;
if first_node.is_text() && first.offset == first_node.get_text_content_size() {
start_node = Some(first_node);
}
if last.offset == 0 {
end_node = Some(last_node);
}
}
for (i, node) in nodes.iter().enumerate() {
let excluded = if i == 0 { &start_node } else { &end_node };
if node.is_text() && excluded.as_ref() != Some(node) {
let node_style_value =
get_node_style_value_for_property(node, style_property, default_value);
match &style_value {
None => style_value = Some(node_style_value),
Some(value) if *value != node_style_value => {
style_value = Some(String::new());
break;
}
Some(_) => {}
}
}
}
Ok(style_value.unwrap_or_else(|| default_value.to_owned()))
}