use crate::a11y::{aria_live_region_extension, replace_first};
use crate::error::invariant;
use crate::extension::named_signals_config;
use crate::extension::signals::effect;
use crate::extension_core::{
ExtensionBuildState, ExtensionRegisterState, LexicalExtension, define_extension,
};
use crate::{Editor, MutationListenerOptions, NodeMutation, Unregister};
use std::rc::Rc;
named_signals_config! {
pub struct AutoLinkAnnounceExtensionConfig;
pub struct AutoLinkAnnounceExtensionConfigOverrides;
pub struct AutoLinkAnnounceOutput {
created: String,
created_many: String,
destroyed: String,
destroyed_many: String,
disabled: bool,
}
}
pub type AutoLinkAnnounceExtensionType =
LexicalExtension<AutoLinkAnnounceExtensionConfig, AutoLinkAnnounceOutput, ()>;
fn make() -> Rc<AutoLinkAnnounceExtensionType> {
define_extension(LexicalExtension {
build: Some(Rc::new(
|_: &Editor, config: &AutoLinkAnnounceExtensionConfig, _: &ExtensionBuildState<()>| {
Ok(AutoLinkAnnounceOutput::of(config))
},
)),
dependencies: vec![aria_live_region_extension().into()],
register: Some(Rc::new(
|editor: &Editor,
_: &AutoLinkAnnounceExtensionConfig,
state: &ExtensionRegisterState<(), AutoLinkAnnounceOutput>| {
let output = state
.get_output()
.expect("AutoLinkAnnounceExtension has a build");
let announcer = (*state
.get_dependency(&aria_live_region_extension())?
.output
.expect("AriaLiveRegionExtension has a build"))
.clone();
invariant!(
editor.registered_nodes().contains_key("autolink"),
"Node AutoLinkNode has not been registered. Ensure node has been passed to createEditor."
);
let weak = editor.weak();
Ok(effect(move || {
if output.disabled.value() {
return None;
}
let editor = weak.upgrade().map(Editor)?;
let output = output.clone();
let announcer = announcer.clone();
editor
.register_mutation_listener(
"autolink",
move |nodes, _| {
let created_count = nodes
.iter()
.filter(|(_, m)| *m == NodeMutation::Created)
.count();
let destroyed_count = nodes
.iter()
.filter(|(_, m)| *m == NodeMutation::Destroyed)
.count();
if created_count > 0 && destroyed_count == 0 {
announcer.announce(&if created_count == 1 {
output.created.peek()
} else {
replace_first(
&output.created_many.peek(),
&created_count.to_string(),
)
});
} else if destroyed_count > 0 && created_count == 0 {
announcer.announce(&if destroyed_count == 1 {
output.destroyed.peek()
} else {
replace_first(
&output.destroyed_many.peek(),
&destroyed_count.to_string(),
)
});
}
},
MutationListenerOptions {
skip_initialization: true,
},
)
.ok()
.map(|unregister| unregister as Unregister)
}))
},
)),
..LexicalExtension::new(
"@lexical/link/AutoLinkAnnounce",
AutoLinkAnnounceExtensionConfig {
created: "Link".to_owned(),
created_many: "%s links".to_owned(),
destroyed: "Link removed".to_owned(),
destroyed_many: "%s links removed".to_owned(),
disabled: false,
},
)
})
}
thread_local! {
static AUTO_LINK_ANNOUNCE_EXTENSION: Rc<AutoLinkAnnounceExtensionType> = make();
}
pub fn auto_link_announce_extension() -> Rc<AutoLinkAnnounceExtensionType> {
AUTO_LINK_ANNOUNCE_EXTENSION.with(Rc::clone)
}