use crate::extension::named_signals_config;
use crate::extension::root_element_extension;
use crate::extension::signals::{Signal, effect, signal};
use crate::extension_core::{
ExtensionBuildState, ExtensionConfigBase, ExtensionInitState, ExtensionRegisterState,
InitialEditorConfig, LexicalExtension, define_extension,
};
use crate::merge_register::merge_register;
use crate::{
COMMAND_PRIORITY_LOW, Editor, LexicalError, REDO_COMMAND, RootElementRef, UNDO_COMMAND,
Unregister,
};
use std::cell::{Cell, RefCell};
use std::rc::{Rc, Weak};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum AriaPoliteness {
#[default]
Polite,
Assertive,
}
impl AriaPoliteness {
pub fn as_str(&self) -> &'static str {
match self {
AriaPoliteness::Polite => "polite",
AriaPoliteness::Assertive => "assertive",
}
}
pub fn parse(politeness: &str) -> Option<Self> {
match politeness {
"polite" => Some(AriaPoliteness::Polite),
"assertive" => Some(AriaPoliteness::Assertive),
_ => None,
}
}
}
#[derive(Debug)]
pub struct LiveRegion {
politeness: Cell<Option<AriaPoliteness>>,
text_content: RefCell<String>,
host: RefCell<Option<Weak<dyn LiveRegionHost>>>,
}
impl LiveRegion {
pub fn role(&self) -> &'static str {
"status"
}
pub fn atomic(&self) -> bool {
true
}
pub fn politeness(&self) -> Option<AriaPoliteness> {
self.politeness.get()
}
pub fn text_content(&self) -> String {
self.text_content.borrow().clone()
}
fn host(&self) -> Option<Rc<dyn LiveRegionHost>> {
self.host.borrow().as_ref().and_then(Weak::upgrade)
}
fn set_politeness(self: &Rc<Self>, politeness: AriaPoliteness) {
self.politeness.set(Some(politeness));
if let Some(host) = self.host() {
host.live_region_did_update(self);
}
}
fn set_text_content(self: &Rc<Self>, text: String) {
*self.text_content.borrow_mut() = text;
if let Some(host) = self.host() {
host.live_region_did_update(self);
}
}
fn remove(self: &Rc<Self>) {
let host = self.host.borrow_mut().take().and_then(|h| h.upgrade());
if let Some(host) = host {
host.unmount_live_region(self);
}
}
}
pub trait LiveRegionHost {
fn mount_live_region(&self, region: &Rc<LiveRegion>) {
let _ = region;
}
fn unmount_live_region(&self, region: &Rc<LiveRegion>) {
let _ = region;
}
fn live_region_did_update(&self, region: &Rc<LiveRegion>) {
let _ = region;
}
}
#[derive(Clone)]
pub struct LiveRegionHostRef(pub Rc<dyn LiveRegionHost>);
impl PartialEq for LiveRegionHostRef {
fn eq(&self, other: &Self) -> bool {
std::ptr::addr_eq(Rc::as_ptr(&self.0), Rc::as_ptr(&other.0))
}
}
impl std::fmt::Debug for LiveRegionHostRef {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"LiveRegionHostRef({:p})",
Rc::as_ptr(&self.0) as *const ()
)
}
}
#[derive(Clone)]
struct RegionRef(Rc<LiveRegion>);
impl PartialEq for RegionRef {
fn eq(&self, other: &Self) -> bool {
Rc::ptr_eq(&self.0, &other.0)
}
}
#[derive(Clone, Default)]
pub struct AriaLiveRegionExtensionConfig {
pub politeness: AriaPoliteness,
pub owner: Option<LiveRegionHostRef>,
}
#[derive(Clone, Default)]
pub struct AriaLiveRegionExtensionConfigOverrides {
pub politeness: Option<AriaPoliteness>,
pub owner: Option<Option<LiveRegionHostRef>>,
}
impl ExtensionConfigBase for AriaLiveRegionExtensionConfig {
type Partial = AriaLiveRegionExtensionConfigOverrides;
fn shallow_merge(&self, overrides: &Self::Partial) -> Self {
AriaLiveRegionExtensionConfig {
politeness: overrides.politeness.unwrap_or(self.politeness),
owner: overrides
.owner
.clone()
.unwrap_or_else(|| self.owner.clone()),
}
}
}
#[derive(Clone)]
pub struct AriaLiveRegion {
pub politeness: Signal<AriaPoliteness>,
pub owner: Signal<Option<LiveRegionHostRef>>,
message: Signal<String>,
}
impl AriaLiveRegion {
pub fn announce(&self, text: &str) {
let message = if *text == self.message.peek() {
format!("{text}\u{200B}")
} else {
text.to_owned()
};
self.message.set_value(message);
}
}
pub type AriaLiveRegionExtensionType =
LexicalExtension<AriaLiveRegionExtensionConfig, AriaLiveRegion, Signal<String>>;
fn make_aria_live_region_extension() -> Rc<AriaLiveRegionExtensionType> {
define_extension(LexicalExtension {
init: Some(Rc::new(
|_: &mut InitialEditorConfig,
_: &AriaLiveRegionExtensionConfig,
_: &ExtensionInitState| Ok(signal(String::new())),
)),
build: Some(Rc::new(
|_: &Editor,
config: &AriaLiveRegionExtensionConfig,
state: &ExtensionBuildState<Signal<String>>| {
Ok(AriaLiveRegion {
politeness: signal(config.politeness),
owner: signal(config.owner.clone()),
message: (*state.get_init_result()?).clone(),
})
},
)),
dependencies: vec![root_element_extension().into()],
register: Some(Rc::new(
|_: &Editor,
_: &AriaLiveRegionExtensionConfig,
state: &ExtensionRegisterState<Signal<String>, AriaLiveRegion>| {
let message = (*state.get_init_result()?).clone();
let output = state
.get_output()
.expect("AriaLiveRegionExtension has a build");
let root_element = state
.get_dependency(&root_element_extension())?
.output
.expect("RootElementExtension has a build");
let region: Signal<Option<RegionRef>> = signal(None);
let (owner, politeness) = (output.owner.clone(), output.politeness.clone());
let mounted = region.clone();
Ok(merge_register(vec![
effect(move || {
let host = match owner.value() {
Some(owner) => owner.0,
None => root_element
.value()
.and_then(|RootElementRef(root)| root.live_region_host())?,
};
let el = Rc::new(LiveRegion {
politeness: Cell::new(None),
text_content: RefCell::new(String::new()),
host: RefCell::new(Some(Rc::downgrade(&host))),
});
host.mount_live_region(&el);
mounted.set_value(Some(RegionRef(el.clone())));
let mounted = mounted.clone();
Some(Box::new(move || {
el.remove();
mounted.set_value(None);
}) as Unregister)
}),
{
let region = region.clone();
effect(move || {
if let Some(RegionRef(el)) = region.value() {
el.set_politeness(politeness.value());
}
None
})
},
effect(move || {
let text = message.value();
if let Some(RegionRef(el)) = region.peek() {
el.set_text_content(text);
}
None
}),
]))
},
)),
..LexicalExtension::new(
"@lexical/a11y/AriaLiveRegion",
AriaLiveRegionExtensionConfig::default(),
)
})
}
named_signals_config! {
pub struct HistoryAnnounceExtensionConfig;
pub struct HistoryAnnounceExtensionConfigOverrides;
pub struct HistoryAnnounceOutput {
undone: String,
redone: String,
disabled: bool,
}
}
pub type HistoryAnnounceExtensionType =
LexicalExtension<HistoryAnnounceExtensionConfig, HistoryAnnounceOutput, ()>;
fn announcer<I: 'static, O: 'static>(
state: &ExtensionRegisterState<I, O>,
) -> Result<AriaLiveRegion, LexicalError> {
Ok((*state
.get_dependency(&aria_live_region_extension())?
.output
.expect("AriaLiveRegionExtension has a build"))
.clone())
}
fn make_history_announce_extension() -> Rc<HistoryAnnounceExtensionType> {
define_extension(LexicalExtension {
build: Some(Rc::new(
|_: &Editor, config: &HistoryAnnounceExtensionConfig, _: &ExtensionBuildState<()>| {
Ok(HistoryAnnounceOutput::of(config))
},
)),
dependencies: vec![aria_live_region_extension().into()],
register: Some(Rc::new(
|editor: &Editor,
_: &HistoryAnnounceExtensionConfig,
state: &ExtensionRegisterState<(), HistoryAnnounceOutput>| {
let output = state
.get_output()
.expect("HistoryAnnounceExtension has a build");
let announcer = announcer(state)?;
let editor = editor.weak();
Ok(effect(move || {
if output.disabled.value() {
return None;
}
let editor = editor.upgrade().map(Editor)?;
let (undone, redone) = (output.undone.clone(), output.redone.clone());
let (on_undo, on_redo) = (announcer.clone(), announcer.clone());
Some(merge_register(vec![
editor.register_command(
&UNDO_COMMAND,
move |_, _| {
on_undo.announce(&undone.peek());
Ok(false)
},
COMMAND_PRIORITY_LOW,
),
editor.register_command(
&REDO_COMMAND,
move |_, _| {
on_redo.announce(&redone.peek());
Ok(false)
},
COMMAND_PRIORITY_LOW,
),
]))
}))
},
)),
..LexicalExtension::new(
"@lexical/a11y/HistoryAnnounce",
HistoryAnnounceExtensionConfig {
undone: "Undone".to_owned(),
redone: "Redone".to_owned(),
disabled: false,
},
)
})
}
named_signals_config! {
pub struct EditorModeAnnounceExtensionConfig;
pub struct EditorModeAnnounceExtensionConfigOverrides;
pub struct EditorModeAnnounceOutput {
editable: String,
read_only: String,
disabled: bool,
}
}
pub type EditorModeAnnounceExtensionType =
LexicalExtension<EditorModeAnnounceExtensionConfig, EditorModeAnnounceOutput, ()>;
fn make_editor_mode_announce_extension() -> Rc<EditorModeAnnounceExtensionType> {
define_extension(LexicalExtension {
build: Some(Rc::new(
|_: &Editor,
config: &EditorModeAnnounceExtensionConfig,
_: &ExtensionBuildState<()>| { Ok(EditorModeAnnounceOutput::of(config)) },
)),
dependencies: vec![aria_live_region_extension().into()],
register: Some(Rc::new(
|editor: &Editor,
_: &EditorModeAnnounceExtensionConfig,
state: &ExtensionRegisterState<(), EditorModeAnnounceOutput>| {
let output = state
.get_output()
.expect("EditorModeAnnounceExtension has a build");
let announcer = announcer(state)?;
let editor = editor.weak();
Ok(effect(move || {
if output.disabled.value() {
return None;
}
let editor = editor.upgrade().map(Editor)?;
let (editable, read_only) = (output.editable.clone(), output.read_only.clone());
let announcer = announcer.clone();
Some(editor.register_editable_listener(move |is_editable| {
announcer.announce(&if is_editable {
editable.peek()
} else {
read_only.peek()
});
}))
}))
},
)),
..LexicalExtension::new(
"@lexical/a11y/EditorModeAnnounce",
EditorModeAnnounceExtensionConfig {
editable: "Editor is editable".to_owned(),
read_only: "Editor is read-only".to_owned(),
disabled: false,
},
)
})
}
thread_local! {
static ARIA_LIVE_REGION_EXTENSION: Rc<AriaLiveRegionExtensionType> =
make_aria_live_region_extension();
static HISTORY_ANNOUNCE_EXTENSION: Rc<HistoryAnnounceExtensionType> =
make_history_announce_extension();
static EDITOR_MODE_ANNOUNCE_EXTENSION: Rc<EditorModeAnnounceExtensionType> =
make_editor_mode_announce_extension();
}
pub fn aria_live_region_extension() -> Rc<AriaLiveRegionExtensionType> {
ARIA_LIVE_REGION_EXTENSION.with(Rc::clone)
}
pub fn history_announce_extension() -> Rc<HistoryAnnounceExtensionType> {
HISTORY_ANNOUNCE_EXTENSION.with(Rc::clone)
}
pub fn editor_mode_announce_extension() -> Rc<EditorModeAnnounceExtensionType> {
EDITOR_MODE_ANNOUNCE_EXTENSION.with(Rc::clone)
}
#[cfg(any(feature = "rich-text", feature = "link"))]
pub(crate) fn replace_first(message: &str, value: &str) -> String {
message.replacen("%s", value, 1)
}