#![cfg(feature = "rich-text")]
use super::super::support::{
TestBlockableDecoratorNode, create_test_blockable_decorator_node, set_is_inline,
set_test_root_element, update, update_with,
};
use super::support::paragraph;
use crate::extension::{
GetParentEditor, LexicalEditorWithDispose, NestedEditorConfigOverrides,
SelectBlockConfigOverrides, build_editor_from_extensions, get_extension_dependency_from_editor,
nested_editor_extension, prevent_select_all_extension, select_block_extension,
};
use crate::{
Editor, InitialEditorStateType, KeyboardEvent, LexicalError, LexicalExtension, NodeClass,
NodeRef, PointType, SELECT_ALL_COMMAND, Which, config_extension, create_node_selection,
create_paragraph_node, define_extension, get_root, get_selection, is_block_fully_selected,
set_selection,
};
use std::rc::Rc;
fn set_up_editor(cascade_selection: bool, disabled: bool) -> LexicalEditorWithDispose {
let editor = build_editor_from_extensions([define_extension(LexicalExtension {
initial_editor_state: Some(InitialEditorStateType::Update(Rc::new(|_| {
get_root().append(&[paragraph("first"), paragraph("second")])?;
Ok(())
}))),
dependencies: vec![config_extension(
&select_block_extension(),
[SelectBlockConfigOverrides {
cascade_selection: Some(cascade_selection),
disabled: Some(disabled),
}],
)],
nodes: vec![NodeClass::of::<TestBlockableDecoratorNode>()],
..LexicalExtension::<(), (), ()>::new("select-block-test", ())
})
.into()])
.unwrap();
set_test_root_element(&editor);
editor
}
fn default_editor() -> LexicalEditorWithDispose {
set_up_editor(false, false)
}
fn select_all_event() -> Rc<KeyboardEvent> {
Rc::new(KeyboardEvent {
key: "a".to_owned(),
ctrl_key: true,
..KeyboardEvent::default()
})
}
fn select_all(editor: &Editor) -> bool {
editor
.dispatch_command(&SELECT_ALL_COMMAND, select_all_event())
.unwrap()
}
fn second_paragraph() -> NodeRef {
let node = get_root().get_child_at_index(1).expect("second paragraph");
assert!(node.is_element());
node
}
fn fully_selected(block: &NodeRef) -> bool {
let range = get_selection()
.and_then(|s| s.range())
.expect("expecting a RangeSelection");
is_block_fully_selected(block, &range).unwrap()
}
fn expect_root_fully_selected(editor: &Editor) {
assert!(editor.read(|| fully_selected(&get_root())).unwrap());
}
fn caret_in_second(editor: &Editor) {
update(editor, || {
let text = second_paragraph().get_first_descendant().unwrap();
assert!(text.is_text());
text.select(Some(3), Some(3))?;
Ok(())
});
}
fn points(editor: &Editor) -> (String, usize, String, usize) {
editor
.read(|| {
let range = get_selection().and_then(|s| s.range()).unwrap();
let (a, f) = (range.point(Which::Anchor), range.point(Which::Focus));
(a.key.clone(), a.offset, f.key.clone(), f.offset)
})
.unwrap()
}
#[test]
fn selects_the_block_then_the_document() {
let editor = default_editor();
caret_in_second(&editor);
assert!(select_all(&editor));
editor
.read(|| {
assert!(fully_selected(&second_paragraph()));
assert!(!fully_selected(&get_root()));
})
.unwrap();
assert!(select_all(&editor));
expect_root_fully_selected(&editor);
editor.dispose();
}
#[test]
fn repeated_select_all_does_not_change_the_selection() {
let editor = default_editor();
caret_in_second(&editor);
select_all(&editor);
select_all(&editor);
let before = points(&editor);
select_all(&editor);
assert_eq!(points(&editor), before);
expect_root_fully_selected(&editor);
editor.dispose();
}
#[test]
fn a_selection_spanning_blocks_expands_to_the_document() {
let editor = default_editor();
update(&editor, || {
let first = get_root().get_first_descendant().unwrap();
let second = second_paragraph().get_first_descendant().unwrap();
let selection = first.select(Some(2), Some(2))?;
selection.point_set(Which::Focus, second.get_key(), 3, PointType::Text)?;
Ok(())
});
assert!(select_all(&editor));
expect_root_fully_selected(&editor);
editor.dispose();
}
#[test]
fn a_selection_on_the_root_selects_all() {
let editor = default_editor();
update(&editor, || {
get_root().select(Some(0), Some(1))?;
Ok(())
});
assert!(select_all(&editor));
expect_root_fully_selected(&editor);
editor.dispose();
}
#[test]
fn select_all_after_the_document_changes() {
let editor = default_editor();
caret_in_second(&editor);
select_all(&editor);
select_all(&editor);
update(&editor, || {
get_root().append(&[paragraph("third")])?;
Ok(())
});
assert!(select_all(&editor));
expect_root_fully_selected(&editor);
editor.dispose();
}
#[test]
fn select_all_preserves_a_full_selection() {
let editor = default_editor();
update(&editor, || {
let first = get_root().get_first_descendant().unwrap();
let last = get_root().get_last_descendant().unwrap();
let selection = last.select(Some(6), Some(6))?;
selection.point_set(Which::Focus, first.get_key(), 0, PointType::Text)?;
Ok(())
});
assert!(select_all(&editor));
editor
.read(|| {
let selection = get_selection().unwrap();
assert!(selection.is_backward().unwrap());
assert!(fully_selected(&get_root()));
})
.unwrap();
editor.dispose();
}
#[test]
fn select_all_in_a_single_block_document() {
let editor = default_editor();
update(&editor, || {
let root = get_root();
root.clear()?;
root.append(&[paragraph("only")])?;
root.get_first_descendant()
.unwrap()
.select(Some(2), Some(2))?;
Ok(())
});
assert!(select_all(&editor));
expect_root_fully_selected(&editor);
assert!(select_all(&editor));
expect_root_fully_selected(&editor);
editor.dispose();
}
fn select_node(node: &NodeRef) {
let selection = create_node_selection();
selection.add(node.get_key());
set_selection(Some(selection));
}
#[test]
fn a_node_selection_of_an_inline_decorator_selects_its_block() {
let editor = default_editor();
update(&editor, || {
let decorator = create_test_blockable_decorator_node();
second_paragraph().append(std::slice::from_ref(&decorator))?;
select_node(&decorator);
Ok(())
});
assert!(select_all(&editor));
assert!(editor.read(|| fully_selected(&second_paragraph())).unwrap());
editor.dispose();
}
#[test]
fn a_node_selection_of_a_top_level_decorator_selects_all() {
let editor = default_editor();
update(&editor, || {
let decorator = set_is_inline(&create_test_blockable_decorator_node(), false);
get_root().append(std::slice::from_ref(&decorator))?;
select_node(&decorator);
Ok(())
});
assert!(select_all(&editor));
expect_root_fully_selected(&editor);
editor.dispose();
}
#[test]
fn an_empty_node_selection_defers() {
let editor = default_editor();
update(&editor, || {
set_selection(Some(create_node_selection()));
Ok(())
});
assert!(!select_all(&editor));
editor.dispose();
}
#[test]
fn respects_disabled_config() {
let editor = set_up_editor(false, true);
caret_in_second(&editor);
assert!(!select_all(&editor));
editor.dispose();
}
#[test]
fn enables_and_disables_prevent_select_all_together() {
let editor = set_up_editor(false, true);
let select_block = get_extension_dependency_from_editor(&editor, &select_block_extension())
.unwrap()
.output
.unwrap();
let prevent = get_extension_dependency_from_editor(&editor, &prevent_select_all_extension())
.unwrap()
.output
.unwrap();
assert!(prevent.disabled.value());
select_block.disabled.set_value(false);
assert!(!prevent.disabled.value());
select_block.disabled.set_value(true);
assert!(prevent.disabled.value());
editor.dispose();
}
fn set_up_nested_editor(
parent: &Editor,
init: fn() -> Result<(), LexicalError>,
) -> LexicalEditorWithDispose {
let parent = parent.clone();
build_editor_from_extensions([define_extension(LexicalExtension {
initial_editor_state: Some(InitialEditorStateType::Update(Rc::new(move |_| init()))),
dependencies: vec![
crate::rich_text::rich_text_extension().into(),
config_extension(
&nested_editor_extension(),
[NestedEditorConfigOverrides {
get_parent_editor: Some(GetParentEditor(Rc::new(move || Ok(parent.clone())))),
..Default::default()
}],
),
],
namespace: Some("nested".to_owned()),
..LexicalExtension::<(), (), ()>::new("nested-editor-test", ())
})
.into()])
.unwrap()
}
fn caption() -> Result<(), LexicalError> {
get_root().append(&[paragraph("caption")])?;
Ok(())
}
#[test]
fn nested_ignores_bubbled_commands_without_cascade() {
let editor = default_editor();
let nested = set_up_nested_editor(&editor, caption);
update(&editor, || {
let decorator = create_test_blockable_decorator_node();
second_paragraph().append(std::slice::from_ref(&decorator))?;
select_node(&decorator);
Ok(())
});
assert!(select_all(&nested));
expect_root_fully_selected(&nested);
assert!(
editor
.read(|| get_selection().is_some_and(|s| s.is_node()))
.unwrap()
);
nested.dispose();
editor.dispose();
}
#[test]
fn nested_cascade_waits_until_the_nested_editor_is_fully_selected() {
let editor = set_up_editor(true, false);
let nested = set_up_nested_editor(&editor, caption);
update(&nested, || {
get_root()
.get_first_descendant()
.unwrap()
.select(Some(3), Some(3))?;
Ok(())
});
assert!(select_all(&nested));
expect_root_fully_selected(&nested);
assert!(
!editor
.read(|| get_selection().is_some_and(|s| s.is_range()))
.unwrap()
);
assert!(select_all(&nested));
expect_root_fully_selected(&editor);
nested.dispose();
editor.dispose();
}
#[test]
fn nested_cascade_from_inside_a_nested_update() {
let editor = set_up_editor(true, false);
let nested = set_up_nested_editor(&editor, caption);
let inner = nested.editor().clone();
let handled = update_with(&nested, move || {
crate::select_all()?;
let handled = inner.dispatch_command(&SELECT_ALL_COMMAND, select_all_event())?;
get_root().append(&[paragraph("after")])?;
Ok(handled)
});
assert!(handled);
let text = nested.read(|| get_root().get_text_content()).unwrap();
assert!(text.contains("caption"));
assert!(text.contains("after"));
expect_root_fully_selected(&editor);
nested.dispose();
editor.dispose();
}
#[test]
fn nested_cascade_from_an_empty_nested_editor() {
let editor = set_up_editor(true, false);
let nested = set_up_nested_editor(&editor, || {
let p = create_paragraph_node();
get_root().append(std::slice::from_ref(&p))?;
p.select_start()?;
Ok(())
});
assert!(select_all(&nested));
expect_root_fully_selected(&editor);
nested.dispose();
editor.dispose();
}