use super::support::{build, discrete, item, list, text_item};
use crate::extension::LexicalEditorWithDispose;
use crate::list::{
ListType, RegisterListOptions, create_list_item_node, handle_indent, insert_list,
is_list_item_node, is_list_node, list_extension, register_list,
};
use crate::nodes::line_break::create_line_break_node;
use crate::upstream_tests::support::{create_test_decorator_node, initialize_unit_test, update};
use crate::{
CreateEditorArgs, Editor, INSERT_PARAGRAPH_COMMAND, LexicalError, NodeRef, PointType,
create_paragraph_node, create_text_node, get_node_by_key, get_root, get_selection,
nodes_of_type, select_all,
};
use std::cell::RefCell;
use std::rc::Rc;
fn editor() -> Editor {
initialize_unit_test(CreateEditorArgs::default())
}
fn create_nested_list_item(list_type: ListType, texts: &[&str]) -> NodeRef {
let items: Vec<NodeRef> = texts.iter().map(|t| text_item(t)).collect();
item(&[list(list_type, &items)])
}
fn get_nested_list(node: &NodeRef) -> NodeRef {
assert!(is_list_item_node(node));
let list = node.get_first_child().unwrap();
assert!(is_list_node(&list));
list
}
fn texts(list: &NodeRef) -> Vec<String> {
list.get_children()
.iter()
.map(NodeRef::get_text_content)
.collect()
}
fn read(editor: &Editor, f: impl FnOnce()) {
editor.read(f).unwrap();
}
#[test]
fn inserting_with_empty_root_selection() {
let editor = editor();
update(&editor, || get_root().select(None, None).map(|_| ()));
update(&editor, || insert_list(ListType::Number));
read(&editor, || {
let root = get_root();
assert_eq!(root.get_children_size(), 1);
assert!(is_list_node(&root.get_first_child_or_throw().unwrap()));
});
}
#[test]
fn inserting_in_root_selection_with_existing_child() {
let editor = editor();
update(&editor, || {
get_root().select(None, None)?;
let paragraph = create_paragraph_node();
paragraph.append(&[create_text_node("hello")])?;
get_root().append(&[paragraph])
});
update(&editor, || insert_list(ListType::Number));
read(&editor, || {
let root = get_root();
assert_eq!(root.get_children_size(), 1);
assert!(is_list_node(&root.get_first_child_or_throw().unwrap()));
});
}
#[cfg(feature = "table")]
#[test]
fn inserting_with_empty_shadow_root_selection() {
use crate::table::{
create_table_cell_node, create_table_node, create_table_row_node, is_table_cell_node,
is_table_node, is_table_row_node, table_nodes,
};
let editor = initialize_unit_test(CreateEditorArgs {
nodes: table_nodes(),
..CreateEditorArgs::default()
});
update(&editor, || {
let table = create_table_node();
let row = create_table_row_node(None);
let cell = create_table_cell_node(0, 1.0, None);
row.append(std::slice::from_ref(&cell))?;
table.append(&[row])?;
get_root().append(&[table])?;
cell.select(None, None)?;
Ok(())
});
update(&editor, || insert_list(ListType::Number));
read(&editor, || {
let table = get_root().get_first_child().filter(is_table_node).unwrap();
let row = table.get_first_child().filter(is_table_row_node).unwrap();
let cell = row.get_first_child().filter(is_table_cell_node).unwrap();
assert_eq!(cell.get_children_size(), 1);
let first_child = cell.get_first_child_or_throw().unwrap();
assert!(is_list_node(&first_child));
});
}
#[test]
fn formatting_empty_list_items() {
let editor = editor();
update(&editor, || {
get_root().append(&[list(
ListType::Bullet,
&[
text_item("Level 1"),
item(&[list(ListType::Bullet, &[create_list_item_node(None)])]),
],
)])
});
update(&editor, || {
select_all()?;
insert_list(ListType::Number)
});
read(&editor, || {
let lists: Vec<NodeRef> = nodes_of_type("list")
.into_iter()
.filter(|n| n.get_list_type() == Some(ListType::Number))
.collect();
assert_eq!(lists.len(), 2);
});
}
#[test]
fn preserves_element_anchored_selection_when_converting_paragraph_with_linebreak_to_list() {
let editor = editor();
update(&editor, || {
let paragraph = create_paragraph_node();
paragraph.append(&[create_text_node("Item 1"), create_line_break_node()])?;
get_root().append(std::slice::from_ref(¶graph))?;
paragraph.select(None, None)?;
Ok(())
});
update(&editor, || insert_list(ListType::Bullet));
read(&editor, || {
let selection = get_selection();
let list = get_root().get_first_child_or_throw().unwrap();
assert!(is_list_node(&list));
let list_item = list.get_first_child_or_throw().unwrap();
assert!(is_list_item_node(&list_item));
if let Some(selection) = selection.filter(crate::SelectionRef::is_range) {
for which in [crate::Which::Anchor, crate::Which::Focus] {
let point = selection.point(which).unwrap();
assert_eq!(point.key, list_item.get_key());
assert_eq!(point.offset, 2);
assert_eq!(point.point_type, PointType::Element);
}
}
});
}
fn list_editor(rich_text: bool) -> Editor {
let editor = editor();
if rich_text {
let _ = crate::rich_text::register_rich_text(&editor);
}
let _ = register_list(&editor, RegisterListOptions::default());
editor
}
fn dispatch_insert_paragraph() {
crate::get_editor()
.dispatch_command(&INSERT_PARAGRAPH_COMMAND, ())
.unwrap();
}
fn key_cell() -> Rc<RefCell<String>> {
Rc::new(RefCell::new(String::new()))
}
#[test]
fn exits_list_when_list_item_is_completely_empty() {
let editor = list_editor(false);
let key = key_cell();
let k = key.clone();
update(&editor, move || {
let empty = create_list_item_node(None);
*k.borrow_mut() = empty.get_key().to_string();
get_root().append(&[list(ListType::Bullet, &[text_item("item"), empty.clone()])])?;
empty.select(None, None)?;
dispatch_insert_paragraph();
Ok(())
});
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 2);
assert!(is_list_node(&children[0]));
assert_eq!(children[1].get_type(), "paragraph");
assert_eq!(children[0].get_children_size(), 1);
assert!(get_node_by_key(&key.borrow()).is_none());
});
}
#[test]
fn exits_list_when_list_item_contains_only_whitespace() {
let editor = list_editor(false);
let key = key_cell();
let k = key.clone();
update(&editor, move || {
let whitespace = create_text_node(" ");
let item = item(std::slice::from_ref(&whitespace));
*k.borrow_mut() = item.get_key().to_string();
get_root().append(&[list(ListType::Bullet, &[text_item("item"), item])])?;
whitespace.select(None, None)?;
dispatch_insert_paragraph();
Ok(())
});
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 2);
assert!(is_list_node(&children[0]));
assert_eq!(children[1].get_type(), "paragraph");
assert_eq!(children[0].get_children_size(), 1);
assert!(get_node_by_key(&key.borrow()).is_none());
});
}
#[test]
fn extends_list_when_list_item_contains_non_whitespace_content() {
let editor = list_editor(true);
update(&editor, || {
let text = create_text_node("item 2");
get_root().append(&[list(
ListType::Bullet,
&[text_item("item 1"), item(std::slice::from_ref(&text))],
)])?;
text.select_end()?;
dispatch_insert_paragraph();
Ok(())
});
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 1);
assert!(is_list_node(&children[0]));
assert_eq!(children[0].get_children_size(), 3);
});
}
#[test]
fn extends_list_when_list_item_contains_a_decorator_node() {
let editor = list_editor(true);
update(&editor, || {
let item2 = item(&[create_test_decorator_node()]);
get_root().append(&[list(
ListType::Bullet,
&[text_item("item 1"), item2.clone()],
)])?;
item2.select(None, None)?;
dispatch_insert_paragraph();
Ok(())
});
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 1);
assert!(is_list_node(&children[0]));
assert_eq!(children[0].get_children_size(), 3);
});
}
fn indent_middle(
root_type: ListType,
before: (ListType, &'static [&'static str]),
after: impl FnOnce() -> NodeRef + 'static,
) -> Editor {
let editor = editor();
let middle = key_cell();
let m = middle.clone();
update(&editor, move || {
let middle_item = text_item("middle");
*m.borrow_mut() = middle_item.get_key().to_string();
get_root().append(&[list(
root_type,
&[
create_nested_list_item(before.0, before.1),
middle_item,
after(),
],
)])
});
update(&editor, move || {
handle_indent(&get_node_by_key(&middle.borrow()).unwrap())
});
editor
}
fn root_list_children() -> Vec<NodeRef> {
let list = get_root().get_first_child().unwrap();
assert!(is_list_node(&list));
list.get_children()
}
#[test]
fn merges_the_surrounding_sublists_when_they_are_the_same_type() {
let editor = indent_middle(
ListType::Bullet,
(ListType::Bullet, &["first child"]),
|| create_nested_list_item(ListType::Bullet, &["second child"]),
);
read(&editor, || {
let children = root_list_children();
assert_eq!(children.len(), 1);
let sublist = get_nested_list(&children[0]);
assert_eq!(sublist.get_list_type(), Some(ListType::Bullet));
assert_eq!(texts(&sublist), ["first child", "middle", "second child"]);
});
}
#[test]
fn does_not_merge_the_surrounding_sublists_of_a_different_list_type() {
let editor = indent_middle(
ListType::Bullet,
(ListType::Bullet, &["bullet child"]),
|| create_nested_list_item(ListType::Number, &["number one", "number two"]),
);
read(&editor, || {
let children = root_list_children();
let number_sublist = get_nested_list(children.last().unwrap());
assert_eq!(number_sublist.get_list_type(), Some(ListType::Number));
assert_eq!(texts(&number_sublist), ["number one", "number two"]);
assert_eq!(children.len(), 2);
let bullet_sublist = get_nested_list(&children[0]);
assert_eq!(bullet_sublist.get_list_type(), Some(ListType::Bullet));
assert_eq!(texts(&bullet_sublist), ["bullet child", "middle"]);
});
}
#[test]
fn does_not_merge_the_surrounding_sublists_of_a_different_list_type_the_other_way_round() {
let editor = indent_middle(
ListType::Number,
(ListType::Number, &["number one"]),
|| create_nested_list_item(ListType::Bullet, &["bullet one", "bullet two"]),
);
read(&editor, || {
let children = root_list_children();
let bullet_sublist = get_nested_list(children.last().unwrap());
assert_eq!(bullet_sublist.get_list_type(), Some(ListType::Bullet));
assert_eq!(texts(&bullet_sublist), ["bullet one", "bullet two"]);
assert_eq!(children.len(), 2);
let number_sublist = get_nested_list(&children[0]);
assert_eq!(number_sublist.get_list_type(), Some(ListType::Number));
assert_eq!(texts(&number_sublist), ["number one", "middle"]);
});
}
#[test]
fn keeps_the_checked_state_of_a_following_check_sublist() {
let editor = indent_middle(
ListType::Bullet,
(ListType::Bullet, &["bullet child"]),
|| {
let check_item = create_list_item_node(None);
check_item.set_checked(Some(true));
check_item.append(&[create_text_node("done")]).unwrap();
item(&[list(ListType::Check, &[check_item])])
},
);
read(&editor, || {
let children = root_list_children();
let check_sublist = get_nested_list(children.last().unwrap());
assert_eq!(check_sublist.get_list_type(), Some(ListType::Check));
let check_item = check_sublist.get_first_child().unwrap();
assert!(is_list_item_node(&check_item));
assert_eq!(check_item.get_checked(), Some(true));
assert_eq!(children.len(), 2);
});
}
fn collapse_editor() -> LexicalEditorWithDispose {
build("[root]", vec![list_extension().into()])
}
fn collapse(editor: &Editor, make: impl FnOnce() -> Result<NodeRef, LexicalError> + 'static) {
editor
.update(
|| {
get_root().clear()?;
let item = make()?;
let selection = item.select(Some(0), Some(0))?;
assert!(selection.is_range(), "Expected RangeSelection");
item.collapse_at_start(&selection)?;
Ok(())
},
discrete(),
)
.unwrap();
}
#[test]
fn top_level_single_item_converts_to_paragraph() {
let editor = collapse_editor();
collapse(&editor, || {
let item = text_item("hello");
get_root().append(&[list(ListType::Bullet, std::slice::from_ref(&item))])?;
Ok(item)
});
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 1);
assert_eq!(
children[0].get_type(),
"paragraph",
"Expected ParagraphNode"
);
assert_eq!(children[0].get_text_content(), "hello");
});
editor.dispose();
}
#[test]
fn top_level_first_item_extracts_as_paragraph_keeps_remaining_list() {
let editor = collapse_editor();
collapse(&editor, || {
let first = text_item("first");
get_root().append(&[list(
ListType::Bullet,
&[first.clone(), text_item("second")],
)])?;
Ok(first)
});
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 2);
assert_eq!(
children[0].get_type(),
"paragraph",
"Expected ParagraphNode"
);
assert_eq!(children[0].get_text_content(), "first");
assert!(is_list_node(&children[1]), "Expected ListNode");
assert_eq!(children[1].get_children_size(), 1);
});
editor.dispose();
}
fn collapse_nested(editor: &Editor, nested: fn() -> Vec<NodeRef>) -> String {
let key = key_cell();
let k = key.clone();
collapse(editor, move || {
let nested = nested();
let first = nested[0].clone();
*k.borrow_mut() = first.get_key().to_string();
get_root().append(&[list(
ListType::Bullet,
&[
text_item("parent"),
item(&[list(ListType::Bullet, &nested)]),
],
)])?;
Ok(first)
});
key.take()
}
#[test]
fn indented_item_outdents_instead_of_converting_to_paragraph() {
let editor = collapse_editor();
let key = collapse_nested(&editor, || vec![text_item("child")]);
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 1);
assert!(is_list_node(&children[0]), "Expected ListNode");
assert_eq!(children[0].get_children_size(), 2);
let outdented = get_node_by_key(&key).unwrap();
assert!(is_list_item_node(&outdented), "Expected ListItemNode");
assert_eq!(outdented.get_text_content(), "child");
});
editor.dispose();
}
#[test]
fn indented_item_with_siblings_outdents_without_breaking_list() {
let editor = collapse_editor();
let key = collapse_nested(&editor, || vec![text_item("child1"), text_item("child2")]);
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 1);
assert!(is_list_node(&children[0]), "Expected ListNode");
let outdented = get_node_by_key(&key).unwrap();
assert!(is_list_item_node(&outdented), "Expected ListItemNode");
assert_eq!(outdented.get_text_content(), "child1");
assert!(
children[0]
.get_children()
.iter()
.any(|item| is_list_item_node(item) && item.get_text_content().contains("child2"))
);
});
editor.dispose();
}
fn collapse_middle(editor: &Editor, list_type: ListType, middle: fn() -> NodeRef) {
collapse(editor, move || {
let item2 = middle();
get_root().append(&[list(
list_type,
&[text_item("first"), item2.clone(), text_item("third")],
)])?;
Ok(item2)
});
}
#[test]
fn middle_item_converts_to_paragraph_and_splits_list() {
let editor = collapse_editor();
collapse_middle(&editor, ListType::Bullet, || text_item("second"));
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 3);
assert!(is_list_node(&children[0]), "Expected first ListNode");
assert_eq!(children[0].get_children_size(), 1);
assert_eq!(children[0].get_text_content(), "first");
assert_eq!(
children[1].get_type(),
"paragraph",
"Expected ParagraphNode"
);
assert_eq!(children[1].get_text_content(), "second");
assert!(is_list_node(&children[2]), "Expected second ListNode");
assert_eq!(children[2].get_children_size(), 1);
assert_eq!(children[2].get_text_content(), "third");
});
editor.dispose();
}
#[test]
fn split_preserves_list_type() {
let editor = collapse_editor();
collapse_middle(&editor, ListType::Number, || text_item("second"));
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 3);
assert_eq!(children[0].get_list_type(), Some(ListType::Number));
assert_eq!(children[2].get_list_type(), Some(ListType::Number));
});
editor.dispose();
}
#[test]
fn last_item_converts_to_paragraph_without_splitting() {
let editor = collapse_editor();
collapse(&editor, || {
let item2 = text_item("second");
get_root().append(&[list(ListType::Bullet, &[text_item("first"), item2.clone()])])?;
Ok(item2)
});
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 2);
assert!(is_list_node(&children[0]), "Expected ListNode");
assert_eq!(children[0].get_children_size(), 1);
assert_eq!(children[0].get_text_content(), "first");
assert_eq!(
children[1].get_type(),
"paragraph",
"Expected ParagraphNode"
);
assert_eq!(children[1].get_text_content(), "second");
});
editor.dispose();
}
#[test]
fn empty_middle_item_converts_to_empty_paragraph_and_splits_list() {
let editor = collapse_editor();
collapse_middle(&editor, ListType::Bullet, || create_list_item_node(None));
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 3);
assert!(is_list_node(&children[0]), "Expected ListNode");
assert_eq!(children[0].get_children_size(), 1);
assert_eq!(
children[0]
.get_first_child_or_throw()
.unwrap()
.get_text_content(),
"first"
);
assert_eq!(
children[1].get_type(),
"paragraph",
"Expected ParagraphNode"
);
assert_eq!(children[1].get_text_content(), "");
assert!(is_list_node(&children[2]), "Expected ListNode");
assert_eq!(children[2].get_children_size(), 1);
assert_eq!(
children[2]
.get_first_child_or_throw()
.unwrap()
.get_text_content(),
"third"
);
let selection = get_selection().filter(crate::SelectionRef::is_range);
assert!(
selection
.expect("Expected RangeSelection")
.range()
.unwrap()
.is_collapsed()
);
});
editor.dispose();
}
#[test]
fn empty_indented_item_outdents() {
let editor = collapse_editor();
let key = collapse_nested(&editor, || vec![create_list_item_node(None)]);
read(&editor, || {
let children = get_root().get_children();
assert_eq!(children.len(), 1);
assert!(is_list_node(&children[0]), "Expected ListNode");
let outdented = get_node_by_key(&key).unwrap();
assert!(is_list_item_node(&outdented), "Expected ListItemNode");
assert_eq!(outdented.get_indent().unwrap(), 0.0);
});
editor.dispose();
}
#[test]
fn does_not_merge_nested_sublists_of_a_different_list_type() {
let editor = editor();
editor
.update(
|| {
let list1 = list(
ListType::Bullet,
&[
text_item("a"),
create_nested_list_item(ListType::Number, &["one"]),
],
);
let list2 = list(
ListType::Bullet,
&[
create_nested_list_item(ListType::Bullet, &["two"]),
text_item("b"),
],
);
get_root().clear()?;
get_root().append(&[list1, list2])
},
discrete(),
)
.unwrap();
read(&editor, || {
let list = get_root().get_children()[0].clone();
assert!(is_list_node(&list), "Expected ListNode");
let sublist_types: Vec<Option<ListType>> = list
.get_children()
.iter()
.filter(|c| is_list_item_node(c))
.filter_map(NodeRef::get_first_child)
.filter(is_list_node)
.map(|s| s.get_list_type())
.collect();
assert_eq!(
sublist_types,
[Some(ListType::Number), Some(ListType::Bullet)]
);
});
}