use crate::error::invariant;
use crate::json::Value;
use crate::lexical_selection::{PointType, SelectionRef, Which};
use crate::lexical_utils::get_root;
use crate::node::NodeRef;
use crate::node_state::{
StateConfig, StateValueConfig, create_state_with, get_state, set_state_with,
};
use crate::nodes::line_break::LineBreakNode;
use crate::schema::{SerializationSchema, SerializationSchemaMeta, array_set_value};
use crate::{LexicalError, NodeKey};
use std::cmp::Ordering;
use std::collections::HashSet;
use std::rc::Rc;
use super::is_mark_node;
#[cfg(feature = "extension")]
pub use extension::*;
pub const MARK_STATE_KEY: &str = "markIds";
pub const MARK_STATE_IDS_ATTRIBUTE: &str = "data-lexical-mark-ids";
pub(super) const MARK_STATE_EXTENSION_NAME: &str = "@lexical/mark/MarkState";
pub(super) fn is_js_whitespace(c: char) -> bool {
matches!(
c,
'\t' | '\n' | '\u{0B}' | '\u{0C}' | '\r' | ' ' | '\u{A0}' | '\u{1680}' | '\u{2000}'
..='\u{200A}'
| '\u{2028}'
| '\u{2029}'
| '\u{202F}'
| '\u{205F}'
| '\u{3000}'
| '\u{FEFF}'
)
}
pub(super) fn is_valid_mark_id(id: &str) -> bool {
!id.is_empty() && !id.chars().any(is_js_whitespace)
}
pub(super) fn js_cmp(a: &str, b: &str) -> Ordering {
a.encode_utf16().cmp(b.encode_utf16())
}
fn mark_id_value() -> SerializationSchema {
SerializationSchema::new(
SerializationSchemaMeta::String,
"".into(),
None,
Some(Rc::new(|value: &Value| {
value.as_str().is_some_and(is_valid_mark_id)
})),
|value| match value.as_str() {
Some(id) if is_valid_mark_id(id) => value.clone(),
_ => "".into(),
},
)
}
fn create_mark_ids_state(state_key: &str) -> StateConfig<Vec<String>> {
create_state_with(
state_key,
StateValueConfig::from_schema(array_set_value(mark_id_value()).expect("a set of strings")),
)
}
pub struct MarkFlavor {
name: String,
state_key: String,
attribute: String,
pub(super) state: StateConfig<Vec<String>>,
}
impl MarkFlavor {
fn new(name: &str, state_key: &str, attribute: &str) -> Self {
MarkFlavor {
name: name.to_owned(),
state_key: state_key.to_owned(),
attribute: attribute.to_owned(),
state: create_mark_ids_state(state_key),
}
}
pub fn name(&self) -> &str {
&self.name
}
pub fn state_key(&self) -> &str {
&self.state_key
}
pub fn attribute(&self) -> &str {
&self.attribute
}
}
thread_local! {
static MARK_STATE_FLAVOR: Rc<MarkFlavor> = Rc::new(MarkFlavor::new(
MARK_STATE_EXTENSION_NAME,
MARK_STATE_KEY,
MARK_STATE_IDS_ATTRIBUTE,
));
}
fn default_flavor() -> Rc<MarkFlavor> {
MARK_STATE_FLAVOR.with(Rc::clone)
}
pub fn is_inline_decorator_node(node: &NodeRef) -> bool {
node.is_decorator() && node.is_inline()
}
fn default_is_markable(node: &NodeRef) -> bool {
node.is_text() || node.get_latest().is::<LineBreakNode>() || is_inline_decorator_node(node)
}
pub(super) fn is_markable_node(flavor: &MarkFlavor, node: &NodeRef) -> bool {
#[cfg(feature = "extension")]
if let Some(is_markable) = extension::editor_is_markable(flavor) {
return is_markable(node);
}
let _ = flavor;
default_is_markable(node)
}
pub(super) fn read_node_mark_ids(
flavor: &MarkFlavor,
node: &NodeRef,
) -> Result<Vec<String>, LexicalError> {
get_state(node, &flavor.state)
}
pub(super) fn get_markable_ids(
flavor: &MarkFlavor,
node: Option<&NodeRef>,
) -> Result<Vec<String>, LexicalError> {
match node {
Some(node) if is_markable_node(flavor, node) => read_node_mark_ids(flavor, node),
_ => Ok(Vec::new()),
}
}
pub fn get_node_mark_ids(node: &NodeRef) -> Result<Vec<String>, LexicalError> {
read_node_mark_ids(&default_flavor(), node)
}
fn update_node_mark_ids(
flavor: &MarkFlavor,
node: &NodeRef,
updater: impl FnOnce(&Vec<String>) -> Vec<String>,
) -> Result<(), LexicalError> {
set_state_with(node, &flavor.state, updater).map(|_| ())
}
pub(super) fn add_node_mark_ids(
flavor: &MarkFlavor,
node: &NodeRef,
ids: &[String],
) -> Result<(), LexicalError> {
update_node_mark_ids(flavor, node, |prev| {
if ids.iter().all(|id| prev.contains(id)) {
prev.clone()
} else {
prev.iter().chain(ids).cloned().collect()
}
})
}
fn remove_node_mark_ids(
flavor: &MarkFlavor,
node: &NodeRef,
ids: &[String],
) -> Result<(), LexicalError> {
update_node_mark_ids(flavor, node, |prev| {
prev.iter()
.filter(|id| !ids.contains(id))
.cloned()
.collect()
})
}
fn assert_valid_mark_id(id: &str) -> Result<(), LexicalError> {
invariant!(
is_valid_mark_id(id),
"MarkStateExtension: invalid mark id {}, ids must be non-empty strings without whitespace",
Value::from(id)
);
Ok(())
}
fn markable_nodes_in_selection(
flavor: &MarkFlavor,
selection: &SelectionRef,
) -> Result<Vec<NodeRef>, LexicalError> {
if selection.range().is_some_and(|r| r.is_collapsed()) {
return Ok(Vec::new());
}
let mut nodes = Vec::new();
let mut seen = HashSet::new();
for node in selection.extract()? {
if is_markable_node(flavor, &node) && seen.insert(node.get_key().to_owned()) {
nodes.push(node.clone());
}
for_each_slot(&node, |slot| {
collect_markable_nodes(flavor, slot, &mut nodes, &mut seen)
});
}
Ok(nodes)
}
fn for_each_slot(node: &NodeRef, mut f: impl FnMut(&NodeRef)) {
for name in crate::slot::get_slot_names(node) {
if let Some(slot) = crate::slot::get_slot(node, &name) {
f(&slot);
}
}
}
fn add_mark_id_impl(
flavor: &MarkFlavor,
id: &str,
selection: &SelectionRef,
) -> Result<Vec<NodeRef>, LexicalError> {
assert_valid_mark_id(id)?;
let nodes = markable_nodes_in_selection(flavor, selection)?;
let ids = [id.to_owned()];
for node in &nodes {
add_node_mark_ids(flavor, node, &ids)?;
}
Ok(nodes)
}
pub fn add_mark_id(id: &str, selection: &SelectionRef) -> Result<Vec<NodeRef>, LexicalError> {
add_mark_id_impl(&default_flavor(), id, selection)
}
pub(super) fn collect_markable_nodes(
flavor: &MarkFlavor,
node: &NodeRef,
out: &mut Vec<NodeRef>,
seen: &mut HashSet<NodeKey>,
) {
if is_markable_node(flavor, node) && seen.insert(node.get_key().to_owned()) {
out.push(node.clone());
}
if node.is_element() {
let mut child = node.get_first_child();
while let Some(c) = child {
collect_markable_nodes(flavor, &c, out, seen);
child = c.get_next_sibling();
}
}
for_each_slot(node, |slot| collect_markable_nodes(flavor, slot, out, seen));
}
pub(super) fn markable_nodes_in(flavor: &MarkFlavor, node: &NodeRef) -> Vec<NodeRef> {
let mut out = Vec::new();
collect_markable_nodes(flavor, node, &mut out, &mut HashSet::new());
out
}
fn remove_mark_id_impl(
flavor: &MarkFlavor,
id: &str,
selection: Option<&SelectionRef>,
) -> Result<(), LexicalError> {
let nodes = match selection {
Some(selection) => markable_nodes_in_selection(flavor, selection)?,
None => {
#[cfg(feature = "extension")]
let candidates = extension::get_mark_id_candidates(flavor, id);
#[cfg(not(feature = "extension"))]
let candidates: Option<Vec<NodeRef>> = None;
candidates.unwrap_or_else(|| markable_nodes_in(flavor, &get_root()))
}
};
let ids = [id.to_owned()];
for node in &nodes {
remove_node_mark_ids(flavor, node, &ids)?;
}
#[cfg(feature = "extension")]
extension::record_removed(flavor, id);
Ok(())
}
pub fn remove_mark_id(id: &str, selection: Option<&SelectionRef>) -> Result<(), LexicalError> {
remove_mark_id_impl(&default_flavor(), id, selection)
}
pub(super) fn get_adjacent_leaf(node: &NodeRef, previous: bool) -> Option<NodeRef> {
let mut current = node.clone();
loop {
let sibling = if previous {
current.get_previous_sibling()
} else {
current.get_next_sibling()
};
let Some(sibling) = sibling else {
let parent = current.get_parent()?;
if parent.is_element() && parent.is_inline() {
current = parent;
continue;
}
return None;
};
let mut leaf = sibling;
while leaf.is_element() && leaf.is_inline() {
let child = if previous {
leaf.get_last_child()
} else {
leaf.get_first_child()
};
match child {
Some(child) => leaf = child,
None => break,
}
}
return Some(leaf);
}
}
fn get_point_mark_ids(
flavor: &MarkFlavor,
selection: &SelectionRef,
which: Which,
) -> Result<Vec<String>, LexicalError> {
let point = selection.point(which).expect("a range selection");
let node = point.get_node()?;
if point.point_type == PointType::Text {
let ids = read_node_mark_ids(flavor, &node)?;
if ids.is_empty() && node.is_text() && point.offset == node.get_text_content_size() {
return get_markable_ids(flavor, get_adjacent_leaf(&node, false).as_ref());
}
return Ok(ids);
}
if node.is_element() {
let before = get_markable_ids(
flavor,
point
.offset
.checked_sub(1)
.and_then(|i| node.get_child_at_index(i))
.as_ref(),
)?;
return if before.is_empty() {
get_markable_ids(flavor, node.get_child_at_index(point.offset).as_ref())
} else {
Ok(before)
};
}
Ok(Vec::new())
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum MarkIDsMode {
#[default]
Any,
All,
}
fn get_mark_ids_at_selection_impl(
flavor: &MarkFlavor,
selection: Option<&SelectionRef>,
mode: MarkIDsMode,
) -> Result<Vec<String>, LexicalError> {
let Some(selection) = selection else {
return Ok(Vec::new());
};
let range = selection.range();
if range.as_ref().is_some_and(|r| r.is_collapsed()) {
return get_point_mark_ids(flavor, selection, Which::Anchor);
}
let mut leaves: Vec<NodeRef> = selection
.get_nodes()?
.into_iter()
.filter(|node| is_markable_node(flavor, node))
.collect();
if let Some(range) = range {
let (start, end) = if selection.is_backward()? {
(&range.focus, &range.anchor)
} else {
(&range.anchor, &range.focus)
};
leaves.retain(|node| {
if !node.is_text() {
return true;
}
let key = node.get_key();
let from = if start.point_type == PointType::Text && start.key == key {
start.offset
} else {
0
};
let to = if end.point_type == PointType::Text && end.key == key {
end.offset
} else {
node.get_text_content_size()
};
to > from
});
}
if leaves.is_empty() {
return Ok(Vec::new());
}
let id_sets = leaves
.iter()
.map(|node| read_node_mark_ids(flavor, node))
.collect::<Result<Vec<_>, _>>()?;
Ok(match mode {
MarkIDsMode::Any => {
let mut ids: Vec<String> = id_sets.into_iter().flatten().collect();
ids.sort_by(|a, b| js_cmp(a, b));
ids.dedup();
ids
}
MarkIDsMode::All => id_sets[0]
.iter()
.filter(|id| id_sets.iter().all(|ids| ids.contains(id)))
.cloned()
.collect(),
})
}
pub fn get_mark_ids_at_selection(
selection: Option<&SelectionRef>,
mode: MarkIDsMode,
) -> Result<Vec<String>, LexicalError> {
get_mark_ids_at_selection_impl(&default_flavor(), selection, mode)
}
fn migrate_mark_nodes_to_mark_state_impl(
flavor: &MarkFlavor,
node: Option<&NodeRef>,
) -> Result<usize, LexicalError> {
fn visit(
flavor: &MarkFlavor,
current: &NodeRef,
inherited: &[String],
count: &mut usize,
) -> Result<(), LexicalError> {
if is_mark_node(current) {
let own_ids = current.get_ids().unwrap_or_default();
for id in &own_ids {
assert_valid_mark_id(id)?;
}
let mut ids: Vec<String> = Vec::new();
for id in inherited.iter().chain(&own_ids) {
if !ids.contains(id) {
ids.push(id.clone());
}
}
for child in current.get_children() {
visit(flavor, &child, &ids, count)?;
}
for child in current.get_children() {
current.insert_before(&child, true)?;
}
current.remove(false)?;
*count += 1;
} else {
if is_markable_node(flavor, current) && !inherited.is_empty() {
add_node_mark_ids(flavor, current, inherited)?;
}
if current.is_element() {
for child in current.get_children() {
visit(flavor, &child, inherited, count)?;
}
}
for name in crate::slot::get_slot_names(current) {
if let Some(slot) = crate::slot::get_slot(current, &name) {
visit(flavor, &slot, inherited, count)?;
}
}
}
Ok(())
}
let node = node.cloned().unwrap_or_else(get_root);
let mut count = 0;
visit(flavor, &node, &[], &mut count)?;
Ok(count)
}
pub fn migrate_mark_nodes_to_mark_state(node: Option<&NodeRef>) -> Result<usize, LexicalError> {
migrate_mark_nodes_to_mark_state_impl(&default_flavor(), node)
}
#[cfg(all(feature = "extension", feature = "html"))]
fn split_on_whitespace(value: &str) -> impl Iterator<Item = &str> {
value.split(is_js_whitespace).filter(|s| !s.is_empty())
}
#[cfg(feature = "extension")]
mod extension {
use super::super::mark_state_inserted_text::{
PendingEdits, SplitOrigins, apply_inserted_text_mark_ids, get_block,
get_composition_replaced_range, get_replaced_range,
};
use super::*;
use crate::commands::{
COMPOSITION_START_COMMAND, CONTROLLED_TEXT_INSERTION_COMMAND, PASTE_COMMAND,
};
use crate::editor::{
COLLABORATION_TAG, COMMAND_PRIORITY_CRITICAL, COMPOSITION_START_TAG, DirtyType,
HISTORIC_TAG, UpdateListenerPayload, has_update_tag,
};
use crate::extension::get_peer_dependency_from_editor;
use crate::extension::signals::{ReadonlySignal, Signal, effect, signal};
use crate::extension_core::{
ExtensionBuildState, ExtensionConfigBase, ExtensionInitState, ExtensionRegisterState,
InitialEditorConfig, LexicalExtension, LexicalExtensionDependency, define_extension,
};
use crate::lexical_selection::{Point, get_selection};
use crate::lexical_utils::get_node_by_key;
use crate::merge_register::merge_register;
use crate::ordered::{OrderedMap, OrderedSet};
use crate::updates::{get_active_editor, read_editor_state};
use crate::{Editor, EditorState, Unregister};
use std::cell::{Cell, OnceCell, RefCell};
use std::collections::HashMap;
use std::rc::Weak;
#[derive(Clone)]
pub struct MarkableNodeMatch(pub Rc<dyn Fn(&NodeRef) -> bool>);
impl MarkableNodeMatch {
pub fn new(guard: impl Fn(&NodeRef) -> bool + 'static) -> Self {
MarkableNodeMatch(Rc::new(guard))
}
}
pub fn default_markable_nodes() -> Vec<MarkableNodeMatch> {
vec![
MarkableNodeMatch::new(NodeRef::is_text),
MarkableNodeMatch::new(|node| node.get_latest().is::<LineBreakNode>()),
MarkableNodeMatch::new(is_inline_decorator_node),
]
}
fn compile_markable_nodes(matches: &[MarkableNodeMatch]) -> IsMarkable {
let guards: Vec<_> = matches.iter().map(|m| m.0.clone()).collect();
Rc::new(move |node| guards.iter().any(|guard| guard(node)))
}
type IsMarkable = Rc<dyn Fn(&NodeRef) -> bool>;
#[derive(Clone)]
pub struct MarkStateConfig {
pub disabled: bool,
pub export_ids_to_html: bool,
pub markable_nodes: Vec<MarkableNodeMatch>,
pub(crate) flavor: Rc<MarkFlavor>,
}
#[derive(Clone, Default)]
pub struct MarkStateConfigOverrides {
pub disabled: Option<bool>,
pub export_ids_to_html: Option<bool>,
pub markable_nodes: Option<Vec<MarkableNodeMatch>>,
}
impl ExtensionConfigBase for MarkStateConfig {
type Partial = MarkStateConfigOverrides;
fn shallow_merge(&self, overrides: &MarkStateConfigOverrides) -> Self {
MarkStateConfig {
disabled: overrides.disabled.unwrap_or(self.disabled),
export_ids_to_html: overrides
.export_ids_to_html
.unwrap_or(self.export_ids_to_html),
markable_nodes: overrides
.markable_nodes
.clone()
.unwrap_or_else(|| self.markable_nodes.clone()),
flavor: self.flavor.clone(),
}
}
}
#[derive(Clone, Default)]
pub struct MarkIDNodeKeys(Rc<Vec<(String, Vec<NodeKey>)>>);
impl PartialEq for MarkIDNodeKeys {
fn eq(&self, other: &Self) -> bool {
Rc::ptr_eq(&self.0, &other.0)
}
}
impl MarkIDNodeKeys {
pub fn get(&self, id: &str) -> Option<&[NodeKey]> {
self.0
.iter()
.find(|(i, _)| i == id)
.map(|(_, keys)| keys.as_slice())
}
pub fn ids(&self) -> impl Iterator<Item = &str> {
self.0.iter().map(|(id, _)| id.as_str())
}
pub fn iter(&self) -> impl Iterator<Item = (&str, &[NodeKey])> {
self.0
.iter()
.map(|(id, keys)| (id.as_str(), keys.as_slice()))
}
pub fn len(&self) -> usize {
self.0.len()
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
}
#[derive(Clone)]
pub struct MarkStateOutput {
pub disabled: Signal<bool>,
pub export_ids_to_html: Signal<bool>,
pub mark_id_node_keys: ReadonlySignal<MarkIDNodeKeys>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct MarkIDsChange {
pub added: Vec<String>,
pub ids: Vec<String>,
pub removed: Vec<String>,
pub tags: Vec<String>,
}
pub type MarkIDsListener = Rc<dyn Fn(&MarkIDsChange)>;
struct ListenerEntry {
listener: MarkIDsListener,
reported: RefCell<Vec<String>>,
}
pub struct MarkStateInit {
mark_id_node_keys: Signal<MarkIDNodeKeys>,
listeners: RefCell<Vec<Rc<ListenerEntry>>>,
is_markable: RefCell<Option<IsMarkable>>,
edit: RefCell<Option<Rc<PendingEdits>>>,
}
impl MarkStateInit {
fn new() -> Self {
MarkStateInit {
mark_id_node_keys: signal(MarkIDNodeKeys::default()),
listeners: RefCell::default(),
is_markable: RefCell::default(),
edit: RefCell::default(),
}
}
}
pub type MarkFlavorExtension =
Rc<LexicalExtension<MarkStateConfig, MarkStateOutput, MarkStateInit>>;
pub fn mark_flavor(extension: &MarkFlavorExtension) -> &Rc<MarkFlavor> {
&extension.config.flavor
}
type FlavorDependency =
LexicalExtensionDependency<MarkStateConfig, MarkStateOutput, MarkStateInit>;
fn flavor_dependency(flavor: &MarkFlavor, editor: &Editor) -> Option<FlavorDependency> {
get_peer_dependency_from_editor(editor, &flavor.name)
.ok()
.flatten()
}
pub(super) fn editor_is_markable(flavor: &MarkFlavor) -> Option<IsMarkable> {
let editor = get_active_editor()?;
let dep = flavor_dependency(flavor, &editor)?;
dep.init?.is_markable.borrow().clone()
}
fn editor_edit(flavor: &MarkFlavor, editor: &Editor) -> Option<Rc<PendingEdits>> {
flavor_dependency(flavor, editor)?
.init?
.edit
.borrow()
.clone()
}
pub(super) fn record_removed(flavor: &MarkFlavor, id: &str) {
if let Some(editor) = get_active_editor()
&& let Some(edit) = editor_edit(flavor, &editor)
{
edit.record(&editor, |edit| {
edit.add_removed(id);
});
}
}
pub(super) fn get_mark_id_candidates(flavor: &MarkFlavor, id: &str) -> Option<Vec<NodeRef>> {
let editor = get_active_editor()?;
let output = flavor_dependency(flavor, &editor)?.output?;
if output.disabled.peek() {
return None;
}
let mut keys = OrderedSet::new();
if let Some(known) = output.mark_id_node_keys.peek().get(id) {
for key in known {
keys.add(key);
}
}
for key in editor.0.dirty.borrow().leaves.iter() {
keys.add(key);
}
Some(
keys.iter()
.filter_map(get_node_by_key)
.filter(|node| is_markable_node(flavor, node) && node.is_attached())
.collect(),
)
}
pub fn get_node_mark_ids_for(
flavor: &MarkFlavorExtension,
node: &NodeRef,
) -> Result<Vec<String>, LexicalError> {
read_node_mark_ids(mark_flavor(flavor), node)
}
pub fn add_mark_id_for(
flavor: &MarkFlavorExtension,
id: &str,
selection: &SelectionRef,
) -> Result<Vec<NodeRef>, LexicalError> {
add_mark_id_impl(mark_flavor(flavor), id, selection)
}
pub fn remove_mark_id_for(
flavor: &MarkFlavorExtension,
id: &str,
selection: Option<&SelectionRef>,
) -> Result<(), LexicalError> {
remove_mark_id_impl(mark_flavor(flavor), id, selection)
}
pub fn get_mark_ids_at_selection_for(
flavor: &MarkFlavorExtension,
selection: Option<&SelectionRef>,
mode: MarkIDsMode,
) -> Result<Vec<String>, LexicalError> {
get_mark_ids_at_selection_impl(mark_flavor(flavor), selection, mode)
}
pub fn migrate_mark_nodes_to_mark_state_for(
flavor: &MarkFlavorExtension,
node: Option<&NodeRef>,
) -> Result<usize, LexicalError> {
migrate_mark_nodes_to_mark_state_impl(mark_flavor(flavor), node)
}
pub fn get_mark_ids_by_flavor(
node: &NodeRef,
) -> Result<Vec<(String, Vec<String>)>, LexicalError> {
let mut out = Vec::new();
let Some(editor) = get_active_editor() else {
return Ok(out);
};
if let Some(base) = get_peer_dependency_from_editor::<(), MarkBaseOutput, MarkBaseInit>(
&editor,
MARK_BASE_EXTENSION_NAME,
)?
.and_then(|dep| dep.output)
{
for (state_key, extension) in base.flavors() {
out.push((
state_key,
get_markable_ids(mark_flavor(&extension), Some(node))?,
));
}
}
Ok(out)
}
fn report_mark_ids(init: &MarkStateInit, tags: &[String]) {
let entries = init.listeners.borrow().clone();
if entries.is_empty() {
return;
}
let ids: Vec<String> = init
.mark_id_node_keys
.peek()
.ids()
.map(str::to_owned)
.collect();
for entry in entries {
let prev = entry.reported.borrow().clone();
let added: Vec<String> = ids
.iter()
.filter(|id| !prev.contains(id))
.cloned()
.collect();
let removed: Vec<String> = prev
.iter()
.filter(|id| !ids.contains(id))
.cloned()
.collect();
let registered = init
.listeners
.borrow()
.iter()
.any(|e| Rc::ptr_eq(e, &entry));
if (!added.is_empty() || !removed.is_empty()) && registered {
*entry.reported.borrow_mut() = ids.clone();
(entry.listener)(&MarkIDsChange {
added,
ids: ids.clone(),
removed,
tags: tags.to_vec(),
});
}
}
}
pub fn register_mark_ids_listener(
editor: &Editor,
flavor: &MarkFlavorExtension,
listener: impl Fn(&MarkIDsChange) + 'static,
) -> Result<Unregister, LexicalError> {
let dep = flavor_dependency(mark_flavor(flavor), editor);
let (Some(init), Some(output)) = (
dep.as_ref().and_then(|d| d.init.clone()),
dep.and_then(|d| d.output),
) else {
return Err(LexicalError::new(format!(
"registerMarkIDsListener: the editor was not built with {}. Add it to the dependencies of the extension the editor is built from.",
flavor.name
)));
};
let ids: Vec<String> = if output.disabled.peek() {
Vec::new()
} else {
output
.mark_id_node_keys
.peek()
.ids()
.map(str::to_owned)
.collect()
};
if !ids.is_empty() {
listener(&MarkIDsChange {
added: ids.clone(),
ids: ids.clone(),
removed: Vec::new(),
tags: Vec::new(),
});
}
let entry = Rc::new(ListenerEntry {
listener: Rc::new(listener),
reported: RefCell::new(ids),
});
init.listeners.borrow_mut().push(entry.clone());
let init = Rc::downgrade(&init);
Ok(Box::new(move || {
if let Some(init) = init.upgrade() {
init.listeners
.borrow_mut()
.retain(|e| !Rc::ptr_eq(e, &entry));
}
}))
}
fn register_mark_ids_state(flavor: &MarkFlavor, editor: &Editor) {
for node_type in editor.registered_nodes().keys() {
if let Some(shared) = editor.shared_node_state(node_type) {
shared
.shared_config_map
.borrow_mut()
.entry(flavor.state_key.clone())
.or_insert_with(|| flavor.state.erased());
}
}
}
struct MarkStateRegistration {
flavor: Rc<MarkFlavor>,
init: Rc<MarkStateInit>,
splits: Rc<SplitOrigins>,
edit: Rc<PendingEdits>,
ids_by_key: RefCell<HashMap<NodeKey, Vec<String>>>,
keys_by_id: RefCell<OrderedMap<OrderedSet>>,
changed: Cell<bool>,
replaced_state: Cell<bool>,
composition_base: RefCell<Option<EditorState>>,
composition_tainted: Cell<bool>,
composition_replaced: RefCell<Option<(Point, Point)>>,
disposed: Cell<bool>,
}
impl MarkStateRegistration {
fn set_key(&self, key: &str, ids: Vec<String>) {
let mut ids_by_key = self.ids_by_key.borrow_mut();
let prev = ids_by_key.get(key).cloned().unwrap_or_default();
if self.flavor.state.is_equal(&prev, &ids) {
return;
}
self.changed.set(true);
let mut keys_by_id = self.keys_by_id.borrow_mut();
for id in &prev {
if !ids.contains(id)
&& let Some(keys) = keys_by_id.get_mut(id)
{
keys.delete(key);
if keys.is_empty() {
keys_by_id.delete(id);
}
}
}
for id in &ids {
if keys_by_id.get(id).is_none() {
keys_by_id.set(id, OrderedSet::new());
}
keys_by_id.get_mut(id).expect("just set").add(key);
}
if ids.is_empty() {
ids_by_key.remove(key);
} else {
ids_by_key.insert(key.to_owned(), ids);
}
}
fn visit(&self, key: &str) -> Result<(), LexicalError> {
let node = get_node_by_key(key);
self.set_key(key, get_markable_ids(&self.flavor, node.as_ref())?);
Ok(())
}
fn rescan(&self) -> Result<(), LexicalError> {
let mut seen = HashSet::new();
for leaf in markable_nodes_in(&self.flavor, &get_root()) {
seen.insert(leaf.get_key().to_owned());
self.set_key(leaf.get_key(), read_node_mark_ids(&self.flavor, &leaf)?);
}
let keys: Vec<NodeKey> = self.ids_by_key.borrow().keys().cloned().collect();
for key in keys {
if !seen.contains(&key) {
self.set_key(&key, Vec::new());
}
}
Ok(())
}
fn rescan_changed(
&self,
editor: &Editor,
prev_state: &EditorState,
next_state: &EditorState,
) -> Result<(), LexicalError> {
let changed: Vec<NodeKey> = {
let prev_nodes = prev_state.0.node_map.borrow();
next_state
.0
.node_map
.borrow()
.iter()
.filter(|(key, node)| {
prev_nodes
.get(key.as_str())
.is_none_or(|prev| !Rc::ptr_eq(prev, node))
})
.map(|(key, _)| key.clone())
.collect()
};
read_editor_state(Some(editor), next_state, || {
for key in &changed {
let node = NodeRef::new(key.clone());
let ids = if is_markable_node(&self.flavor, &node) && node.is_attached() {
read_node_mark_ids(&self.flavor, &node)?
} else {
Vec::new()
};
self.set_key(key, ids);
}
Ok::<_, LexicalError>(())
})?;
let gone: Vec<NodeKey> = {
let next_nodes = next_state.0.node_map.borrow();
self.ids_by_key
.borrow()
.keys()
.filter(|key| !next_nodes.contains_key(key.as_str()))
.cloned()
.collect()
};
for key in gone {
self.set_key(&key, Vec::new());
}
Ok(())
}
fn publish(&self, tags: &[String]) {
if self.changed.replace(false) {
let next: Vec<(String, Vec<NodeKey>)> = self
.keys_by_id
.borrow()
.iter()
.map(|(id, keys)| (id.to_owned(), keys.iter().map(str::to_owned).collect()))
.collect();
self.init
.mark_id_node_keys
.set_value(MarkIDNodeKeys(Rc::new(next)));
report_mark_ids(&self.init, tags);
}
}
fn on_update(
&self,
editor: &Editor,
payload: &UpdateListenerPayload,
) -> Result<(), LexicalError> {
if self.disposed.get() {
return Ok(());
}
let UpdateListenerPayload {
dirty_elements,
dirty_leaves,
tags,
editor_state,
prev_editor_state,
..
} = payload;
self.edit.forget();
self.splits.clear();
let has_tag = |tag: &str| tags.iter().any(|t| t == tag);
let base = self.composition_base.borrow().clone();
if let Some(base) = base {
if !editor.is_composing() {
*self.composition_base.borrow_mut() = None;
self.composition_tainted.set(false);
*self.composition_replaced.borrow_mut() = None;
} else if has_tag(COMPOSITION_START_TAG) {
let replaced = get_composition_replaced_range(editor, &base, editor_state)?;
*self.composition_replaced.borrow_mut() = replaced;
} else if !self.composition_tainted.get() && has_tag(COLLABORATION_TAG) {
let tainted = read_editor_state(Some(editor), editor_state, || {
let composing = editor
.composition_key()
.and_then(|key| get_node_by_key(&key))
.and_then(|node| get_block(&node));
composing.is_none_or(|block| {
dirty_elements.iter().any(|(k, _)| k == block.get_key())
})
});
self.composition_tainted.set(tainted);
}
}
if self.replaced_state.get()
|| has_tag(HISTORIC_TAG)
|| (dirty_leaves.is_empty()
&& dirty_elements.len() == 1
&& dirty_elements[0].0 == "root")
{
self.replaced_state.set(false);
self.rescan_changed(editor, prev_editor_state, editor_state)?;
self.publish(tags);
return Ok(());
}
if dirty_leaves.is_empty() && dirty_elements.is_empty() {
return Ok(());
}
let mut removed: Vec<NodeKey> = Vec::new();
read_editor_state(Some(editor), editor_state, || {
for key in dirty_leaves {
self.visit(key)?;
if get_node_by_key(key).is_none() {
removed.push(key.clone());
}
}
for (key, _) in dirty_elements {
match get_node_by_key(key) {
None => removed.push(key.clone()),
Some(node) if is_markable_node(&self.flavor, &node) => {
self.set_key(key, read_node_mark_ids(&self.flavor, &node)?)
}
Some(_) => {}
}
}
Ok::<_, LexicalError>(())
})?;
if !removed.is_empty() {
let gone: Vec<NodeKey> = read_editor_state(Some(editor), prev_editor_state, || {
removed
.iter()
.filter_map(|key| get_node_by_key(key))
.flat_map(|node| markable_nodes_in(&self.flavor, &node))
.map(|leaf| leaf.get_key().to_owned())
.collect()
});
read_editor_state(Some(editor), editor_state, || {
for key in &gone {
if get_node_by_key(key).is_none() {
self.set_key(key, Vec::new());
}
}
});
}
self.publish(tags);
Ok(())
}
fn on_root_transform(&self, editor: &Editor) -> Result<(), LexicalError> {
if self.disposed.get() {
return Ok(());
}
if editor.dirty_type() == DirtyType::FullReconcile {
self.replaced_state.set(true);
return Ok(());
}
if editor.is_composing()
|| has_update_tag(COLLABORATION_TAG)
|| has_update_tag(HISTORIC_TAG)
{
return Ok(());
}
self.edit.refresh(editor);
let removed: Vec<String> = self.edit.removed.borrow().iter().cloned().collect();
let base = self.composition_base.borrow().clone();
if let Some(base) = base {
if !self.composition_tainted.get() {
let composition_replaced = self.composition_replaced.borrow().clone();
let replaced_for_sure = composition_replaced.is_some();
let replaced = match composition_replaced {
Some(replaced) => Some(replaced),
None => read_editor_state(Some(editor), &base, || {
get_replaced_range(get_selection().as_ref())
})?,
};
apply_inserted_text_mark_ids(
&self.flavor,
editor,
&base,
replaced.as_ref(),
&removed,
&self.splits,
replaced_for_sure,
)?;
}
return Ok(());
}
let replaced = self.edit.replaced.borrow().clone();
apply_inserted_text_mark_ids(
&self.flavor,
editor,
&editor.get_editor_state(),
replaced.as_ref(),
&removed,
&self.splits,
false,
)
}
}
fn register_mark_state(
flavor: &Rc<MarkFlavor>,
editor: &Editor,
init: &Rc<MarkStateInit>,
splits: &Rc<SplitOrigins>,
) -> Unregister {
let edit = Rc::new(PendingEdits::default());
*init.edit.borrow_mut() = Some(edit.clone());
let reg = Rc::new(MarkStateRegistration {
flavor: flavor.clone(),
init: init.clone(),
splits: splits.clone(),
edit: edit.clone(),
ids_by_key: RefCell::default(),
keys_by_id: RefCell::default(),
changed: Cell::new(false),
replaced_state: Cell::new(false),
composition_base: RefCell::new(None),
composition_tainted: Cell::new(false),
composition_replaced: RefCell::new(None),
disposed: Cell::new(false),
});
let _ = read_editor_state(Some(editor), &editor.get_editor_state(), || reg.rescan());
reg.publish(&[]);
report_mark_ids(init, &[]);
let weak = editor.weak();
let upgrade = move |weak: &Weak<_>| weak.upgrade().map(Editor);
let record_replaced = {
let (edit, weak) = (edit.clone(), weak.clone());
move || -> Result<bool, LexicalError> {
if let Some(editor) = upgrade(&weak) {
let replaced = get_replaced_range(get_selection().as_ref())?;
edit.record(&editor, |edit| *edit.replaced.borrow_mut() = replaced);
}
Ok(false)
}
};
let record_paste = record_replaced.clone();
merge_register(vec![
{
let (reg, weak) = (reg.clone(), weak.clone());
editor.register_update_listener(move |payload| {
if let Some(editor) = upgrade(&weak) {
let _ = reg.on_update(&editor, payload);
}
})
},
{
let (reg, weak) = (reg.clone(), weak.clone());
editor.register_node_transform("root", move |_| match upgrade(&weak) {
Some(editor) => reg.on_root_transform(&editor),
None => Ok(()),
})
},
{
let (reg, weak) = (reg.clone(), weak.clone());
editor.register_command(
&COMPOSITION_START_COMMAND,
move |_, _| {
if let Some(editor) = upgrade(&weak) {
*reg.composition_base.borrow_mut() = Some(editor.get_editor_state());
}
reg.composition_tainted.set(false);
*reg.composition_replaced.borrow_mut() = None;
Ok(false)
},
COMMAND_PRIORITY_CRITICAL,
)
},
editor.register_command(
&CONTROLLED_TEXT_INSERTION_COMMAND,
move |_, _| record_replaced(),
COMMAND_PRIORITY_CRITICAL,
),
editor.register_command(
&PASTE_COMMAND,
move |_, _| record_paste(),
COMMAND_PRIORITY_CRITICAL,
),
{
let init = init.clone();
Box::new(move || {
reg.disposed.set(true);
*reg.composition_base.borrow_mut() = None;
*reg.composition_replaced.borrow_mut() = None;
edit.forget();
let mut current = init.edit.borrow_mut();
if current.as_ref().is_some_and(|e| Rc::ptr_eq(e, &edit)) {
*current = None;
}
drop(current);
init.mark_id_node_keys.set_value(MarkIDNodeKeys::default());
})
},
])
}
const MARK_BASE_EXTENSION_NAME: &str = "@lexical/mark/MarkBase";
#[derive(Default)]
pub struct MarkBaseInit {
flavors: Rc<RefCell<Vec<(String, MarkFlavorExtension)>>>,
splits: Rc<SplitOrigins>,
}
#[derive(Clone)]
pub struct MarkBaseOutput {
flavors: Rc<RefCell<Vec<(String, MarkFlavorExtension)>>>,
}
impl MarkBaseOutput {
pub fn flavors(&self) -> Vec<(String, MarkFlavorExtension)> {
self.flavors.borrow().clone()
}
}
pub type MarkBaseExtensionType = LexicalExtension<(), MarkBaseOutput, MarkBaseInit>;
fn make_mark_base() -> Rc<MarkBaseExtensionType> {
define_extension(LexicalExtension {
build: Some(Rc::new(
|_: &Editor, _: &(), state: &ExtensionBuildState<MarkBaseInit>| {
Ok(MarkBaseOutput {
flavors: state.get_init_result()?.flavors.clone(),
})
},
)),
init: Some(Rc::new(
|_: &mut InitialEditorConfig, _: &(), _: &ExtensionInitState| {
Ok(MarkBaseInit::default())
},
)),
register: Some(Rc::new(
|editor: &Editor,
_: &(),
state: &ExtensionRegisterState<MarkBaseInit, MarkBaseOutput>| {
let splits = state.get_init_result()?.splits.clone();
let on_dispose = splits.clone();
Ok(merge_register(vec![
editor.register_update_listener(move |_| splits.clear()),
Box::new(move || on_dispose.clear()),
]))
},
)),
..LexicalExtension::new(MARK_BASE_EXTENSION_NAME, ())
})
}
fn create_mark_flavor_extension(
flavor: Rc<MarkFlavor>,
config_defaults: &MarkStateConfigOverrides,
) -> MarkFlavorExtension {
let name = flavor.name.clone();
let this: Rc<OnceCell<Weak<_>>> = Rc::default();
let config = MarkStateConfig {
disabled: false,
export_ids_to_html: false,
markable_nodes: default_markable_nodes(),
flavor: flavor.clone(),
}
.shallow_merge(config_defaults);
let this_in_build = this.clone();
#[cfg_attr(not(feature = "html"), allow(unused_mut))]
let mut dependencies = vec![mark_base_extension().into()];
#[cfg(feature = "html")]
dependencies.splice(0..0, html::dependencies(&flavor));
let extension = define_extension(LexicalExtension {
dependencies,
init: Some(Rc::new(
|_: &mut InitialEditorConfig, _: &MarkStateConfig, _: &ExtensionInitState| {
Ok(MarkStateInit::new())
},
)),
build: Some(Rc::new(
move |editor: &Editor,
config: &MarkStateConfig,
state: &ExtensionBuildState<MarkStateInit>| {
let base = state
.get_dependency(&mark_base_extension())?
.init
.expect("MarkBaseExtension has an init");
let flavor = &config.flavor;
for (_, other) in base.flavors.borrow().iter() {
let other = mark_flavor(other);
invariant!(
other.state_key != flavor.state_key,
"MarkBaseExtension: {} and {} both use stateKey {}. Give each flavor its own stateKey.",
other.name,
flavor.name,
Value::from(flavor.state_key.as_str())
);
invariant!(
other.attribute != flavor.attribute,
"MarkBaseExtension: {} and {} both render the attribute {}. Give each flavor its own attribute.",
other.name,
flavor.name,
flavor.attribute
);
}
if let Some(extension) = this_in_build.get().and_then(Weak::upgrade) {
base.flavors
.borrow_mut()
.push((flavor.state_key.clone(), extension));
}
let init = state.get_init_result()?;
*init.is_markable.borrow_mut() =
Some(compile_markable_nodes(&config.markable_nodes));
register_mark_ids_state(flavor, editor);
Ok(MarkStateOutput {
disabled: signal(config.disabled),
export_ids_to_html: signal(config.export_ids_to_html),
mark_id_node_keys: init.mark_id_node_keys.as_readonly(),
})
},
)),
register: Some(Rc::new(
|editor: &Editor,
config: &MarkStateConfig,
state: &ExtensionRegisterState<MarkStateInit, MarkStateOutput>| {
let disabled = state
.get_output()
.expect("a mark flavor has a build")
.disabled
.clone();
let init = state.get_init_result()?;
let splits = state
.get_dependency(&mark_base_extension())?
.init
.expect("MarkBaseExtension has an init")
.splits
.clone();
let flavor = config.flavor.clone();
let weak = editor.weak();
Ok(effect(move || {
if disabled.value() {
return None;
}
let editor = weak.upgrade().map(Editor)?;
Some(register_mark_state(&flavor, &editor, &init, &splits))
}))
},
)),
..LexicalExtension::new(name, config)
});
let _ = this.set(Rc::downgrade(&extension));
extension
}
#[derive(Clone, Default)]
pub struct MarkFlavorDefinition {
pub name: String,
pub state_key: String,
pub attribute: Option<String>,
pub class_name: Option<String>,
pub overlap_class_name: Option<String>,
pub config: MarkStateConfigOverrides,
}
fn default_mark_attribute(state_key: &str) -> String {
let mut attribute = String::from("data-lexical-");
for c in state_key.chars() {
if c.is_ascii_uppercase() {
attribute.push('-');
attribute.push(c.to_ascii_lowercase());
} else {
attribute.push(c);
}
}
attribute
}
pub fn define_mark_extension(
definition: &MarkFlavorDefinition,
) -> Result<MarkFlavorExtension, LexicalError> {
let MarkFlavorDefinition {
name, state_key, ..
} = definition;
invariant!(
is_valid_mark_id(state_key) && state_key != MARK_STATE_KEY && state_key != "__proto__",
"defineMarkExtension: invalid stateKey {} for {}. Use a non-empty name without whitespace, other than \"markIds\" (the key of MarkStateExtension) and \"__proto__\", such as \"commentIds\".",
Value::from(state_key.as_str()),
name
);
let attribute = definition
.attribute
.clone()
.filter(|a| !a.is_empty())
.unwrap_or_else(|| default_mark_attribute(state_key))
.to_lowercase();
Ok(create_mark_flavor_extension(
Rc::new(MarkFlavor::new(name, state_key, &attribute)),
&definition.config,
))
}
thread_local! {
static MARK_BASE_EXTENSION: Rc<MarkBaseExtensionType> = make_mark_base();
static MARK_STATE_EXTENSION: MarkFlavorExtension = create_mark_flavor_extension(
default_flavor(),
&MarkStateConfigOverrides::default(),
);
}
pub fn mark_base_extension() -> Rc<MarkBaseExtensionType> {
MARK_BASE_EXTENSION.with(Rc::clone)
}
pub fn mark_state_extension() -> MarkFlavorExtension {
MARK_STATE_EXTENSION.with(Rc::clone)
}
#[cfg(feature = "html")]
mod html {
use super::*;
use crate::extension_core::{AnyLexicalExtensionArgument, config_extension};
use crate::html::import::{
DomImportConfigOverrides, define_import_rule, dom_import_extension, sel, sel::AttrMatch,
};
use crate::html::{
DomOverrideOptions, DomRenderConfigOverrides, DomRenderMatchConfig, NodeMatch,
dom_override, dom_render_extension,
};
fn create_mark_ids_import_rule(
flavor: &Rc<MarkFlavor>,
) -> crate::html::import::DomImportRule {
let f = flavor.clone();
define_import_rule(
Some(&format!("{}/ids", flavor.name)),
sel::any().attr(&flavor.attribute, AttrMatch::Present),
move |_, el, next| {
let nodes = next()?;
let value = el.get_attribute(&f.attribute).unwrap_or_default();
let ids: Vec<String> = split_on_whitespace(&value)
.filter(|id| is_valid_mark_id(id))
.map(str::to_owned)
.collect();
if !ids.is_empty() {
let mut leaves = Vec::new();
let mut seen = HashSet::new();
for node in &nodes {
collect_markable_nodes(&f, node, &mut leaves, &mut seen);
}
for leaf in &leaves {
add_node_mark_ids(&f, leaf, &ids)?;
}
}
Ok(nodes)
},
)
}
pub(super) fn dependencies(flavor: &Rc<MarkFlavor>) -> Vec<AnyLexicalExtensionArgument> {
let (f, g) = (flavor.clone(), flavor.clone());
let export = dom_override(
Some(vec![NodeMatch::predicate(move |_, node| {
is_markable_node(&f, node)
})]),
DomRenderMatchConfig {
export_dom: Some(Rc::new(move |_, node, next, editor| {
let output = next()?;
let export = flavor_dependency(&g, editor)
.and_then(|dep| dep.output)
.is_some_and(|output| output.export_ids_to_html.peek());
if !export {
return Ok(output);
}
let ids = read_node_mark_ids(&g, node)?;
if !ids.is_empty()
&& let Some(element) =
output.element.as_ref().filter(|e| e.is_element())
{
element.set_attribute(&g.attribute, &ids.join(" "));
}
Ok(output)
})),
..DomRenderMatchConfig::default()
},
DomOverrideOptions::default(),
);
vec![
config_extension(
&dom_render_extension(),
[DomRenderConfigOverrides {
overrides: Some(vec![export]),
..DomRenderConfigOverrides::default()
}],
),
config_extension(
&dom_import_extension(),
[DomImportConfigOverrides {
rules: Some(vec![create_mark_ids_import_rule(flavor).into()]),
..DomImportConfigOverrides::default()
}],
),
]
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ids_sort_by_utf16_code_units() {
let ids = Value::Array(vec![
"\u{ff01}".into(),
"\u{1f600}".into(),
"b".into(),
"b".into(),
"not valid".into(),
]);
assert_eq!(
default_flavor().state.parse(&ids),
["b", "\u{1f600}", "\u{ff01}"]
);
assert!(!is_valid_mark_id("a\u{feff}b"));
assert!(is_valid_mark_id("a\u{85}b"));
}
}