#![cfg(feature = "extension")]
use crate::extension::{LexicalEditorWithDispose, build_editor_from_extensions};
use crate::upstream_tests::support::{
TestBlockableDecoratorNode, TestShadowRootNode, create_test_decorator_node_inline,
create_test_shadow_root_node,
};
use crate::utils::{DFSNode, dfs_with_slots, reverse_dfs_with_slots};
use crate::{
InitialEditorStateType, LexicalExtension, NodeClass, NodeKey, NodeRef, create_paragraph_node,
create_text_node, define_extension, get_root, get_slot, get_slot_names, set_slot,
};
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
type Keys = Rc<RefCell<HashMap<&'static str, NodeKey>>>;
fn pairs(nodes: Vec<DFSNode>) -> Vec<(usize, NodeKey)> {
nodes
.into_iter()
.map(|DFSNode { depth, node }| (depth, node.get_key().to_owned()))
.collect()
}
fn expected(keys: &Keys, pairs: &[(usize, &str)]) -> Vec<(usize, NodeKey)> {
let keys = keys.borrow();
pairs
.iter()
.map(|(depth, name)| (*depth, keys[name].clone()))
.collect()
}
fn slot_aware_dfs(depth: usize, node: &NodeRef, out: &mut Vec<(usize, NodeKey)>) {
out.push((depth, node.get_key().to_owned()));
if node.is_element() {
for name in get_slot_names(node) {
if let Some(slot) = get_slot(node, &name) {
slot_aware_dfs(depth + 1, &slot, out);
}
}
for child in node.get_children() {
slot_aware_dfs(depth + 1, &child, out);
}
}
}
fn reverse_slot_aware_dfs(depth: usize, node: &NodeRef, out: &mut Vec<(usize, NodeKey)>) {
out.push((depth, node.get_key().to_owned()));
if node.is_element() {
for child in node.get_children().iter().rev() {
reverse_slot_aware_dfs(depth + 1, child, out);
}
for name in get_slot_names(node).iter().rev() {
if let Some(slot) = get_slot(node, name) {
reverse_slot_aware_dfs(depth + 1, &slot, out);
}
}
}
}
fn slot_tree_editor() -> (LexicalEditorWithDispose, Keys) {
let keys: Keys = Rc::default();
let out = keys.clone();
let editor = build_editor_from_extensions([define_extension(LexicalExtension {
initial_editor_state: Some(InitialEditorStateType::Update(Rc::new(move |_| {
let host = create_paragraph_node();
let title = create_test_shadow_root_node();
let title_para = create_paragraph_node();
let title_text = create_text_node("Title");
title_para.append(std::slice::from_ref(&title_text))?;
title.append(std::slice::from_ref(&title_para))?;
let body = create_paragraph_node();
let body_text = create_text_node("Body");
body.append(std::slice::from_ref(&body_text))?;
get_root().append(std::slice::from_ref(&host))?;
host.append(std::slice::from_ref(&body))?;
set_slot(&host, "title", &title)?;
let mut keys = out.borrow_mut();
for (name, node) in [
("host", &host),
("title", &title),
("titlePara", &title_para),
("titleText", &title_text),
("body", &body),
("bodyText", &body_text),
] {
keys.insert(name, node.get_key().to_owned());
}
Ok(())
}))),
nodes: vec![NodeClass::of::<TestShadowRootNode>()],
..LexicalExtension::<(), (), ()>::new("[slot-dfs]", ())
})
.into()])
.unwrap();
(editor, keys)
}
#[test]
fn dfs_with_slots_visits_slot_subtrees_slots_first() {
let (editor, keys) = slot_tree_editor();
editor
.read(|| {
let host = get_root().get_first_child().unwrap();
assert_eq!(
pairs(dfs_with_slots(Some(&host), None)),
expected(
&keys,
&[
(1, "host"),
(2, "title"),
(3, "titlePara"),
(4, "titleText"),
(2, "body"),
(3, "bodyText"),
]
)
);
})
.unwrap();
}
#[test]
fn dfs_with_slots_matches_the_reference_slots_first_walk() {
let (editor, _) = slot_tree_editor();
editor
.read(|| {
let host = get_root().get_first_child().unwrap();
let mut reference = Vec::new();
slot_aware_dfs(1, &host, &mut reference);
assert_eq!(pairs(dfs_with_slots(Some(&host), None)), reference);
})
.unwrap();
}
#[test]
fn reverse_dfs_with_slots_visits_slots_last() {
let (editor, keys) = slot_tree_editor();
editor
.read(|| {
let host = get_root().get_first_child().unwrap();
let visited = pairs(reverse_dfs_with_slots(Some(&host), None));
assert_eq!(
visited,
expected(
&keys,
&[
(1, "host"),
(2, "body"),
(3, "bodyText"),
(2, "title"),
(3, "titlePara"),
(4, "titleText"),
]
)
);
let mut reference = Vec::new();
reverse_slot_aware_dfs(1, &host, &mut reference);
assert_eq!(visited, reference);
})
.unwrap();
}
#[test]
fn end_node_slot_subtrees_are_not_emitted_past_the_inclusive_stop() {
let (editor, keys) = slot_tree_editor();
editor
.read(|| {
let root = get_root();
let host = root.get_first_child().unwrap();
let truncated = vec![
(0, root.get_key().to_owned()),
(1, keys.borrow()["host"].clone()),
];
assert_eq!(pairs(dfs_with_slots(Some(&root), Some(&host))), truncated);
assert_eq!(
pairs(reverse_dfs_with_slots(Some(&root), Some(&host))),
truncated
);
})
.unwrap();
}
#[test]
fn reconciler_text_cache_includes_slot_text() {
let (editor, _) = slot_tree_editor();
editor
.read(|| {
let root = get_root();
let host = root.get_first_child().unwrap();
assert_eq!(host.get_text_content(), "TitleBody");
assert_eq!(root.get_text_content(), "TitleBody");
})
.unwrap();
}
fn decorator_slot_editor() -> (LexicalEditorWithDispose, Keys) {
let keys: Keys = Rc::default();
let out = keys.clone();
let editor = build_editor_from_extensions([define_extension(LexicalExtension {
initial_editor_state: Some(InitialEditorStateType::Update(Rc::new(move |_| {
let host = create_test_decorator_node_inline(false);
let media = create_test_shadow_root_node();
let media_para = create_paragraph_node();
let media_text = create_text_node("Eq");
media_para.append(std::slice::from_ref(&media_text))?;
media.append(std::slice::from_ref(&media_para))?;
get_root().append(std::slice::from_ref(&host))?;
set_slot(&host, "media", &media)?;
let mut keys = out.borrow_mut();
for (name, node) in [
("host", &host),
("media", &media),
("mediaPara", &media_para),
("mediaText", &media_text),
] {
keys.insert(name, node.get_key().to_owned());
}
Ok(())
}))),
nodes: vec![
NodeClass::of::<TestShadowRootNode>(),
NodeClass::of::<TestBlockableDecoratorNode>(),
],
..LexicalExtension::<(), (), ()>::new("[slot-dfs-decorator]", ())
})
.into()])
.unwrap();
(editor, keys)
}
const MEDIA: [(usize, &str); 4] = [
(1, "host"),
(2, "media"),
(3, "mediaPara"),
(4, "mediaText"),
];
#[test]
fn dfs_with_slots_descends_into_a_decorator_hosts_slots() {
let (editor, keys) = decorator_slot_editor();
editor
.read(|| {
let host = get_root().get_first_child().unwrap();
assert_eq!(
pairs(dfs_with_slots(Some(&host), None)),
expected(&keys, &MEDIA)
);
})
.unwrap();
}
#[test]
fn reverse_dfs_with_slots_descends_into_a_decorator_hosts_slots() {
let (editor, keys) = decorator_slot_editor();
editor
.read(|| {
let host = get_root().get_first_child().unwrap();
assert_eq!(
pairs(reverse_dfs_with_slots(Some(&host), None)),
expected(&keys, &MEDIA)
);
})
.unwrap();
}