#![cfg(all(
feature = "extension",
feature = "link",
feature = "list",
feature = "rich-text"
))]
use crate::extension::{LexicalEditorWithDispose, build_editor_from_extensions};
use crate::link::{LinkAttributes, create_link_node};
use crate::list::{ListType, create_list_item_node, create_list_node, is_list_node};
use crate::upstream_tests::support::{
TestBlockableDecoratorNode, TestInlineElementNode, TestShadowRootNode,
create_test_blockable_decorator_node, create_test_shadow_root_node, mount_in_jsdom,
set_is_inline, shape, update,
};
use crate::{
LexicalError, LexicalExtension, NodeClass, NodeRef, PointType, SelectionRef, Which,
create_paragraph_node, create_range_selection, create_text_node, define_extension, get_root,
get_selection, set_composition_key, set_selection,
};
use std::rc::Rc;
fn selection_test_extension(name: &str, extra: Vec<NodeClass>) -> LexicalEditorWithDispose {
let mut nodes = vec![
NodeClass::of::<TestBlockableDecoratorNode>(),
NodeClass::of::<TestInlineElementNode>(),
NodeClass::of::<TestShadowRootNode>(),
];
nodes.extend(extra);
build_editor_from_extensions([define_extension(LexicalExtension {
dependencies: vec![
crate::link::link_extension().into(),
crate::list::list_extension().into(),
],
nodes,
..LexicalExtension::<(), (), ()>::new(name, ())
})
.into()])
.unwrap()
}
fn build() -> LexicalEditorWithDispose {
selection_test_extension("@test/selection", Vec::new())
}
fn mounted() -> LexicalEditorWithDispose {
let editor = build();
mount_in_jsdom(&editor);
editor
}
fn range(selection: &SelectionRef) -> crate::RangeSelection {
selection.range().expect("a RangeSelection")
}
fn current() -> SelectionRef {
get_selection()
.filter(SelectionRef::is_range)
.expect("Expected RangeSelection")
}
fn paragraph_of(children: &[NodeRef]) -> NodeRef {
let paragraph = create_paragraph_node();
paragraph.append(children).unwrap();
paragraph
}
fn link_of(text: &str) -> NodeRef {
let link = create_link_node("https://", &LinkAttributes::default());
link.append(&[create_text_node(text)]).unwrap();
link
}
fn texts_of(nodes: &[NodeRef]) -> Vec<String> {
nodes.iter().map(NodeRef::get_text_content).collect()
}
fn block_decorator() -> NodeRef {
set_is_inline(&create_test_blockable_decorator_node(), false)
}
#[derive(Clone, Copy)]
enum Mode {
Start,
Mid,
End,
}
#[derive(Clone, Copy)]
enum Method {
InsertText,
InsertNodes,
}
fn setup_inline(editor: &crate::Editor, mode: Mode) {
update(editor, move || {
let root = get_root();
root.clear()?;
let children = match mode {
Mode::Start => vec![link_of("a"), create_text_node("b")],
Mode::Mid => vec![create_text_node("a"), link_of("b"), create_text_node("c")],
Mode::End => vec![create_text_node("a"), link_of("b")],
};
root.append(&[paragraph_of(&children)])
});
assert_eq!(
shape(editor),
match mode {
Mode::End => "<paragraph>[a]<link>[b]</link></paragraph>",
Mode::Mid => "<paragraph>[a]<link>[b]</link>[c]</paragraph>",
Mode::Start => "<paragraph><link>[a]</link>[b]</paragraph>",
}
);
}
fn insert_text_or_nodes(selection: &SelectionRef, method: Method) -> Result<(), LexicalError> {
match method {
Method::InsertText => selection.insert_text("x"),
Method::InsertNodes => selection.insert_nodes(vec![paragraph_of(&[create_text_node("x")])]),
}
}
fn insert_beside_inline(mode: Mode, first: bool, offset: usize, method: Method, expected: &str) {
let editor = mounted();
setup_inline(&editor, mode);
update(&editor, move || {
let paragraph = get_root().get_first_child_or_throw()?;
let node = if first {
paragraph.get_first_child_or_throw()?
} else {
paragraph.get_last_child_or_throw()?
};
let selection = node.select(Some(offset), Some(offset))?;
insert_text_or_nodes(&selection, method)
});
assert_eq!(shape(&editor), expected);
editor.dispose();
}
const BEFORE_START: &str = "<paragraph>[x]<link>[a]</link>[b]</paragraph>";
const BEFORE_MID: &str = "<paragraph>[ax]<link>[b]</link>[c]</paragraph>";
const BEFORE_END: &str = "<paragraph>[ax]<link>[b]</link></paragraph>";
const AFTER_START: &str = "<paragraph><link>[a]</link>[xb]</paragraph>";
const AFTER_MID: &str = "<paragraph>[a]<link>[b]</link>[xc]</paragraph>";
const AFTER_END: &str = "<paragraph>[a]<link>[b]</link>[x]</paragraph>";
#[test]
fn insert_text_before_a_start_of_paragraph_inline_element_using_insert_text() {
insert_beside_inline(Mode::Start, true, 0, Method::InsertText, BEFORE_START);
}
#[test]
fn insert_text_before_a_start_of_paragraph_inline_element_using_insert_nodes() {
insert_beside_inline(Mode::Start, true, 0, Method::InsertNodes, BEFORE_START);
}
#[test]
fn insert_text_before_a_mid_paragraph_inline_element_using_insert_text() {
insert_beside_inline(Mode::Mid, true, 1, Method::InsertText, BEFORE_MID);
}
#[test]
fn insert_text_before_a_mid_paragraph_inline_element_using_insert_nodes() {
insert_beside_inline(Mode::Mid, true, 1, Method::InsertNodes, BEFORE_MID);
}
#[test]
fn insert_text_before_an_end_of_paragraph_inline_element_using_insert_text() {
insert_beside_inline(Mode::End, true, 1, Method::InsertText, BEFORE_END);
}
#[test]
fn insert_text_before_an_end_of_paragraph_inline_element_using_insert_nodes() {
insert_beside_inline(Mode::End, true, 1, Method::InsertNodes, BEFORE_END);
}
#[test]
fn insert_text_after_a_start_of_paragraph_inline_element_using_insert_text() {
insert_beside_inline(Mode::Start, false, 0, Method::InsertText, AFTER_START);
}
#[test]
fn insert_text_after_a_start_of_paragraph_inline_element_using_insert_nodes() {
insert_beside_inline(Mode::Start, false, 0, Method::InsertNodes, AFTER_START);
}
#[test]
fn insert_text_after_a_mid_paragraph_inline_element_using_insert_text() {
insert_beside_inline(Mode::Mid, false, 0, Method::InsertText, AFTER_MID);
}
#[test]
fn insert_text_after_a_mid_paragraph_inline_element_using_insert_nodes() {
insert_beside_inline(Mode::Mid, false, 0, Method::InsertNodes, AFTER_MID);
}
#[test]
fn insert_text_after_an_end_of_paragraph_inline_element_using_insert_text() {
insert_beside_inline(Mode::End, false, 1, Method::InsertText, AFTER_END);
}
#[test]
fn insert_text_after_an_end_of_paragraph_inline_element_using_insert_nodes() {
insert_beside_inline(Mode::End, false, 1, Method::InsertNodes, AFTER_END);
}
#[test]
fn inserts_into_existing_paragraph_node_when_selection_is_on_parent_of_paragraph() {
let editor = mounted();
update(&editor, || {
let root = get_root();
root.clear()?;
root.append(&[create_paragraph_node()])?;
let selection = create_range_selection();
selection.point_set(Which::Anchor, "root", 0, PointType::Element)?;
selection.point_set(Which::Focus, "root", 0, PointType::Element)?;
set_selection(Some(selection.clone()));
selection.insert_text("text")?;
assert_eq!(root.get_children_size(), 1);
assert_eq!(root.get_text_content(), "text");
Ok(())
});
editor.dispose();
}
#[derive(Clone, Copy)]
enum Fixture {
TrailingToken,
LeadingToken,
TrailingSegmented,
}
#[derive(Clone, Copy)]
enum Sel {
First,
Second,
Range(usize, Option<usize>),
}
#[derive(Clone, Copy)]
enum Caret {
Paragraph,
First(Option<usize>),
Second,
Remaining,
}
struct RemoveTextCase {
fixture: Fixture,
select: Sel,
first_attached: bool,
second_attached: bool,
texts: &'static [&'static str],
caret: Caret,
}
fn remove_text(case: RemoveTextCase) {
let editor = mounted();
let (first, second, paragraph) = crate::upstream_tests::support::update_with(&editor, {
let fixture = case.fixture;
move || {
let (first, second) = match fixture {
Fixture::TrailingToken => {
let t = create_text_node("token text");
t.set_mode("token")?;
(create_text_node("leading text"), t)
}
Fixture::LeadingToken => {
let t = create_text_node("token text");
t.set_mode("token")?;
(t, create_text_node("trailing text"))
}
Fixture::TrailingSegmented => {
let t = create_text_node("segmented text");
t.set_mode("segmented")?;
(create_text_node("leading text"), t)
}
};
let paragraph = paragraph_of(&[first.clone(), second.clone()]);
get_root().clear()?;
get_root().append(std::slice::from_ref(¶graph))?;
Ok((first, second, paragraph))
}
});
let (f, s, p) = (first.clone(), second.clone(), paragraph.clone());
update(&editor, move || {
let sel = match case.select {
Sel::First => f.select(Some(0), Some(f.get_text_content_size()))?,
Sel::Second => s.select(Some(0), Some(s.get_text_content_size()))?,
Sel::Range(start, end) => {
let sel = f.select(Some(0), Some(0))?;
sel.set_text_node_range(
&f,
start,
&s,
end.unwrap_or_else(|| s.get_text_content_size()),
)?;
assert!(get_selection().unwrap().ptr_eq(&sel));
sel
}
};
sel.remove_text()?;
assert!(get_selection().unwrap().ptr_eq(&sel));
assert_eq!(f.is_attached(), case.first_attached);
assert_eq!(s.is_attached(), case.second_attached);
let all = get_root().get_all_text_nodes();
assert_eq!(texts_of(&all), case.texts);
let selection = range(¤t());
assert!(selection.is_collapsed());
let (key, offset) = match case.caret {
Caret::Paragraph => (p.get_key().to_owned(), 0),
Caret::First(offset) => (
f.get_key().to_owned(),
offset.unwrap_or_else(|| f.get_text_content_size()),
),
Caret::Second => (s.get_key().to_owned(), 0),
Caret::Remaining => (all[0].get_key().to_owned(), 0),
};
assert_eq!(selection.anchor.key, key);
assert_eq!(selection.anchor.offset, offset);
Ok(())
});
if let Fixture::TrailingSegmented = case.fixture
&& let Sel::Range(4, Some(10)) = case.select
{
editor
.read_with_mode(crate::EditorReadMode::Latest, || {
assert_eq!(texts_of(&get_root().get_all_text_nodes()), ["leadtext"]);
assert!(first.is_attached());
})
.unwrap();
}
editor.dispose();
}
#[test]
fn remove_text_trailing_token_remove_all_text() {
remove_text(RemoveTextCase {
fixture: Fixture::TrailingToken,
select: Sel::Range(0, None),
first_attached: false,
second_attached: false,
texts: &[],
caret: Caret::Paragraph,
});
}
#[test]
fn remove_text_trailing_token_remove_initial_text_node() {
remove_text(RemoveTextCase {
fixture: Fixture::TrailingToken,
select: Sel::First,
first_attached: false,
second_attached: true,
texts: &["token text"],
caret: Caret::Second,
});
}
#[test]
fn remove_text_trailing_token_remove_trailing_token_text_node() {
remove_text(RemoveTextCase {
fixture: Fixture::TrailingToken,
select: Sel::Second,
first_attached: true,
second_attached: false,
texts: &["leading text"],
caret: Caret::First(None),
});
}
#[test]
fn remove_text_trailing_token_remove_initial_and_partial_token() {
remove_text(RemoveTextCase {
fixture: Fixture::TrailingToken,
select: Sel::Range(0, Some("token ".len())),
first_attached: false,
second_attached: false,
texts: &[],
caret: Caret::Paragraph,
});
}
#[test]
fn remove_text_trailing_token_remove_partial_initial_and_partial_token() {
remove_text(RemoveTextCase {
fixture: Fixture::TrailingToken,
select: Sel::Range("lead".len(), Some("token ".len())),
first_attached: true,
second_attached: false,
texts: &["lead"],
caret: Caret::First(Some("lead".len())),
});
}
#[test]
fn remove_text_leading_token_remove_all_text() {
remove_text(RemoveTextCase {
fixture: Fixture::LeadingToken,
select: Sel::Range(0, None),
first_attached: false,
second_attached: false,
texts: &[],
caret: Caret::Paragraph,
});
}
#[test]
fn remove_text_leading_token_remove_trailing_text_node() {
remove_text(RemoveTextCase {
fixture: Fixture::LeadingToken,
select: Sel::Second,
first_attached: true,
second_attached: false,
texts: &["token text"],
caret: Caret::First(None),
});
}
#[test]
fn remove_text_leading_token_remove_leading_token_text_node() {
remove_text(RemoveTextCase {
fixture: Fixture::LeadingToken,
select: Sel::First,
first_attached: false,
second_attached: true,
texts: &["trailing text"],
caret: Caret::Second,
});
}
#[test]
fn remove_text_leading_token_remove_partial_token_and_trailing() {
remove_text(RemoveTextCase {
fixture: Fixture::LeadingToken,
select: Sel::Range("token ".len(), None),
first_attached: false,
second_attached: false,
texts: &[],
caret: Caret::Paragraph,
});
}
#[test]
fn remove_text_leading_token_remove_partial_token_and_partial_trailing() {
remove_text(RemoveTextCase {
fixture: Fixture::LeadingToken,
select: Sel::Range("token ".len(), Some("trail".len())),
first_attached: false,
second_attached: true,
texts: &["ing text"],
caret: Caret::Second,
});
}
#[test]
fn remove_text_trailing_segmented_remove_all_text() {
remove_text(RemoveTextCase {
fixture: Fixture::TrailingSegmented,
select: Sel::Range(0, None),
first_attached: false,
second_attached: false,
texts: &[],
caret: Caret::Paragraph,
});
}
#[test]
fn remove_text_trailing_segmented_remove_initial_text_node() {
remove_text(RemoveTextCase {
fixture: Fixture::TrailingSegmented,
select: Sel::First,
first_attached: false,
second_attached: true,
texts: &["segmented text"],
caret: Caret::Second,
});
}
#[test]
fn remove_text_trailing_segmented_remove_trailing_segmented_text_node() {
remove_text(RemoveTextCase {
fixture: Fixture::TrailingSegmented,
select: Sel::Second,
first_attached: true,
second_attached: false,
texts: &["leading text"],
caret: Caret::First(None),
});
}
#[test]
fn remove_text_trailing_segmented_remove_initial_and_partial_segmented() {
remove_text(RemoveTextCase {
fixture: Fixture::TrailingSegmented,
select: Sel::Range(0, Some("segmented ".len())),
first_attached: false,
second_attached: false,
texts: &["text"],
caret: Caret::Remaining,
});
}
#[test]
fn remove_text_trailing_segmented_remove_partial_initial_and_partial_segmented() {
remove_text(RemoveTextCase {
fixture: Fixture::TrailingSegmented,
select: Sel::Range("lead".len(), Some("segmented ".len())),
first_attached: true,
second_attached: false,
texts: &["lead", "text"],
caret: Caret::First(Some("lead".len())),
});
}
fn segmented(text: &str) -> NodeRef {
let node = create_text_node(text);
node.set_mode("segmented").unwrap();
node
}
fn note_state() -> crate::StateConfig<String> {
crate::create_state("note", |v| v.as_str().unwrap_or_default().to_owned())
}
#[test]
fn insert_text_during_composition_preserves_node_key() {
let editor = build();
update(&editor, || {
let segmented = segmented("JohnSmith");
get_root().clear()?;
get_root().append(&[paragraph_of(std::slice::from_ref(&segmented))])?;
let key = segmented.get_key().to_owned();
set_composition_key(Some(&key));
segmented.select(Some(4), Some(4))?.insert_text("")?;
assert_eq!(segmented.get_key(), key);
assert!(!segmented.is_segmented());
assert_eq!(segmented.get_text_content(), "JohnSmith");
Ok(())
});
editor.dispose();
}
#[test]
fn insert_text_without_composition_replaces_segmented_node() {
let editor = build();
update(&editor, || {
let segmented = segmented("JohnSmith");
get_root().clear()?;
get_root().append(&[paragraph_of(std::slice::from_ref(&segmented))])?;
segmented.select(Some(4), Some(4))?.insert_text("")?;
assert!(!segmented.is_attached());
let all = get_root().get_all_text_nodes();
assert_eq!(all.len(), 1);
assert_ne!(all[0].get_key(), segmented.get_key());
assert_eq!(all[0].get_text_content(), "JohnSmith");
Ok(())
});
editor.dispose();
}
#[test]
fn insert_text_without_composition_types_into_a_segmented_node() {
let editor = build();
update(&editor, || {
let segmented = segmented("JohnSmith");
get_root().clear()?;
get_root().append(&[paragraph_of(std::slice::from_ref(&segmented))])?;
segmented.select(Some(4), Some(4))?.insert_text("X")?;
assert!(!segmented.is_attached());
let all = get_root().get_all_text_nodes();
assert_eq!(all.len(), 1);
assert!(!all[0].is_segmented());
assert_eq!(all[0].get_text_content(), "JohnXSmith");
let selection = range(¤t());
assert!(selection.is_collapsed());
assert_eq!(selection.anchor.key, all[0].get_key());
assert_eq!(selection.anchor.offset, 5);
Ok(())
});
editor.dispose();
}
#[test]
fn insert_text_without_composition_keeps_the_node_state_and_detail_of_the_segmented_node() {
let note = note_state();
let editor = build();
update(&editor, move || {
let segmented = segmented("JohnSmith");
segmented.toggle_unmergeable();
crate::set_state(&segmented, ¬e, "c1".to_owned())?;
get_root().clear()?;
get_root().append(&[paragraph_of(std::slice::from_ref(&segmented))])?;
segmented.select(Some(4), Some(4))?.insert_text("X")?;
let all = get_root().get_all_text_nodes();
assert_eq!(all.len(), 1);
assert!(!all[0].is_segmented());
assert_eq!(all[0].get_text_content(), "JohnXSmith");
assert_eq!(crate::get_state(&all[0], ¬e)?, "c1");
assert!(all[0].is_unmergeable());
Ok(())
});
editor.dispose();
}
#[derive(Clone, Debug, Default)]
struct ReplacementTextNode {
base: crate::NodeBase,
text: crate::TextData,
}
impl crate::LexicalNode for ReplacementTextNode {
fn get_type(&self) -> &'static str {
"test-replacement-text"
}
fn base(&self) -> &crate::NodeBase {
&self.base
}
fn base_mut(&mut self) -> &mut crate::NodeBase {
&mut self.base
}
fn text(&self) -> Option<&crate::TextData> {
Some(&self.text)
}
fn text_mut(&mut self) -> Option<&mut crate::TextData> {
Some(&mut self.text)
}
}
#[test]
fn a_text_node_replacement_keeps_the_node_state_it_sets_and_takes_the_rest() {
let note = note_state();
let other = crate::create_state("other", |v| v.as_str().unwrap_or_default().to_owned());
let n = note.clone();
let editor = crate::upstream_tests::support::create_test_editor(crate::CreateEditorArgs {
nodes: vec![
NodeClass::of::<ReplacementTextNode>(),
crate::LexicalNodeReplacement {
replace: NodeClass::of::<crate::nodes::text::TextNode>(),
with: Rc::new(move |node| {
let replacement = crate::create::<ReplacementTextNode>();
replacement.set_text_content(&node.get_text_content());
crate::set_state(&replacement, &n, "replacement".to_owned())
}),
with_klass: Some(NodeClass::of::<ReplacementTextNode>()),
}
.into(),
],
..crate::CreateEditorArgs::default()
});
update(&editor, move || {
let segmented = crate::create::<ReplacementTextNode>();
segmented.set_text_content("JohnSmith");
segmented.set_mode("segmented")?;
crate::set_state(&segmented, ¬e, "c1".to_owned())?;
crate::set_state(&segmented, &other, "o1".to_owned())?;
get_root().clear()?;
get_root().append(&[paragraph_of(std::slice::from_ref(&segmented))])?;
segmented.select(Some(4), Some(4))?.insert_text("X")?;
let text = get_root().get_all_text_nodes()[0].clone();
assert_eq!(text.get_text_content(), "JohnXSmith");
assert_eq!(crate::get_state(&text, ¬e)?, "replacement");
assert_eq!(crate::get_state(&text, &other)?, "o1");
Ok(())
});
}
#[test]
fn removing_text_from_inside_a_segmented_node_to_the_next_block_keeps_its_node_state_and_detail() {
let note = note_state();
let editor = build();
update(&editor, move || {
let segmented = segmented("$AB");
segmented.toggle_unmergeable();
crate::set_state(&segmented, ¬e, "c1".to_owned())?;
let next = create_text_node("z");
get_root().clear()?;
get_root().append(&[
paragraph_of(std::slice::from_ref(&segmented)),
paragraph_of(std::slice::from_ref(&next)),
])?;
let selection = create_range_selection();
selection.point_set(Which::Anchor, segmented.get_key(), 2, PointType::Text)?;
selection.point_set(Which::Focus, next.get_key(), 0, PointType::Text)?;
set_selection(Some(selection.clone()));
selection.remove_text()?;
let nodes = get_root().get_all_text_nodes();
assert_eq!(get_root().get_text_content(), "$Az");
let kept = nodes
.iter()
.find(|n| n.get_text_content().starts_with("$A"))
.expect("the kept node");
assert_eq!(crate::get_state(kept, ¬e)?, "c1");
assert!(kept.is_unmergeable());
Ok(())
});
editor.dispose();
}
#[test]
fn insert_text_during_composition_preserves_format_and_style() {
let editor = build();
update(&editor, || {
let segmented = segmented("JohnSmith");
segmented.set_format_type("bold");
get_root().clear()?;
get_root().append(&[paragraph_of(std::slice::from_ref(&segmented))])?;
let key = segmented.get_key().to_owned();
set_composition_key(Some(&key));
let sel = segmented.select(Some(4), Some(4))?;
sel.set_format(1.0); sel.insert_text("")?;
assert!(segmented.is_attached());
assert_eq!(segmented.get_key(), key);
assert_eq!(segmented.text_data().get_format(), 1.0);
Ok(())
});
editor.dispose();
}
#[test]
fn splice_text_into_existing_node_instead_of_creating_new_one() {
let editor = build();
update(&editor, || {
let text_node = create_text_node("Hello World");
get_root().clear()?;
get_root().append(&[paragraph_of(std::slice::from_ref(&text_node))])?;
let key = text_node.get_key().to_owned();
set_composition_key(Some(&key));
text_node.select(Some(5), Some(11))?.insert_text("!")?;
assert_eq!(text_node.get_key(), key);
assert_eq!(text_node.get_text_content(), "Hello!");
Ok(())
});
editor.dispose();
}
#[test]
fn without_composition_creates_a_new_node() {
let editor = build();
update(&editor, || {
let text_node = create_text_node("Hello World");
get_root().clear()?;
get_root().append(&[paragraph_of(std::slice::from_ref(&text_node))])?;
let key = text_node.get_key().to_owned();
text_node.select(Some(5), Some(11))?.insert_text("!")?;
let all = get_root().get_all_text_nodes();
assert_eq!(texts_of(&all), ["Hello", "!"]);
assert_ne!(all[1].get_key(), key);
Ok(())
});
editor.dispose();
}
#[derive(Clone, Debug, Default)]
struct InlineElementNode {
base: crate::NodeBase,
element: crate::ElementData,
}
impl crate::LexicalNode for InlineElementNode {
fn get_type(&self) -> &'static str {
"inline-element-node"
}
fn base(&self) -> &crate::NodeBase {
&self.base
}
fn base_mut(&mut self) -> &mut crate::NodeBase {
&mut self.base
}
fn element(&self) -> Option<&crate::ElementData> {
Some(&self.element)
}
fn element_mut(&mut self) -> Option<&mut crate::ElementData> {
Some(&mut self.element)
}
fn is_inline(&self) -> bool {
true
}
}
#[test]
fn insert_nodes_fails_an_invariant_when_there_is_no_block_ancestor() {
let editor = build_editor_from_extensions([define_extension(LexicalExtension {
nodes: vec![NodeClass::of::<InlineElementNode>()],
..LexicalExtension::<(), (), ()>::new("@test/6701", ())
})
.into()])
.unwrap();
let result = editor.update(
|| {
let text_node = create_text_node("test");
let inline = crate::create::<InlineElementNode>();
inline.append(std::slice::from_ref(&text_node))?;
get_root().clear()?;
get_root().append(&[inline])?;
text_node
.select(None, None)?
.insert_nodes(vec![create_text_node("more text")])
},
crate::UpdateOptions {
discrete: true,
..crate::UpdateOptions::default()
},
);
let message = result.expect_err("an invariant").message().to_owned();
assert!(
message
.contains("Expected node TextNode of type text to have a block ElementNode ancestor"),
"{message}"
);
editor.dispose();
}
fn in_shadow_root(
editor: &crate::Editor,
children: fn() -> Vec<NodeRef>,
offset: usize,
insert: fn(&SelectionRef) -> Result<(), LexicalError>,
) {
update(editor, move || {
let shadow = create_test_shadow_root_node();
shadow.append(&children())?;
get_root().clear()?;
get_root().append(std::slice::from_ref(&shadow))?;
shadow.select(Some(offset), Some(offset))?;
Ok(())
});
update(editor, move || insert(¤t()));
}
fn insert_block_decorator(selection: &SelectionRef) -> Result<(), LexicalError> {
selection.insert_nodes(vec![block_decorator()])
}
fn shadow_children() -> Vec<NodeRef> {
let shadow = get_root().get_first_child_or_throw().unwrap();
assert_eq!(
shadow.get_type(),
"test_shadow_root",
"Expected shadow root"
);
shadow.get_children()
}
#[test]
fn inserts_a_block_decorator_after_the_block_cursor_at_the_end_of_a_shadow_root() {
let editor = build();
in_shadow_root(
&editor,
|| vec![block_decorator()],
1,
insert_block_decorator,
);
editor
.read(|| {
assert_eq!(get_root().get_children_size(), 1);
let children = shadow_children();
assert_eq!(children.len(), 2);
assert!(children.iter().all(NodeRef::is_decorator));
})
.unwrap();
editor.dispose();
}
#[test]
fn inserts_a_block_decorator_before_the_block_cursor_at_the_start_of_a_shadow_root() {
let editor = build();
let existing_key = crate::upstream_tests::support::update_with(&editor, || {
let shadow = create_test_shadow_root_node();
let existing = block_decorator();
shadow.append(std::slice::from_ref(&existing))?;
get_root().clear()?;
get_root().append(std::slice::from_ref(&shadow))?;
shadow.select(Some(0), Some(0))?;
Ok(existing.get_key().to_owned())
});
update(&editor, || insert_block_decorator(¤t()));
editor
.read(|| {
let children = shadow_children();
assert_eq!(children.len(), 2);
assert!(children.iter().all(NodeRef::is_decorator));
assert_eq!(children[1].get_key(), existing_key);
})
.unwrap();
editor.dispose();
}
#[test]
fn inserts_a_block_decorator_into_an_empty_shadow_root() {
let editor = build();
in_shadow_root(&editor, Vec::new, 0, insert_block_decorator);
editor
.read(|| {
let children = shadow_children();
assert_eq!(children.len(), 1);
assert!(children[0].is_decorator());
})
.unwrap();
editor.dispose();
}
#[test]
fn inserts_a_block_element_at_the_block_cursor_inside_a_shadow_root() {
let editor = build();
in_shadow_root(
&editor,
|| vec![block_decorator()],
1,
|selection| selection.insert_nodes(vec![paragraph_of(&[create_text_node("inserted")])]),
);
editor
.read(|| {
let children = shadow_children();
assert_eq!(children.len(), 2);
assert!(children[0].is_decorator());
assert_eq!(children[1].get_type(), "paragraph");
assert_eq!(children[1].get_text_content(), "inserted");
})
.unwrap();
editor.dispose();
}
#[test]
fn insert_paragraph_at_an_element_point_on_a_shadow_root_seeds_into_that_shadow_root() {
let editor = build();
in_shadow_root(
&editor,
|| vec![block_decorator()],
1,
|selection| {
let paragraph = selection
.insert_paragraph()?
.expect("Expected a paragraph to be inserted");
assert_eq!(
paragraph.get_parent().map(|p| p.get_key().to_owned()),
get_root().get_first_child().map(|p| p.get_key().to_owned())
);
Ok(())
},
);
editor
.read(|| {
assert_eq!(get_root().get_children_size(), 1);
let children = shadow_children();
assert_eq!(children.len(), 2);
assert_eq!(children[1].get_type(), "paragraph");
})
.unwrap();
editor.dispose();
}
#[test]
fn inserts_a_block_decorator_at_a_root_element_point_without_wrapping_it_in_a_paragraph() {
let editor = build();
update(&editor, || {
get_root().clear()?;
get_root().append(&[paragraph_of(&[create_text_node("existing")])])?;
get_root().select(Some(1), Some(1))?;
Ok(())
});
update(&editor, || insert_block_decorator(¤t()));
editor
.read(|| {
let children = get_root().get_children();
assert_eq!(children.len(), 2);
assert_eq!(children[0].get_type(), "paragraph");
assert!(children[1].is_decorator());
})
.unwrap();
editor.dispose();
}
fn forward_delete(editor: &crate::Editor) {
update(editor, || current().delete_character(false));
}
#[test]
fn forward_delete_removes_an_empty_block_before_a_shadow_root() {
let editor = build();
update(&editor, || {
let paragraph = create_paragraph_node();
let shadow = create_test_shadow_root_node();
shadow.append(&[paragraph_of(&[create_text_node("inside")])])?;
get_root().clear()?;
get_root().append(&[paragraph.clone(), shadow])?;
paragraph.select_start()?;
Ok(())
});
forward_delete(&editor);
editor
.read(|| {
let children = get_root().get_children();
assert_eq!(children.len(), 1);
assert_eq!(children[0].get_type(), "test_shadow_root");
assert_eq!(children[0].get_text_content(), "inside");
})
.unwrap();
editor.dispose();
}
#[test]
fn forward_delete_keeps_a_non_empty_block_before_a_shadow_root() {
let editor = build();
update(&editor, || {
let paragraph = paragraph_of(&[create_text_node("before")]);
let shadow = create_test_shadow_root_node();
shadow.append(&[paragraph_of(&[create_text_node("inside")])])?;
get_root().clear()?;
get_root().append(&[paragraph.clone(), shadow])?;
paragraph.select_end()?;
Ok(())
});
forward_delete(&editor);
editor
.read(|| {
let children = get_root().get_children();
assert_eq!(children.len(), 2);
assert_eq!(children[0].get_text_content(), "before");
assert_eq!(children[1].get_type(), "test_shadow_root");
assert_eq!(children[1].get_text_content(), "inside");
})
.unwrap();
editor.dispose();
}
#[test]
fn forward_delete_from_an_empty_block_at_the_end_of_a_shadow_root_does_nothing() {
let editor = build();
update(&editor, || {
let inner = create_paragraph_node();
let first = create_test_shadow_root_node();
first.append(std::slice::from_ref(&inner))?;
let second = create_test_shadow_root_node();
second.append(&[paragraph_of(&[create_text_node("next")])])?;
get_root().clear()?;
get_root().append(&[first, second])?;
inner.select_start()?;
Ok(())
});
forward_delete(&editor);
editor
.read(|| {
let children = get_root().get_children();
assert_eq!(children.len(), 2);
assert_eq!(children[0].get_type(), "test_shadow_root");
assert_eq!(children[0].get_children_size(), 1);
assert_eq!(children[0].get_text_content(), "");
assert_eq!(children[1].get_text_content(), "next");
})
.unwrap();
editor.dispose();
}
fn build_insert_block() -> LexicalEditorWithDispose {
selection_test_extension(
"@test/selection-insert-block",
vec![NodeClass::of::<crate::rich_text::QuoteNode>()],
)
}
fn setup_paragraph(editor: &crate::Editor, text: &'static str, caret_offset: usize) {
update(editor, move || {
get_root().clear()?;
get_root().append(&[paragraph_of(&[create_text_node(text)])])?;
let paragraph = get_root().get_first_child_or_throw()?;
assert_eq!(paragraph.get_type(), "paragraph", "Expected a paragraph");
let text = paragraph.get_first_child_or_throw()?;
assert!(text.is_text(), "Expected a text node");
text.select(Some(caret_offset), Some(caret_offset))?;
Ok(())
});
}
fn insert_blocks(editor: &crate::Editor, make_nodes: fn() -> Vec<NodeRef>) {
update(editor, move || current().insert_nodes(make_nodes()));
}
fn make_list() -> Vec<NodeRef> {
let item = create_list_item_node(None);
item.append(&[create_text_node("item")]).unwrap();
let list = create_list_node(ListType::Bullet, 1.0);
list.append(&[item]).unwrap();
vec![list]
}
fn blocks(editor: &crate::Editor) -> Vec<String> {
editor
.read(|| {
get_root()
.get_children()
.iter()
.map(|c| {
if c.is_decorator() {
"decorator".to_owned()
} else if is_list_node(c) {
format!("list:{}", c.get_text_content())
} else {
format!("{}:{}", c.get_type(), c.get_text_content())
}
})
.collect()
})
.unwrap()
}
#[test]
fn pasting_a_block_decorator_at_the_end_of_a_paragraph_leaves_no_empty_paragraph() {
let editor = build_insert_block();
setup_paragraph(&editor, "hello", 5);
insert_blocks(&editor, || vec![block_decorator()]);
assert_eq!(blocks(&editor), ["paragraph:hello", "decorator"]);
editor.dispose();
}
#[test]
fn pasting_a_block_decorator_in_the_middle_of_a_paragraph_keeps_the_trailing_text() {
let editor = build_insert_block();
setup_paragraph(&editor, "helloworld", 5);
insert_blocks(&editor, || vec![block_decorator()]);
assert_eq!(
blocks(&editor),
["paragraph:hello", "decorator", "paragraph:world"]
);
editor.dispose();
}
#[test]
fn pasting_a_block_decorator_at_the_start_of_a_paragraph_keeps_the_paragraph_after_it() {
let editor = build_insert_block();
setup_paragraph(&editor, "hello", 0);
insert_blocks(&editor, || vec![block_decorator()]);
assert_eq!(blocks(&editor), ["decorator", "paragraph:hello"]);
editor.dispose();
}
#[test]
fn pasting_a_list_at_the_end_of_a_paragraph_leaves_no_empty_paragraph() {
let editor = build_insert_block();
setup_paragraph(&editor, "hello", 5);
insert_blocks(&editor, make_list);
assert_eq!(blocks(&editor), ["paragraph:hello", "list:item"]);
editor.dispose();
}
#[test]
fn pasting_a_list_in_the_middle_of_a_paragraph_keeps_the_trailing_text() {
let editor = build_insert_block();
setup_paragraph(&editor, "helloworld", 5);
insert_blocks(&editor, make_list);
assert_eq!(
blocks(&editor),
["paragraph:hello", "list:item", "paragraph:world"]
);
editor.dispose();
}
#[test]
fn pasting_a_list_at_the_start_of_a_paragraph_keeps_the_paragraph_after_it() {
let editor = build_insert_block();
setup_paragraph(&editor, "hello", 0);
insert_blocks(&editor, make_list);
assert_eq!(blocks(&editor), ["list:item", "paragraph:hello"]);
editor.dispose();
}
#[test]
fn pasting_a_quote_at_the_end_of_a_paragraph_merges_into_it() {
let editor = build_insert_block();
setup_paragraph(&editor, "hello", 5);
insert_blocks(&editor, || {
let quote = crate::rich_text::create_quote_node(false);
quote.append(&[create_text_node("quoted")]).unwrap();
vec![quote]
});
assert_eq!(blocks(&editor), ["paragraph:helloquoted"]);
editor.dispose();
}
#[test]
fn pasting_a_paragraph_at_the_end_of_a_paragraph_merges_into_it() {
let editor = build_insert_block();
setup_paragraph(&editor, "hello", 5);
insert_blocks(&editor, || vec![paragraph_of(&[create_text_node("world")])]);
assert_eq!(blocks(&editor), ["paragraph:helloworld"]);
editor.dispose();
}
#[test]
fn typing_after_pasting_a_block_decorator_at_the_end_creates_a_paragraph_on_demand() {
let editor = build_insert_block();
setup_paragraph(&editor, "hello", 5);
insert_blocks(&editor, || vec![block_decorator()]);
update(&editor, || current().insert_text("x"));
assert_eq!(
blocks(&editor),
["paragraph:hello", "decorator", "paragraph:x"]
);
editor.dispose();
}
#[derive(Clone)]
struct Doc {
paragraph_node: NodeRef,
paragraph_text: NodeRef,
link_node: NodeRef,
link_text: NodeRef,
list_node: NodeRef,
list_item_text1: NodeRef,
list_item_text2: NodeRef,
list_item1: NodeRef,
list_item2: NodeRef,
empty_paragraph: NodeRef,
}
impl Doc {
fn up_to_list(&self) -> Vec<NodeRef> {
vec![
self.paragraph_text.clone(),
self.link_node.clone(),
self.link_text.clone(),
self.paragraph_node.clone(),
self.list_node.clone(),
self.list_item1.clone(),
self.list_item_text1.clone(),
self.list_item2.clone(),
self.list_item_text2.clone(),
]
}
fn all(&self) -> Vec<NodeRef> {
let mut nodes = self.up_to_list();
nodes.push(self.empty_paragraph.clone());
nodes
}
}
fn get_nodes_setup() -> (LexicalEditorWithDispose, Doc) {
let editor = build();
let doc = crate::upstream_tests::support::update_with(&editor, || {
let doc = Doc {
paragraph_text: create_text_node("paragraph text"),
link_text: create_text_node("link text"),
link_node: create_link_node("", &LinkAttributes::default()),
paragraph_node: create_paragraph_node(),
list_item_text1: create_text_node("item 1"),
list_item_text2: create_text_node("item 2"),
list_item1: create_list_item_node(None),
list_item2: create_list_item_node(None),
list_node: create_list_node(ListType::Bullet, 1.0),
empty_paragraph: create_paragraph_node(),
};
doc.link_node.append(std::slice::from_ref(&doc.link_text))?;
doc.paragraph_node
.append(&[doc.paragraph_text.clone(), doc.link_node.clone()])?;
doc.list_item1
.append(std::slice::from_ref(&doc.list_item_text1))?;
doc.list_item2
.append(std::slice::from_ref(&doc.list_item_text2))?;
doc.list_node
.append(&[doc.list_item1.clone(), doc.list_item2.clone()])?;
get_root().clear()?;
get_root().append(&[
doc.paragraph_node.clone(),
doc.list_node.clone(),
doc.empty_paragraph.clone(),
])?;
Ok(doc)
});
(editor, doc)
}
fn keys(nodes: &[NodeRef]) -> Vec<String> {
nodes.iter().map(|n| n.get_key().to_owned()).collect()
}
fn expect_points(
selection: &SelectionRef,
anchor: (&NodeRef, usize, PointType),
focus: (&NodeRef, usize, PointType),
) {
let r = range(selection);
for (point, (node, offset, point_type)) in [(&r.anchor, anchor), (&r.focus, focus)] {
assert_eq!(point.key, node.get_key());
assert_eq!(point.offset, offset);
assert_eq!(point.point_type, point_type);
}
}
fn with_doc(f: impl FnOnce(&Doc) -> Result<(), LexicalError> + 'static) {
let (editor, doc) = get_nodes_setup();
update(&editor, move || f(&doc));
editor.dispose();
}
fn root_node() -> NodeRef {
get_root()
}
#[test]
fn get_nodes_select_all_with_test_document() {
with_doc(|d| {
let selection = crate::select_all()?;
expect_points(
&selection,
(&d.paragraph_text, 0, PointType::Text),
(&d.empty_paragraph, 0, PointType::Element),
);
assert_eq!(keys(&selection.get_nodes()?), keys(&d.all()));
Ok(())
});
}
#[test]
fn get_nodes_select_all_with_leading_inline_decorator() {
with_doc(|d| {
let leading = create_test_blockable_decorator_node();
d.paragraph_node
.splice(0, 0, std::slice::from_ref(&leading))?;
let selection = crate::select_all()?;
expect_points(
&selection,
(&d.paragraph_node, 0, PointType::Element),
(&d.empty_paragraph, 0, PointType::Element),
);
let mut want = vec![leading];
want.extend(d.all());
assert_eq!(keys(&selection.get_nodes()?), keys(&want));
Ok(())
});
}
#[test]
fn get_nodes_select_all_with_trailing_inline_decorator() {
with_doc(|d| {
let trailing = create_test_blockable_decorator_node();
d.empty_paragraph
.splice(0, 0, std::slice::from_ref(&trailing))?;
let selection = crate::select_all()?;
expect_points(
&selection,
(&d.paragraph_text, 0, PointType::Text),
(&d.empty_paragraph, 1, PointType::Element),
);
let mut want = d.all();
want.push(trailing);
assert_eq!(keys(&selection.get_nodes()?), keys(&want));
Ok(())
});
}
#[test]
fn get_nodes_select_all_with_leading_empty_inline_element() {
with_doc(|d| {
let leading = crate::upstream_tests::support::create_test_inline_element_node();
d.paragraph_node
.splice(0, 0, std::slice::from_ref(&leading))?;
let selection = crate::select_all()?;
expect_points(
&selection,
(&leading, 0, PointType::Element),
(&d.empty_paragraph, 0, PointType::Element),
);
let mut want = vec![leading];
want.extend(d.all());
assert_eq!(keys(&selection.get_nodes()?), keys(&want));
Ok(())
});
}
#[test]
fn get_nodes_select_all_with_trailing_empty_inline_element() {
with_doc(|d| {
let trailing = crate::upstream_tests::support::create_test_inline_element_node();
d.empty_paragraph
.splice(0, 0, std::slice::from_ref(&trailing))?;
let selection = crate::select_all()?;
expect_points(
&selection,
(&d.paragraph_text, 0, PointType::Text),
(&trailing, 0, PointType::Element),
);
let mut want = d.all();
want.push(trailing);
assert_eq!(keys(&selection.get_nodes()?), keys(&want));
Ok(())
});
}
#[test]
fn get_nodes_select_all_after_removing_empty_paragraph() {
with_doc(|d| {
d.empty_paragraph.remove(false)?;
let selection = crate::select_all()?;
expect_points(
&selection,
(&d.paragraph_text, 0, PointType::Text),
(
&d.list_item_text2,
d.list_item_text2.get_text_content_size(),
PointType::Text,
),
);
assert_eq!(keys(&selection.get_nodes()?), keys(&d.up_to_list()));
Ok(())
});
}
fn range_between(
anchor: (&str, usize, PointType),
focus: (&str, usize, PointType),
) -> Result<SelectionRef, LexicalError> {
let selection = create_range_selection();
selection.point_set(Which::Anchor, anchor.0, anchor.1, anchor.2)?;
selection.point_set(Which::Focus, focus.0, focus.1, focus.2)?;
Ok(selection)
}
fn select_all_manually() -> Result<SelectionRef, LexicalError> {
range_between(
("root", 0, PointType::Element),
("root", root_node().get_children_size(), PointType::Element),
)
}
fn first_text_to_empty_paragraph(d: &Doc) -> Result<SelectionRef, LexicalError> {
range_between(
(d.paragraph_text.get_key(), 0, PointType::Text),
(d.empty_paragraph.get_key(), 0, PointType::Element),
)
}
#[test]
fn get_nodes_manual_select_all_without_normalization() {
with_doc(|d| {
let selection = select_all_manually()?;
assert_eq!(keys(&selection.get_nodes()?), keys(&d.all()));
Ok(())
});
}
#[test]
fn get_nodes_manual_select_all_from_first_text_to_last_empty_paragraph() {
with_doc(|d| {
let selection = first_text_to_empty_paragraph(d)?;
assert_eq!(keys(&selection.get_nodes()?), keys(&d.all()));
Ok(())
});
}
fn two_decorators(d: &Doc) -> Result<(NodeRef, NodeRef), LexicalError> {
let leading = create_test_blockable_decorator_node();
let trailing = create_test_blockable_decorator_node();
d.empty_paragraph
.splice(0, 0, &[leading.clone(), trailing.clone()])?;
Ok((leading, trailing))
}
fn collapsed_in_empty_paragraph(d: &Doc, offset: usize) -> Result<(), LexicalError> {
let (_, trailing) = two_decorators(d)?;
let p = d.empty_paragraph.get_key();
let selection = range_between(
(p, offset, PointType::Element),
(p, offset, PointType::Element),
)?;
assert!(range(&selection).is_collapsed());
expect_points(
&selection,
(&d.empty_paragraph, offset, PointType::Element),
(&d.empty_paragraph, offset, PointType::Element),
);
assert_eq!(keys(&selection.get_nodes()?), keys(&[trailing]));
Ok(())
}
#[test]
fn get_nodes_manual_select_with_focus_collapsed_between_inline_decorators() {
with_doc(|d| collapsed_in_empty_paragraph(d, 1));
}
#[test]
fn get_nodes_manual_select_with_focus_collapsed_after_inline_decorator() {
with_doc(|d| collapsed_in_empty_paragraph(d, 2));
}
#[test]
fn get_nodes_manual_select_with_focus_between_inline_decorators() {
with_doc(|d| {
let (leading, _) = two_decorators(d)?;
let selection = range_between(
(d.paragraph_text.get_key(), 0, PointType::Text),
(d.empty_paragraph.get_key(), 1, PointType::Element),
)?;
expect_points(
&selection,
(&d.paragraph_text, 0, PointType::Text),
(&d.empty_paragraph, 1, PointType::Element),
);
let mut want = d.all();
want.push(leading);
assert_eq!(keys(&selection.get_nodes()?), keys(&want));
Ok(())
});
}
#[test]
fn get_nodes_select_only_the_paragraph() {
with_doc(|d| {
let size = d.paragraph_node.get_children_size();
let selection = d.paragraph_node.select(Some(0), Some(size))?;
expect_points(
&selection,
(&d.paragraph_node, 0, PointType::Element),
(&d.paragraph_node, size, PointType::Element),
);
assert_eq!(
keys(&selection.get_nodes()?),
keys(&[
d.paragraph_text.clone(),
d.link_node.clone(),
d.link_text.clone()
])
);
Ok(())
});
}
#[test]
fn get_nodes_select_around_the_paragraph() {
with_doc(|d| {
let index = d.paragraph_node.get_index_within_parent().unwrap();
let selection = range_between(
("root", index, PointType::Element),
("root", index + 1, PointType::Element),
)?;
let root = root_node();
expect_points(
&selection,
(&root, 0, PointType::Element),
(&root, 1, PointType::Element),
);
assert_eq!(
keys(&selection.get_nodes()?),
keys(&[
d.paragraph_text.clone(),
d.link_node.clone(),
d.link_text.clone(),
d.paragraph_node.clone(),
])
);
Ok(())
});
}
#[test]
fn get_nodes_selection_collapsed_inside_an_empty_element() {
with_doc(|d| {
let p = d.empty_paragraph.get_key();
let selection = range_between((p, 0, PointType::Element), (p, 0, PointType::Element))?;
assert_eq!(
keys(&selection.get_nodes()?),
keys(std::slice::from_ref(&d.empty_paragraph))
);
Ok(())
});
}
#[test]
fn get_nodes_select_an_empty_list_item_node() {
with_doc(|d| {
let empty_list_item = create_list_item_node(None);
d.list_item2.insert_before(&empty_list_item, true)?;
let k = empty_list_item.get_key();
let selection = range_between((k, 0, PointType::Element), (k, 0, PointType::Element))?;
expect_points(
&selection,
(&empty_list_item, 0, PointType::Element),
(&empty_list_item, 0, PointType::Element),
);
assert_eq!(keys(&selection.get_nodes()?), keys(&[empty_list_item]));
Ok(())
});
}
#[test]
fn extract_manual_select_all_without_normalization() {
with_doc(|d| {
let selection = select_all_manually()?;
let extracted = selection.extract()?;
assert_eq!(keys(&extracted), keys(&d.all()));
assert_eq!(keys(&selection.get_nodes()?), keys(&extracted));
Ok(())
});
}
#[test]
fn extract_manual_select_all_from_first_text_to_last_empty_paragraph() {
with_doc(|d| {
let selection = first_text_to_empty_paragraph(d)?;
let extracted = selection.extract()?;
assert_eq!(keys(&extracted), keys(&d.all()));
assert_eq!(keys(&selection.get_nodes()?), keys(&extracted));
Ok(())
});
}
fn extract_partial(text: fn(&Doc) -> NodeRef, start: usize, end: usize, want: &'static str) {
with_doc(move |d| {
let selection = text(d).select(Some(start), Some(end))?;
let extracted = selection.extract()?;
assert_eq!(extracted.len(), 1);
assert!(extracted[0].is_text());
assert_eq!(extracted[0].get_text_content(), want);
assert_eq!(keys(&selection.get_nodes()?), keys(&extracted));
Ok(())
});
}
#[test]
fn extract_select_partial_text_node_extracts_paragraph_text() {
extract_partial(|d| d.paragraph_text.clone(), 2, 8, "ragrap");
}
#[test]
fn extract_select_partial_text_node_extracts_link_text() {
extract_partial(|d| d.link_text.clone(), 1, 4, "ink");
}
fn described(nodes: &[NodeRef]) -> Vec<String> {
nodes
.iter()
.map(|n| {
if n.is_text() {
format!("text:{}", n.get_text_content())
} else {
format!("key:{}", n.get_key())
}
})
.collect()
}
#[test]
fn extract_select_multiple_partial_text_node_extracts_text() {
with_doc(|d| {
let selection = create_range_selection();
selection.set_text_node_range(&d.paragraph_text, 10, &d.link_text, 4)?;
let extracted = selection.extract()?;
assert_eq!(
described(&extracted),
[
"text:text".to_owned(),
format!("key:{}", d.link_node.get_key()),
"text:link".to_owned()
]
);
assert_eq!(keys(&selection.get_nodes()?), keys(&extracted));
Ok(())
});
}
#[test]
fn extract_select_last_offset_text_node_as_first_node_removes_node() {
with_doc(|d| {
let selection = create_range_selection();
selection.set_text_node_range(
&d.paragraph_text,
d.paragraph_text.get_text_content_size(),
&d.link_text,
4,
)?;
let before_nodes = selection.get_nodes()?;
let extracted = selection.extract()?;
assert_eq!(
described(&extracted),
[
format!("key:{}", d.link_node.get_key()),
"text:link".to_owned()
]
);
assert_eq!(keys(&selection.get_nodes()?), keys(&before_nodes));
Ok(())
});
}
#[test]
fn extract_select_0_offset_text_node_as_last_node_removes_node() {
with_doc(|d| {
let selection = create_range_selection();
selection.set_text_node_range(&d.paragraph_text, 4, &d.link_text, 0)?;
let before_nodes = selection.get_nodes()?;
assert_eq!(
described(&selection.extract()?),
[
"text:graph text".to_owned(),
format!("key:{}", d.link_node.get_key())
]
);
let mut want = vec![d.paragraph_text.get_next_sibling().unwrap()];
want.extend(before_nodes[1..].iter().cloned());
assert_eq!(keys(&selection.get_nodes()?), keys(&want));
Ok(())
});
}
fn in_fresh_editor(f: impl FnOnce() -> Result<(), LexicalError> + 'static) {
let editor = build();
update(&editor, f);
editor.dispose();
}
fn is_bold(node: &NodeRef) -> bool {
assert!(node.is_text());
crate::nodes::text::to_int32(node.text_data().get_format()) & crate::constants::IS_BOLD != 0
}
fn bold_text(text: &str) -> NodeRef {
let node = create_text_node(text);
node.toggle_format("bold");
node
}
#[test]
fn firefox_selection_and_paste_before_linebreak() {
in_fresh_editor(|| {
let text_node = create_text_node("XXXX");
text_node.set_style("color: --color-test");
let paragraph_node = paragraph_of(&[
create_text_node("ID: "),
text_node.clone(),
crate::nodes::line_break::create_line_break_node(),
create_text_node("aa"),
]);
get_root().clear()?;
get_root().append(std::slice::from_ref(¶graph_node))?;
let selection = text_node.select(Some(0), None)?;
selection.point_set(
Which::Focus,
paragraph_node.get_key(),
1 + text_node.get_index_within_parent().unwrap(),
PointType::Element,
)?;
selection.insert_text("123")?;
let styled_child = paragraph_node
.get_children()
.into_iter()
.find(|c| c.is_text() && c.text_data().get_style() == "color: --color-test")
.expect("a styled child");
assert_eq!(styled_child.get_text_content(), "123");
Ok(())
});
}
#[test]
fn insert_nodes_of_multiple_blocks_over_an_initial_empty_block_and_the_next_block() {
in_fresh_editor(|| {
let empty_paragraph = create_paragraph_node();
let replaced_paragraph = paragraph_of(&[create_text_node("replaced!")]);
get_root().clear()?;
get_root().append(&[empty_paragraph, replaced_paragraph])?;
let selection = crate::select_all()?;
let inserted_nodes = vec![
paragraph_of(&[create_text_node("p1")]),
paragraph_of(&[create_text_node("p2")]),
];
selection.insert_nodes(inserted_nodes.clone())?;
assert_eq!(keys(&get_root().get_children()), keys(&inserted_nodes));
Ok(())
});
}
#[test]
fn point_is_before_edge_case_with_mixed_text_and_element_points() {
in_fresh_editor(|| {
let token = |text: &str| {
let node = create_text_node(text);
node.set_mode("token").unwrap();
node
};
let target_text = token("target");
let paragraph = paragraph_of(&[token("a"), token("b"), target_text.clone()]);
get_root().clear()?;
get_root().append(std::slice::from_ref(¶graph))?;
let selection = paragraph.select(Some(2), Some(2))?;
selection.point_set(Which::Focus, target_text.get_key(), 1, PointType::Text)?;
expect_points(
&selection,
(¶graph, 2, PointType::Element),
(&target_text, 1, PointType::Text),
);
let r = range(&selection);
let caret_range = crate::caret_range_from_selection(&r)?;
assert_eq!(
crate::compare_point_caret_next(
&crate::get_caret_in_direction(&caret_range.anchor, crate::CaretDirection::Next)?,
&crate::get_caret_in_direction(&caret_range.focus, crate::CaretDirection::Next)?,
)?,
std::cmp::Ordering::Less
);
assert!(r.anchor.is_before(&r.focus)?);
assert!(!r.focus.is_before(&r.anchor)?);
Ok(())
});
}
#[test]
fn formatting_issue_when_replacing_text_with_format() {
in_fresh_editor(|| {
let paragraph = paragraph_of(&[bold_text("hello"), create_text_node(" world!")]);
get_root().clear()?;
get_root().append(std::slice::from_ref(¶graph))?;
crate::select_all()?.insert_text("hello")?;
let child = paragraph.get_children()[0].clone();
assert_eq!(child.get_text_content(), "hello");
assert!(is_bold(&child));
Ok(())
});
}
#[test]
fn backward_selection_across_bold_and_plain_inherits_bold() {
in_fresh_editor(|| {
let bold_node = bold_text("hello");
let plain_node = create_text_node(" world");
let paragraph = paragraph_of(&[bold_node.clone(), plain_node.clone()]);
get_root().clear()?;
get_root().append(std::slice::from_ref(¶graph))?;
let selection = plain_node.select(Some(6), Some(6))?;
selection.set_text_node_range(&plain_node, 6, &bold_node, 0)?;
selection.insert_text("X")?;
let child = paragraph.get_children()[0].clone();
assert_eq!(child.get_text_content(), "X");
assert!(is_bold(&child));
Ok(())
});
}
fn token_text(text: &str) -> NodeRef {
let node = create_text_node(text);
node.set_mode("token").unwrap();
node
}
#[test]
fn token_node_at_middle_offset_replaces_entire_node() {
in_fresh_editor(|| {
let token = token_text("abcdef");
let paragraph = paragraph_of(std::slice::from_ref(&token));
get_root().clear()?;
get_root().append(std::slice::from_ref(¶graph))?;
token.select(Some(3), Some(3))?.insert_text("X")?;
let children = paragraph.get_children();
assert_eq!(children.len(), 1);
assert!(children[0].is_text());
assert_eq!(children[0].get_text_content(), "X");
assert!(!token.is_attached());
Ok(())
});
}
#[test]
fn offset_0_on_token_reuses_insertable_previous_sibling() {
in_fresh_editor(|| {
let prev = create_text_node("before");
let token = token_text("locked");
get_root().clear()?;
get_root().append(&[paragraph_of(&[prev.clone(), token.clone()])])?;
token.select(Some(0), Some(0))?;
current().insert_text("X")?;
assert_eq!(prev.get_text_content(), "beforeX");
assert!(token.is_attached());
Ok(())
});
}
#[test]
fn offset_at_end_of_token_reuses_insertable_next_sibling() {
in_fresh_editor(|| {
let token = token_text("locked");
let next = create_text_node("after");
get_root().clear()?;
get_root().append(&[paragraph_of(&[token.clone(), next.clone()])])?;
token.select(Some(6), Some(6))?;
current().insert_text("X")?;
assert_eq!(next.get_text_content(), "Xafter");
assert!(token.is_attached());
Ok(())
});
}
#[test]
fn applies_format_in_place_on_empty_anchor_then_splices_text() {
in_fresh_editor(|| {
let empty = create_text_node("");
let paragraph = paragraph_of(std::slice::from_ref(&empty));
get_root().clear()?;
get_root().append(std::slice::from_ref(¶graph))?;
let sel = empty.select(Some(0), Some(0))?;
sel.set_format(f64::from(crate::constants::IS_BOLD));
sel.insert_text("typed")?;
assert!(empty.is_attached());
assert_eq!(empty.get_text_content(), "typed");
assert!(is_bold(&empty));
assert_eq!(paragraph.get_children_size(), 1);
Ok(())
});
}
#[test]
fn is_backward_caches_the_result_and_invalidates_on_point_mutations() {
in_fresh_editor(|| {
let root = get_root();
root.clear()?;
let text = create_text_node("hello");
root.append(&[paragraph_of(std::slice::from_ref(&text))])?;
let selection = text.select(Some(0), Some(5))?;
let cached = || range(&selection).cached_is_backward;
assert_eq!(cached(), None);
assert!(!selection.is_backward()?);
assert_eq!(cached(), Some(false));
assert!(!selection.is_backward()?);
selection.set_text_node_range(&text, 5, &text, 0)?;
assert_eq!(cached(), None);
assert!(selection.is_backward()?);
assert_eq!(cached(), Some(true));
Ok(())
});
}
fn child_types(node: &NodeRef) -> Vec<&'static str> {
node.get_children().iter().map(NodeRef::get_type).collect()
}
#[test]
fn wraps_all_inline_nodes_preserving_first_linebreak_if_contain_a_block_element() {
in_fresh_editor(|| {
get_root().clear()?;
let selection = crate::select_all()?;
let bold = create_text_node("p1");
bold.set_format_type("bold");
let inline_nodes = vec![
crate::nodes::line_break::create_line_break_node(),
create_text_node("p1"),
bold,
];
let mut nodes = inline_nodes.clone();
nodes.push(create_paragraph_node());
selection.insert_nodes(nodes)?;
let children = get_root().get_children();
assert_eq!(children.len(), 2);
assert_eq!(children[0].get_type(), "paragraph");
assert_eq!(keys(&children[0].get_children()), keys(&inline_nodes));
Ok(())
});
}
#[test]
fn collapses_a_lone_linebreak_run_into_an_empty_paragraph_at_the_end_of_a_non_empty_paragraph() {
in_fresh_editor(|| {
let root = get_root();
root.clear()?;
let paragraph = paragraph_of(&[create_text_node("abc")]);
root.append(std::slice::from_ref(¶graph))?;
paragraph.select_end()?.insert_nodes(vec![
crate::nodes::line_break::create_line_break_node(),
paragraph_of(&[create_text_node("x")]),
])?;
let children = root.get_children();
assert_eq!(children.len(), 3);
assert!(children.iter().all(|c| c.get_type() == "paragraph"));
assert_eq!(children[0].get_text_content(), "abc");
assert_eq!(children[1].get_children_size(), 0);
assert_eq!(children[2].get_text_content(), "x");
Ok(())
});
}
#[test]
fn preserves_a_linebreak_followed_by_inline_content_when_merging_into_a_non_empty_paragraph() {
in_fresh_editor(|| {
let root = get_root();
root.clear()?;
let paragraph = paragraph_of(&[create_text_node("abc")]);
root.append(std::slice::from_ref(¶graph))?;
paragraph.select_end()?.insert_nodes(vec![
crate::nodes::line_break::create_line_break_node(),
create_text_node("tail"),
paragraph_of(&[create_text_node("x")]),
])?;
let children = root.get_children();
assert_eq!(children.len(), 2);
assert_eq!(children[0].get_type(), "paragraph");
assert_eq!(child_types(&children[0]), ["text", "linebreak", "text"]);
assert_eq!(children[0].get_text_content(), "abc\ntail");
assert_eq!(children[1].get_type(), "paragraph");
assert_eq!(children[1].get_text_content(), "x");
Ok(())
});
}
#[test]
fn collapses_a_lone_trailing_linebreak_after_a_block_into_an_empty_paragraph() {
in_fresh_editor(|| {
let root = get_root();
root.clear()?;
let paragraph = create_paragraph_node();
root.append(std::slice::from_ref(¶graph))?;
paragraph.select_end()?.insert_nodes(vec![
paragraph_of(&[create_text_node("x")]),
crate::nodes::line_break::create_line_break_node(),
])?;
let children = root.get_children();
assert_eq!(children.len(), 2);
assert!(children.iter().all(|c| c.get_type() == "paragraph"));
assert_eq!(children[0].get_text_content(), "x");
assert_eq!(children[1].get_children_size(), 0);
Ok(())
});
}
fn format_all(
texts: &'static [(&'static str, bool)],
f: fn(&SelectionRef) -> Result<(), LexicalError>,
want: &'static [(bool, bool)],
) {
in_fresh_editor(move || {
let root = get_root();
root.clear()?;
let paragraph = create_paragraph_node();
for &(text, bold) in texts {
let node = create_text_node(text);
if bold {
node.set_format(f64::from(crate::constants::IS_BOLD));
}
paragraph.append(&[node])?;
}
root.append(std::slice::from_ref(¶graph))?;
let selection = crate::select_all()?;
f(&selection)?;
let got: Vec<(bool, bool)> = paragraph
.get_children()
.iter()
.map(|c| {
let format = crate::nodes::text::to_int32(c.text_data().get_format());
(
format & crate::constants::IS_BOLD != 0,
format & crate::constants::IS_ITALIC != 0,
)
})
.collect();
assert_eq!(got, want);
Ok(())
});
}
#[test]
fn format_text_uses_selection_format_instead_of_first_node_for_toggle_direction() {
format_all(
&[("bold", true), ("plain", false)],
|selection| {
assert!(!selection.has_format("bold"));
selection.format_text("bold", None)
},
&[(true, false), (true, false)],
);
}
#[test]
fn format_text_toggling_off_works_when_all_nodes_share_the_format() {
format_all(
&[("aaa", true), ("bbb", true)],
|selection| {
selection.set_format(f64::from(crate::constants::IS_BOLD));
assert!(selection.has_format("bold"));
selection.format_text("bold", None)
},
&[(false, false), (false, false)],
);
}
#[test]
fn format_text_explicit_align_with_format_bypasses_selection_format() {
format_all(
&[("bold", true), ("plain", false)],
|selection| selection.format_text("bold", Some(f64::from(crate::constants::IS_BOLD))),
&[(true, false), (true, false)],
);
}
#[test]
fn set_text_format_sets_bold_to_true_on_mixed_formatting() {
format_all(
&[("bold", true), ("plain", false)],
|selection| selection.set_text_format(&[("bold", true)]),
&[(true, false), (true, false)],
);
}
#[test]
fn set_text_format_sets_bold_to_false_on_all_bold_text() {
format_all(
&[("aaa", true), ("bbb", true)],
|selection| {
selection.set_format(f64::from(crate::constants::IS_BOLD));
selection.set_text_format(&[("bold", false)])
},
&[(false, false), (false, false)],
);
}
#[test]
fn set_text_format_sets_multiple_formats_at_once() {
format_all(
&[("hello", false)],
|selection| selection.set_text_format(&[("bold", true), ("italic", true)]),
&[(true, true)],
);
}
fn paste_at_start_and_describe_selection(blocks: Vec<NodeRef>) -> Result<String, LexicalError> {
let text = create_text_node("asdf");
get_root().clear()?;
get_root().append(&[paragraph_of(std::slice::from_ref(&text))])?;
text.select(Some(0), Some(0))?;
current().insert_nodes(blocks)?;
let after = range(¤t());
assert!(after.is_collapsed());
Ok(format!(
"{}:{:?}@{}",
after.anchor.point_type.as_str(),
after.anchor.get_node()?.get_text_content(),
after.anchor.offset
))
}
#[test]
fn insert_nodes_leaves_the_caret_where_content_ending_in_an_empty_block_joins() {
in_fresh_editor(|| {
let description = paste_at_start_and_describe_selection(vec![
paragraph_of(&[create_text_node("AA")]),
paragraph_of(&[create_text_node("BB")]),
create_paragraph_node(),
])?;
assert_eq!(texts_of(&get_root().get_children()), ["AA", "BB", "asdf"]);
assert_eq!(description, r#"text:"asdf"@0"#);
Ok(())
});
}
#[test]
fn insert_nodes_leaves_the_caret_where_content_ending_in_a_text_block_joins() {
in_fresh_editor(|| {
let description = paste_at_start_and_describe_selection(vec![
paragraph_of(&[create_text_node("AA")]),
paragraph_of(&[create_text_node("BB")]),
])?;
assert_eq!(texts_of(&get_root().get_children()), ["AA", "BBasdf"]);
assert_eq!(description, r#"text:"BB"@2"#);
Ok(())
});
}