use crate::dom::DomNode;
use crate::editor::NodeClass;
use crate::json::{Object, Value};
use crate::lexical_selection::SelectionRef;
use crate::node::{LexicalNode, NodeRef};
use crate::selection_deletion::is_js_whitespace;
use crate::{Editor, LexicalError};
use std::collections::HashMap;
use std::rc::Rc;
pub use crate::dom::get_document;
pub type DomExportAfter = Box<dyn FnOnce(&DomNode) -> Result<Option<DomNode>, LexicalError>>;
pub type DomExportAppend = Box<dyn FnOnce(&DomNode) -> Result<(), LexicalError>>;
#[derive(Default)]
pub struct DomExportOutput {
pub element: Option<DomNode>,
pub after: Option<DomExportAfter>,
pub append: Option<DomExportAppend>,
pub get_child_nodes: Option<Box<dyn FnOnce() -> Vec<NodeRef>>>,
}
impl DomExportOutput {
pub fn element(element: DomNode) -> Self {
Self {
element: Some(element),
..Self::default()
}
}
}
pub type DomChildConversion =
Rc<dyn Fn(&NodeRef, Option<&NodeRef>) -> Result<Option<NodeRef>, LexicalError>>;
#[derive(Clone, Debug, Default)]
pub enum DomConversionNode {
#[default]
None,
One(NodeRef),
Many(Vec<NodeRef>),
}
pub type DomConversionAfter = Box<dyn FnOnce(Vec<NodeRef>) -> Result<Vec<NodeRef>, LexicalError>>;
#[derive(Default)]
pub struct DomConversionOutput {
pub node: DomConversionNode,
pub for_child: Option<DomChildConversion>,
pub after: Option<DomConversionAfter>,
}
impl DomConversionOutput {
pub fn node(node: Option<NodeRef>) -> Self {
Self {
node: node.map_or(DomConversionNode::None, DomConversionNode::One),
..Self::default()
}
}
}
pub type DomConversionFn =
Rc<dyn Fn(&DomNode) -> Result<Option<DomConversionOutput>, LexicalError>>;
#[derive(Clone)]
pub struct DomConversion {
pub conversion: DomConversionFn,
pub priority: u8,
}
pub type DomImporter = Rc<dyn Fn(&DomNode) -> Option<DomConversion>>;
pub type DomConversionMap = Vec<(String, DomImporter)>;
pub fn importer(
priority: u8,
conversion: impl Fn(&DomNode) -> Result<Option<DomConversionOutput>, LexicalError> + 'static,
) -> DomImporter {
let conversion: DomConversionFn = Rc::new(conversion);
Rc::new(move |_| {
Some(DomConversion {
conversion: conversion.clone(),
priority,
})
})
}
pub type ExportOverride =
Rc<dyn Fn(&Editor, &dyn LexicalNode, &NodeRef) -> Result<DomExportOutput, LexicalError>>;
#[derive(Clone, Default)]
pub struct HtmlConfig {
pub export: Vec<(&'static str, ExportOverride)>,
pub import: DomConversionMap,
}
pub(crate) fn initialize_conversion_cache(
nodes: &[NodeClass],
additional: &DomConversionMap,
) -> HashMap<String, Vec<DomImporter>> {
let mut cache: HashMap<String, Vec<DomImporter>> = HashMap::new();
let mut add = |map: &DomConversionMap| {
for (key, importer) in map {
cache.entry(key.clone()).or_default().push(importer.clone());
}
};
for class in nodes {
if let Some(map) = (class.import_dom)() {
add(&map);
}
}
add(additional);
cache
}
pub(crate) fn get_conversion_function(
dom_node: &DomNode,
editor: &Editor,
) -> Option<DomConversionFn> {
let name = dom_node.node_name().to_lowercase();
let mut current: Option<DomConversion> = None;
for importer in editor.0.html_conversions.get(&name)? {
if let Some(conversion) = importer(dom_node)
&& current
.as_ref()
.is_none_or(|c| c.priority <= conversion.priority)
{
current = Some(conversion);
}
}
current.map(|c| c.conversion)
}
pub type CreateDomHook =
Rc<dyn Fn(&dyn LexicalNode, &NodeRef, &Editor) -> Result<DomNode, LexicalError>>;
pub type ExportDomHook =
Rc<dyn Fn(&dyn LexicalNode, &NodeRef, &Editor) -> Result<DomExportOutput, LexicalError>>;
pub type ExtractWithChildHook = Rc<
dyn Fn(&NodeRef, &NodeRef, Option<&SelectionRef>, &str, &Editor) -> Result<bool, LexicalError>,
>;
pub type SelectionHook =
Rc<dyn Fn(&NodeRef, Option<&SelectionRef>, &Editor) -> Result<bool, LexicalError>>;
#[derive(Clone)]
pub struct EditorDomRenderConfig {
pub create_dom: CreateDomHook,
pub export_dom: ExportDomHook,
pub extract_with_child: ExtractWithChildHook,
pub should_exclude: SelectionHook,
pub should_include: SelectionHook,
}
impl Default for EditorDomRenderConfig {
fn default() -> Self {
Self {
create_dom: Rc::new(create_dom),
export_dom: Rc::new(export_dom),
extract_with_child: Rc::new(|node, child, selection, destination, _| {
extract_with_child(node, child, selection, destination)
}),
should_exclude: Rc::new(|node, _, _| Ok(should_exclude(node))),
should_include: Rc::new(|node, selection, _| should_include(node, selection)),
}
}
}
pub fn get_editor_dom_render_config(editor: &Editor) -> EditorDomRenderConfig {
editor.0.dom.borrow().clone()
}
#[cfg_attr(not(feature = "extension"), allow(dead_code))]
pub(crate) fn set_editor_dom_render_config(editor: &Editor, dom: EditorDomRenderConfig) {
*editor.0.dom.borrow_mut() = dom;
}
pub fn create_dom(
node: &dyn LexicalNode,
this: &NodeRef,
editor: &Editor,
) -> Result<DomNode, LexicalError> {
node.create_dom(this, editor.config(), editor)
}
pub fn export_dom(
node: &dyn LexicalNode,
this: &NodeRef,
editor: &Editor,
) -> Result<DomExportOutput, LexicalError> {
match editor.0.html_export.get(node.get_type()) {
Some(export) => export(editor, node, this),
None => node.export_dom(this, editor),
}
}
pub fn extract_with_child(
node: &NodeRef,
child: &NodeRef,
selection: Option<&SelectionRef>,
destination: &str,
) -> Result<bool, LexicalError> {
if !node.is_element() {
return Ok(false);
}
node.extract_with_child(child, selection, destination)
}
pub fn should_exclude(node: &NodeRef) -> bool {
node.is_element() && node.exclude_from_copy("html")
}
pub fn should_include(
node: &NodeRef,
selection: Option<&SelectionRef>,
) -> Result<bool, LexicalError> {
match selection {
Some(selection) => node.is_selected(Some(selection)),
None => Ok(true),
}
}
pub fn export_dom_base(
node: &dyn LexicalNode,
this: &NodeRef,
editor: &Editor,
) -> Result<DomExportOutput, LexicalError> {
let create_dom = get_editor_dom_render_config(editor).create_dom;
Ok(DomExportOutput::element(create_dom(node, this, editor)?))
}
fn matches_tag(node: &DomNode, tags: &[&str]) -> bool {
let name = node.node_name().to_ascii_lowercase();
tags.contains(&name.as_str())
}
const INLINE_TAGS: &[&str] = &[
"a", "abbr", "acronym", "b", "cite", "code", "del", "em", "i", "ins", "kbd", "label", "mark",
"output", "q", "ruby", "s", "samp", "span", "strong", "sub", "sup", "time", "u", "tt", "var",
"#text",
];
const BLOCK_TAGS: &[&str] = &[
"address",
"article",
"aside",
"blockquote",
"canvas",
"dd",
"div",
"dl",
"dt",
"fieldset",
"figcaption",
"figure",
"footer",
"form",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"header",
"hr",
"li",
"main",
"nav",
"noscript",
"ol",
"p",
"pre",
"section",
"table",
"td",
"tfoot",
"ul",
"video",
];
fn is_displayed_inline(node: &DomNode) -> bool {
node.is_element()
&& node
.style()
.get_property_value("display")
.starts_with("inline")
}
pub fn is_inline_dom_node(node: &DomNode) -> bool {
is_displayed_inline(node) || matches_tag(node, INLINE_TAGS)
}
pub fn is_block_dom_node(node: &DomNode) -> bool {
!is_displayed_inline(node) && matches_tag(node, BLOCK_TAGS)
}
pub fn normalize_class_names(class_names: &[&str]) -> Vec<String> {
class_names
.iter()
.flat_map(|c| c.split(is_js_whitespace).filter(|s| !s.is_empty()))
.map(str::to_owned)
.collect()
}
pub fn add_class_names_to_element(element: &DomNode, class_names: &[&str]) {
let tokens = normalize_class_names(class_names);
if !tokens.is_empty() {
element.class_list().add(&tokens);
}
}
pub fn remove_class_names_from_element(element: &DomNode, class_names: &[&str]) {
let tokens = normalize_class_names(class_names);
if !tokens.is_empty() {
element.class_list().remove(&tokens);
}
}
pub fn get_cached_class_name_array(theme: &Object, key: &str) -> Option<Vec<String>> {
match theme.get(key)? {
Value::String(names) => Some(normalize_class_names(&[names])),
Value::Array(names) => Some(
names
.iter()
.filter_map(|n| n.as_str().map(str::to_owned))
.collect(),
),
_ => None,
}
}
pub fn theme_string<'a>(theme: &'a Object, key: &str) -> Option<&'a str> {
theme.get(key).and_then(Value::as_str)
}
pub fn add_theme_class_names(element: &DomNode, theme: &Object, key: &str) {
if let Some(class_names) = theme_string(theme, key) {
add_class_names_to_element(element, &[class_names]);
}
}
pub fn closest(element: &DomNode, tag: &str) -> Option<DomNode> {
let mut node = Some(element.clone());
while let Some(n) = node {
if n.is_element() && n.local_name() == tag {
return Some(n);
}
node = n.parent_element();
}
None
}
pub fn remove_empty_dom_attribute(dom: &DomNode, attribute_name: &str) {
if dom.get_attribute(attribute_name).as_deref() == Some("") {
dom.remove_attribute(attribute_name);
}
}
pub fn js_parse_int(string: &str) -> Option<f64> {
let s = string.trim_start_matches(is_js_whitespace);
let (negative, digits) = match s.as_bytes().first() {
Some(b'-') => (true, &s[1..]),
Some(b'+') => (false, &s[1..]),
_ => (false, s),
};
let end = digits
.bytes()
.position(|b| !b.is_ascii_digit())
.unwrap_or(digits.len());
if end == 0 {
return None;
}
let value: f64 = digits[..end].parse().ok()?;
Some(if negative { -value } else { value })
}
pub fn js_round(x: f64) -> f64 {
let r = (x + 0.5).floor();
if r == 0.0 && x < 0.0 { -0.0 } else { r }
}
pub fn set_node_indent_from_dom(
element_dom: &DomNode,
element_node: &NodeRef,
) -> Result<(), LexicalError> {
if let Some(indent_attr) = element_dom.get_attribute("data-lexical-indent")
&& let Some(parsed) = js_parse_int(&indent_attr).filter(|p| p.is_finite() && *p >= 0.0)
{
return element_node.set_indent(parsed);
}
let padding = element_dom
.style()
.get_property_value("padding-inline-start");
let indent_size = js_parse_int(&padding).filter(|n| *n != 0.0).unwrap_or(0.0);
element_node.set_indent(js_round(indent_size / 40.0) + 0.0)
}
pub fn set_direction_from_dom(node: &NodeRef, dom_node: &DomNode) {
use crate::nodes::element::Direction;
match dom_node.get_attribute("dir").as_deref() {
Some("ltr") => node.set_direction(Some(Direction::Ltr)),
Some("rtl") => node.set_direction(Some(Direction::Rtl)),
_ => {}
}
}
pub fn is_element_format_type(format_type: &str) -> bool {
!format_type.is_empty()
&& crate::constants::lookup(crate::constants::ELEMENT_TYPE_TO_FORMAT, format_type).is_some()
}
pub fn set_format_from_dom(node: &NodeRef, dom_node: &DomNode) {
let alignment = dom_node.style().get_property_value("text-align");
if is_element_format_type(&alignment) {
node.set_element_format(&alignment);
}
}
fn is_whitespace_dom_text_node(node: &DomNode) -> bool {
if !node.is_text() {
return false;
}
let text = node.text_content();
!text.is_empty() && is_whitespace_run(&text)
}
fn is_whitespace_run(text: &str) -> bool {
let bytes = text.as_bytes();
let mut i = 0;
while i < bytes.len() {
match bytes[i] {
b' ' | b'\t' | b'\n' => i += 1,
b'\r' if bytes.get(i + 1) == Some(&b'\n') => i += 2,
_ => return false,
}
}
true
}
pub fn is_only_child_in_block_node(node: &DomNode) -> bool {
let Some(parent) = node.parent_element().filter(is_block_dom_node) else {
return false;
};
let first = parent.first_child().expect("a parent has children");
let at_start = &first == node
|| (first.next_sibling().as_ref() == Some(node) && is_whitespace_dom_text_node(&first));
if !at_start {
return false;
}
let last = parent.last_child().expect("a parent has children");
&last == node
|| (last.previous_sibling().as_ref() == Some(node) && is_whitespace_dom_text_node(&last))
}
pub fn is_last_child_in_block_node(node: &DomNode) -> bool {
let Some(parent) = node.parent_element().filter(is_block_dom_node) else {
return false;
};
let first = parent.first_child().expect("a parent has children");
if &first == node
|| (first.next_sibling().as_ref() == Some(node) && is_whitespace_dom_text_node(&first))
{
return false;
}
let last = parent.last_child().expect("a parent has children");
&last == node
|| (last.previous_sibling().as_ref() == Some(node) && is_whitespace_dom_text_node(&last))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_int_and_round_as_js() {
assert_eq!(js_parse_int(" 12px"), Some(12.0));
assert_eq!(js_parse_int("-3.9"), Some(-3.0));
assert_eq!(js_parse_int("px"), None);
assert_eq!(js_parse_int("+7"), Some(7.0));
assert_eq!(js_round(2.5), 3.0);
assert_eq!(js_round(-2.5), -2.0);
assert!(js_round(-0.4) == 0.0 && js_round(-0.4).is_sign_negative());
}
#[test]
fn a_composed_text_node_ends_with_the_composition_suffix() {
use crate::{
CreateEditorArgs, UpdateOptions, create_editor, create_paragraph_node,
create_text_node, get_root, set_composition_key,
};
let editor = create_editor(CreateEditorArgs::default());
let html = Rc::new(std::cell::RefCell::new(String::new()));
let out = html.clone();
let read = editor.clone();
editor
.update(
move || {
let text = create_text_node("ab");
let bold = create_text_node("c");
bold.set_format(1.0);
let paragraph = create_paragraph_node();
paragraph.append(&[text.clone(), bold])?;
get_root().append(&[paragraph])?;
set_composition_key(Some(text.get_key()));
*out.borrow_mut() = crate::html::generate_html_from_nodes(&read, None)?;
Ok(())
},
UpdateOptions {
discrete: true,
..UpdateOptions::default()
},
)
.unwrap();
assert_eq!(
*html.borrow(),
"<p><span style=\"white-space: pre-wrap;\">ab\u{200b}</span><b><strong style=\"white-space: pre-wrap;\">c</strong></b></p>"
);
}
}