use super::{
EscapeFormatTriggerConfig, RichTextConfig, ShouldHandlePasteAsFiles, register_rich_text_with,
rich_text_nodes,
};
use crate::extension::normalize_inline_elements_extension;
use crate::extension::signals::{Signal, effect, signal};
use crate::extension_core::{
ExtensionBuildState, ExtensionConfigBase, ExtensionRegisterState, LexicalExtension,
define_extension,
};
use crate::{Editor, Unregister};
use std::rc::Rc;
#[derive(Clone, Default)]
pub struct RichTextConfigOverrides {
pub escape_format_triggers: Option<EscapeFormatTriggerConfig>,
pub should_handle_paste_as_files: Option<ShouldHandlePasteAsFiles>,
}
impl ExtensionConfigBase for RichTextConfig {
type Partial = RichTextConfigOverrides;
fn shallow_merge(&self, overrides: &RichTextConfigOverrides) -> Self {
RichTextConfig {
escape_format_triggers: overrides
.escape_format_triggers
.clone()
.unwrap_or_else(|| self.escape_format_triggers.clone()),
should_handle_paste_as_files: overrides
.should_handle_paste_as_files
.clone()
.unwrap_or_else(|| self.should_handle_paste_as_files.clone()),
}
}
}
fn merge_escape_format_triggers(
config: &EscapeFormatTriggerConfig,
overrides: &EscapeFormatTriggerConfig,
) -> EscapeFormatTriggerConfig {
let mut merged = config.clone();
for (format, override_) in overrides {
let base = config
.iter()
.find(|(f, _)| f == format)
.and_then(|(_, triggers)| triggers.as_ref());
let value = match (base, override_) {
(Some(base), Some(override_)) => Some(base.merged(override_)),
_ => override_.clone(),
};
match merged.iter_mut().find(|(f, _)| f == format) {
Some(entry) => entry.1 = value,
None => merged.push((format.clone(), value)),
}
}
merged
}
fn merge_rich_text_config(
config: &RichTextConfig,
overrides: &RichTextConfigOverrides,
) -> RichTextConfig {
let mut merged = config.shallow_merge(overrides);
if let Some(triggers) = &overrides.escape_format_triggers {
merged.escape_format_triggers =
merge_escape_format_triggers(&config.escape_format_triggers, triggers);
}
merged
}
#[derive(Clone)]
pub struct RichTextOutput {
pub escape_format_triggers: Signal<EscapeFormatTriggerConfig>,
pub should_handle_paste_as_files: Signal<ShouldHandlePasteAsFiles>,
}
pub type RichTextExtensionType = LexicalExtension<RichTextConfig, RichTextOutput, ()>;
fn make() -> Rc<RichTextExtensionType> {
define_extension(LexicalExtension {
build: Some(Rc::new(
|_: &Editor, config: &RichTextConfig, _: &ExtensionBuildState<()>| {
Ok(RichTextOutput {
escape_format_triggers: signal(config.escape_format_triggers.clone()),
should_handle_paste_as_files: signal(
config.should_handle_paste_as_files.clone(),
),
})
},
)),
conflicts_with: vec!["@lexical/plain-text".to_owned()],
dependencies: {
#[allow(unused_mut)]
let mut dependencies = vec![
normalize_inline_elements_extension().into(),
crate::extension::normalize_triple_click_selection_extension().into(),
];
#[cfg(feature = "a11y")]
dependencies.insert(0, super::heading_announce_extension().into());
#[cfg(feature = "html")]
dependencies.extend(crate::html::import::package_import_dependencies(
super::rich_text_import_rules(),
Vec::new(),
));
dependencies
},
merge_config: Some(Rc::new(merge_rich_text_config)),
nodes: rich_text_nodes(),
register: Some(Rc::new(
|editor: &Editor,
_: &RichTextConfig,
state: &ExtensionRegisterState<(), RichTextOutput>| {
let output = state.get_output().expect("RichTextExtension has a build");
let editor = editor.weak();
Ok(effect(move || {
let editor = editor.upgrade().map(Editor)?;
let triggers = output.escape_format_triggers.clone();
let paste_as_files = output.should_handle_paste_as_files.clone();
Some(register_rich_text_with(
&editor,
Rc::new(move || triggers.peek()),
Rc::new(move || paste_as_files.peek()),
))
}) as Unregister)
},
)),
..LexicalExtension::new("@lexical/rich-text", RichTextConfig::default())
})
}
thread_local! {
static RICH_TEXT_EXTENSION: Rc<RichTextExtensionType> = make();
}
pub fn rich_text_extension() -> Rc<RichTextExtensionType> {
RICH_TEXT_EXTENSION.with(Rc::clone)
}