use crate::editor::{
DirtyType, LexicalCommand, MutationListenerPayload, NodeClass, Transform,
UpdateListenerPayload, UpdateOptions,
};
use crate::editor_state::{clone_editor_state, create_empty_editor_state};
use crate::error::invariant;
use crate::gc::garbage_collect_detached_nodes;
use crate::json::Value;
use crate::lexical_selection::{SelectionRef, has_dirty_selection};
use crate::lexical_utils::{get_editors_to_propagate, get_node_by_key, get_root};
use crate::node::NodeRef;
use crate::node_state::{apply_flat_states, update_state_from_json};
use crate::nodes::element::is_root_or_shadow_root;
use crate::normalization::normalize_text_node;
use crate::ordered::{OrderedMap, OrderedSet};
use crate::{Editor, EditorState, LexicalError};
use std::cell::{Cell, RefCell};
use std::collections::{HashMap, HashSet};
use std::rc::Rc;
#[derive(Clone, Default)]
struct Active {
editor: Option<Editor>,
editor_state: Option<EditorState>,
read_only: bool,
registry: Option<Editor>,
}
thread_local! {
static ACTIVE: RefCell<Active> = RefCell::new(Active::default());
static INFINITE_TRANSFORM_COUNT: Cell<u32> = const { Cell::new(0) };
static IS_COMMITTING_PENDING_UPDATES: Cell<bool> = const { Cell::new(false) };
static EDITORS_WITH_PENDING_SELECTION_CHANGE: RefCell<HashSet<usize>> =
RefCell::new(HashSet::new());
static COMMAND_DISPATCH: Cell<(usize, u64)> = const { Cell::new((0, 0)) };
}
#[cfg(all(feature = "mark", feature = "extension"))]
pub(crate) fn command_dispatch_turn() -> Option<u64> {
let (depth, turn) = COMMAND_DISPATCH.with(Cell::get);
(depth > 0).then_some(turn)
}
struct CommandDispatchGuard;
impl CommandDispatchGuard {
fn enter() -> Self {
COMMAND_DISPATCH.with(|c| {
let (depth, turn) = c.get();
c.set((depth + 1, turn));
});
CommandDispatchGuard
}
}
impl Drop for CommandDispatchGuard {
fn drop(&mut self) {
COMMAND_DISPATCH.with(|c| {
let (depth, turn) = c.get();
c.set(if depth == 1 {
(0, turn + 1)
} else {
(depth - 1, turn)
});
});
}
}
fn with_active<R>(active: Active, f: impl FnOnce() -> R) -> R {
struct Restore(Option<Active>);
impl Drop for Restore {
fn drop(&mut self) {
let previous = self.0.take().expect("previous");
ACTIVE.with(|a| *a.borrow_mut() = previous);
}
}
let previous = ACTIVE.with(|a| std::mem::replace(&mut *a.borrow_mut(), active));
let _restore = Restore(Some(previous));
f()
}
pub(crate) fn get_active_editor_state() -> EditorState {
ACTIVE
.with(|a| a.borrow().editor_state.clone())
.unwrap_or_else(|| {
panic!(
"Unable to find an active editor state. State helpers or node methods can only be used synchronously during the callback of editor.update(), editor.read(), or editorState.read()."
)
})
}
#[cfg_attr(not(feature = "text"), allow(dead_code))]
pub(crate) fn internal_get_active_editor_state() -> Option<EditorState> {
ACTIVE.with(|a| a.borrow().editor_state.clone())
}
pub(crate) fn get_active_editor() -> Option<Editor> {
ACTIVE.with(|a| a.borrow().editor.clone())
}
pub(crate) fn get_registry_editor() -> Option<Editor> {
ACTIVE.with(|a| {
let a = a.borrow();
a.editor.clone().or_else(|| a.registry.clone())
})
}
pub(crate) fn is_currently_read_only_mode() -> bool {
ACTIVE.with(|a| a.borrow().read_only)
}
pub(crate) fn error_on_read_only() {
if is_currently_read_only_mode() {
panic!("Cannot use method in read-only mode.");
}
}
#[cfg_attr(not(feature = "rich-text"), allow(dead_code))]
pub(crate) fn flush_sync_after_update() {
let editor_state = get_active_editor_state();
error_on_read_only();
editor_state.0.flush_sync.set(true);
}
pub fn on_update(update_fn: impl FnOnce() + 'static) {
error_on_read_only();
let editor = get_active_editor().unwrap_or_else(|| {
panic!("Unable to find an active editor. This method can only be used synchronously during the callback of editor.update() or editor.read().")
});
editor.0.deferred.borrow_mut().push(Box::new(update_fn));
}
fn trigger_deferred_update_callbacks(editor: &Editor, deferred: Vec<Box<dyn FnOnce()>>) {
if !deferred.is_empty() {
with_updating(editor, || {
for callback in deferred {
callback();
}
});
}
}
pub(crate) fn error_on_infinite_transforms() {
if INFINITE_TRANSFORM_COUNT.with(Cell::get) > 99 {
panic!(
"One or more transforms are endlessly triggering additional transforms. May have encountered infinite recursion caused by transforms that have their preconditions too lose and/or conflict with each other."
);
}
}
fn bump_infinite_transform_count() {
INFINITE_TRANSFORM_COUNT.with(|c| c.set(c.get() + 1));
}
pub(crate) fn read_editor_state<R>(
editor: Option<&Editor>,
editor_state: &EditorState,
f: impl FnOnce() -> R,
) -> R {
with_active(
Active {
editor: editor.cloned(),
editor_state: Some(editor_state.clone()),
read_only: true,
registry: None,
},
f,
)
}
fn apply_transforms(
editor: &Editor,
node: &NodeRef,
cache: &mut HashMap<&'static str, Vec<Transform>>,
) -> Result<(), LexicalError> {
node.get_latest().transform(node)?;
if !node.is_attached() {
return Ok(());
}
if node.is_element() {
normalize_shadow_root_children(node)?;
if !node.is_attached() {
return Ok(());
}
}
let node_type = node.get_type();
let transforms = cache
.entry(node_type)
.or_insert_with(|| editor.transforms_of(node_type))
.clone();
for transform in &transforms {
transform(node)?;
if !node.is_attached() {
break;
}
}
Ok(())
}
fn normalize_shadow_root_children(node: &NodeRef) -> Result<(), LexicalError> {
if !is_root_or_shadow_root(&*node.get_latest())
|| crate::structure::is_structure_enforced_on_active_editor()
{
return Ok(());
}
let mut block: Option<NodeRef> = None;
for child in node.get_children() {
block = if child.is_inline() {
let block = match block {
Some(block) => block,
None => child.replace(&child.create_parent_element_node(), false)?,
};
block.append(&[child])?;
Some(block)
} else {
None
};
}
Ok(())
}
fn should_normalize(node: &NodeRef) -> bool {
node.is_text() && node.is_attached() && node.is_simple_text() && !node.is_unmergeable()
}
fn normalize_all_dirty_text_nodes(editor: &Editor) -> Result<(), LexicalError> {
let mut i = 0;
loop {
let key = editor
.0
.dirty
.borrow()
.leaves
.key_at(&mut i)
.map(str::to_owned);
let Some(key) = key else { break };
if let Some(node) = get_node_by_key(&key)
&& should_normalize(&node)
{
normalize_text_node(&node)?;
}
i += 1;
}
Ok(())
}
fn apply_all_transforms(editor: &Editor) -> Result<(), LexicalError> {
let mut cache = HashMap::new();
let composition_key = crate::lexical_utils::get_composition_key();
let is_composing = |node: &NodeRef| composition_key.as_deref() == Some(node.get_key());
let mut full_leaves: Option<OrderedSet> = None;
let mut full_elements: Option<OrderedMap<bool>> = None;
loop {
let (leaves_len, elements_len) = {
let dirty = editor.0.dirty.borrow();
(dirty.leaves.len(), dirty.elements.len())
};
if leaves_len == 0 && elements_len == 0 {
break;
}
if leaves_len > 0 {
let untransformed = std::mem::take(&mut editor.0.dirty.borrow_mut().leaves);
let keys: Vec<String> = untransformed.iter().map(str::to_owned).collect();
full_leaves.get_or_insert(untransformed);
for key in &keys {
if let Some(node) = get_node_by_key(key) {
if should_normalize(&node) {
normalize_text_node(&node)?;
}
if !is_composing(&node) && node.is_attached() {
apply_transforms(editor, &node, &mut cache)?;
}
}
full_leaves.as_mut().expect("set above").add(key);
}
if !editor.0.dirty.borrow().leaves.is_empty() {
bump_infinite_transform_count();
continue;
}
}
let (previous_leaves, mut untransformed) = {
let mut dirty = editor.0.dirty.borrow_mut();
(
std::mem::take(&mut dirty.leaves),
std::mem::take(&mut dirty.elements),
)
};
full_leaves.get_or_insert(previous_leaves);
if untransformed.delete("root").is_some() {
untransformed.set("root", true);
}
full_elements.get_or_insert_with(|| untransformed.clone());
let entries: Vec<(String, bool)> = untransformed
.iter()
.map(|(k, v)| (k.to_owned(), *v))
.collect();
for (key, intentionally_marked_as_dirty) in entries {
full_elements
.as_mut()
.expect("set above")
.set(&key, intentionally_marked_as_dirty);
if !intentionally_marked_as_dirty {
continue;
}
if let Some(node) = get_node_by_key(&key)
&& !is_composing(&node)
&& node.is_attached()
{
apply_transforms(editor, &node, &mut cache)?;
}
}
bump_infinite_transform_count();
}
let mut dirty = editor.0.dirty.borrow_mut();
if let Some(leaves) = full_leaves {
dirty.leaves = leaves;
}
if let Some(elements) = full_elements {
dirty.elements = elements;
}
Ok(())
}
fn parse_serialized_node_impl(
serialized_node: &Value,
registered_nodes: &HashMap<&'static str, NodeClass>,
) -> Result<NodeRef, LexicalError> {
let Some(object) = serialized_node.as_object() else {
invariant!(
!serialized_node.is_null(),
"Cannot read properties of null (reading 'type')"
);
return Err(LexicalError::new(
"parseEditorState: type \"undefined\" + not found",
));
};
let node_type = object.get("type");
let registered = node_type
.and_then(Value::as_str)
.and_then(|t| registered_nodes.get(t));
let Some(registered) = registered else {
let shown = match node_type {
None | Some(Value::Undefined) => "undefined".to_owned(),
Some(Value::String(s)) => s.clone(),
Some(other) => other.to_string(),
};
return Err(LexicalError::new(format!(
"parseEditorState: type \"{shown}\" + not found"
)));
};
let node = (registered.import_json)(object)?;
if !registered.imports_node_state() {
update_state_from_json(&node, object)?;
apply_flat_states(&node, object)?;
}
if let Some(Value::Array(children)) = object.get("children")
&& node.is_element()
{
for child in children {
let child = parse_serialized_node_impl(child, registered_nodes)?;
node.append(&[child])?;
}
}
if let Some(slots) = object.get("$slots").filter(|v| is_truthy(v)) {
invariant!(
crate::slot::is_slot_host(&node),
"$parseSerializedNode: node {} has slots but is not a valid slot host; only ElementNodes and DecoratorNodes can host slots.",
node.get_type()
);
let entries: Vec<(String, Value)> = match slots {
Value::Object(o) => o.iter().map(|(k, v)| (k.to_owned(), v.clone())).collect(),
Value::Array(a) => a
.iter()
.enumerate()
.map(|(i, v)| (i.to_string(), v.clone()))
.collect(),
_ => Vec::new(),
};
for (name, value) in entries {
let slot_node = parse_serialized_node_impl(&value, registered_nodes)?;
crate::slot::set_slot(&node, &name, &slot_node)?;
}
}
Ok(node)
}
fn is_truthy(value: &Value) -> bool {
match value {
Value::Undefined | Value::Null => false,
Value::Bool(b) => *b,
Value::Number(n) => *n != 0.0 && !n.is_nan(),
Value::String(s) => !s.is_empty(),
Value::Array(_) | Value::Object(_) => true,
}
}
pub fn parse_serialized_node(serialized_node: &Value) -> Result<NodeRef, LexicalError> {
let editor =
get_active_editor().ok_or_else(|| LexicalError::new("Unable to find an active editor."))?;
parse_serialized_node_impl(serialized_node, editor.registered_nodes())
}
pub(crate) fn parse_editor_state(
serialized_editor_state: &Value,
editor: &Editor,
update_fn: Option<Box<dyn FnOnce() -> Result<(), LexicalError> + '_>>,
) -> Result<EditorState, LexicalError> {
let editor_state = create_empty_editor_state();
let active = Active {
editor: None,
editor_state: Some(editor_state.clone()),
read_only: false,
registry: Some(editor.clone()),
};
with_active(active, || {
let serialized_node = serialized_editor_state.get("root");
invariant!(
serialized_node.is_some_and(|v| !v.is_undefined()),
"Cannot read properties of undefined (reading 'type')"
);
parse_serialized_node_impl(serialized_node.unwrap(), editor.registered_nodes())?;
if let Some(update_fn) = update_fn {
update_fn()?;
}
Ok(())
})?;
editor_state.0.read_only.set(true);
editor_state.0.parsed.set(true);
Ok(editor_state)
}
fn editor_state_text_content(editor_state: &EditorState) -> String {
editor_state.read(|| get_root().get_text_content())
}
fn with_updating<R>(editor: &Editor, f: impl FnOnce() -> R) -> R {
struct Restore<'a>(&'a Editor, bool);
impl Drop for Restore<'_> {
fn drop(&mut self) {
self.0.0.updating.set(self.1);
}
}
let _restore = Restore(editor, editor.0.updating.replace(true));
f()
}
pub(crate) fn commit_pending_updates(editor: &Editor) -> Result<(), LexicalError> {
struct Restore(bool);
impl Drop for Restore {
fn drop(&mut self) {
IS_COMMITTING_PENDING_UPDATES.with(|c| c.set(self.0));
}
}
let _restore = Restore(IS_COMMITTING_PENDING_UPDATES.with(|c| c.replace(true)));
let notification_result = notify_pending_selection_change(editor)?;
commit_pending_updates_impl(editor)?;
if notification_result {
editor.on_warn(LexicalError::new(
"Selection change listeners are endlessly changing the selection.",
))?;
}
Ok(())
}
fn has_selection_changed(editor: &Editor, selection: Option<&SelectionRef>) -> bool {
let previous = editor.0.last_notified_selection.borrow();
match selection {
None => previous.is_some(),
Some(selection) => previous.as_ref().is_none_or(|p| !selection.get().is(p)),
}
}
pub(crate) fn dispatch_selection_change_command(
editor: &Editor,
selection: Option<&SelectionRef>,
force: bool,
) -> Result<(), LexicalError> {
if !force && !has_selection_changed(editor, selection) {
return Ok(());
}
editor.dispatch_command(&crate::commands::SELECTION_CHANGE_COMMAND, ())?;
Ok(())
}
fn notify_pending_selection_change(editor: &Editor) -> Result<bool, LexicalError> {
let id = Rc::as_ptr(&editor.0) as usize;
if !EDITORS_WITH_PENDING_SELECTION_CHANGE.with(|s| s.borrow_mut().insert(id)) {
return Ok(false);
}
struct Remove(usize);
impl Drop for Remove {
fn drop(&mut self) {
EDITORS_WITH_PENDING_SELECTION_CHANGE.with(|s| s.borrow_mut().remove(&self.0));
}
}
let _remove = Remove(id);
let mut count = 0;
while let Some(pending) = editor.pending() {
let selection = pending.selection();
if !has_selection_changed(editor, selection.as_ref()) {
return Ok(false);
}
let root_connected = editor
.get_root_element()
.is_some_and(|root| root.0.is_connected());
let skip_notification = selection.as_ref().is_none_or(SelectionRef::is_range)
&& (editor.is_headless() || !root_connected);
if skip_notification || count == 100 {
*editor.0.last_notified_selection.borrow_mut() = selection.map(|s| s.get());
return Ok(!skip_notification);
}
let e = editor.clone();
begin_update_with(
editor,
move || {
e.dispatch_command(&crate::commands::SELECTION_CHANGE_COMMAND, ())
.map(|_| ())
},
&UpdateOptions::default(),
true,
)?;
count += 1;
}
Ok(false)
}
pub(crate) fn is_committing_pending_updates() -> bool {
IS_COMMITTING_PENDING_UPDATES.with(Cell::get)
}
fn commit_pending_updates_impl(editor: &Editor) -> Result<(), LexicalError> {
let pending = editor.0.pending.borrow_mut().take();
let Some(pending) = pending else {
if !editor.0.updating.get() && !editor.0.deferred.borrow().is_empty() {
let deferred = std::mem::take(&mut *editor.0.deferred.borrow_mut());
trigger_deferred_update_callbacks(editor, deferred);
}
return Ok(());
};
let current = editor.get_editor_state();
let needs_update = editor.dirty_type() != DirtyType::None;
let previously_updating = editor.0.updating.get();
*editor.0.editor_state.borrow_mut() = pending.clone();
let mutated_nodes =
if !editor.is_headless() && editor.get_root_element().is_some() && needs_update {
let mutated = with_active(
Active {
editor: Some(editor.clone()),
editor_state: Some(pending.clone()),
read_only: false,
registry: None,
},
|| {
with_updating(editor, || {
let mutated = crate::reconciler::reconcile_root(¤t, &pending, editor);
(mutated, get_root().get_text_content())
})
},
);
let (mutated, text) = mutated;
let root = pending.0.node_map.borrow().get("root").cloned();
if let Some(root) = root.filter(|_| !pending.0.read_only.get()) {
let mut cache = editor.0.root_text_cache.borrow_mut();
let fresh = cache.as_ref().is_some_and(|(cached, cached_text)| {
Rc::ptr_eq(cached, &root) && *cached_text == text
});
if !fresh {
editor.0.dirty.borrow_mut().elements.set("root", true);
*cache = Some((root, text));
}
}
Some(mutated)
} else {
None
};
pending.0.read_only.set(true);
let (dirty_elements, dirty_leaves, normalized_nodes) = {
let mut dirty = editor.0.dirty.borrow_mut();
let elements = dirty
.elements
.iter()
.map(|(k, v)| (k.to_owned(), *v))
.collect();
let leaves = dirty.leaves.iter().map(str::to_owned).collect();
let normalized = dirty.normalized.iter().map(str::to_owned).collect();
if needs_update {
*dirty = Default::default();
}
(elements, leaves, normalized)
};
let tags: Vec<String> = std::mem::take(&mut *editor.0.tags.borrow_mut())
.iter()
.map(str::to_owned)
.collect();
let deferred = if previously_updating {
Vec::new()
} else {
std::mem::take(&mut *editor.0.deferred.borrow_mut())
};
crate::reconciler::garbage_collect_detached_decorators(editor, &pending);
let previously_dispatching = editor.0.dispatching_commit_listeners.replace(true);
if let Some(mutated_nodes) = &mutated_nodes {
let leaves: &Vec<String> = &dirty_leaves;
trigger_mutation_listeners(editor, mutated_nodes, &tags, leaves, ¤t);
}
with_updating(editor, || {
let pending_decorators = editor.0.pending_decorators.borrow_mut().take();
if let Some(pending_decorators) = pending_decorators {
*editor.0.decorators.borrow_mut() = pending_decorators.clone();
editor.trigger_decorator_listeners(&pending_decorators);
}
if editor.has_text_content_listeners() {
let current_text = editor_state_text_content(¤t);
let latest_text = editor_state_text_content(&pending);
if current_text != latest_text {
editor.trigger_text_content_listeners(&latest_text);
}
}
let payload = UpdateListenerPayload {
dirty_elements,
dirty_leaves,
normalized_nodes,
tags,
editor_state: pending.clone(),
prev_editor_state: current.clone(),
mutated_nodes: mutated_nodes.clone(),
};
editor.trigger_update_listeners(&payload);
});
editor
.0
.dispatching_commit_listeners
.set(previously_dispatching);
if !previously_updating {
trigger_deferred_update_callbacks(editor, deferred);
}
trigger_enqueued_updates(editor)
}
fn trigger_mutation_listeners(
editor: &Editor,
mutated_nodes: &crate::reconciler::MutatedNodes,
update_tags: &[String],
dirty_leaves: &[String],
prev_editor_state: &EditorState,
) {
let payload = MutationListenerPayload {
dirty_leaves: dirty_leaves.to_vec(),
prev_editor_state: prev_editor_state.clone(),
update_tags: update_tags.to_vec(),
};
for (listener, node_type) in editor.mutation_listeners() {
if let Some((_, mutations)) = mutated_nodes.iter().find(|(t, _)| *t == node_type) {
listener(mutations, &payload);
}
}
}
fn trigger_enqueued_updates(editor: &Editor) -> Result<(), LexicalError> {
if editor.0.updates.borrow().is_empty() {
editor.0.cascade_count.set(0);
return Ok(());
}
let count = editor
.0
.cascade_count
.replace(editor.0.cascade_count.get() + 1);
if count > 99 {
editor.0.updates.borrow_mut().clear();
editor.0.cascade_count.set(0);
return editor.on_warn(LexicalError::new(format!(
"One or more update listeners are endlessly enqueueing more updates. May have encountered infinite recursion caused by update listeners that trigger additional updates without a stop condition. Editor namespace: {}",
editor.get_namespace()
)));
}
let queued = editor.0.updates.borrow_mut().pop_front();
match queued {
Some(queued) => begin_update(editor, queued.update_fn, &queued.options),
None => Ok(()),
}
}
fn process_nested_updates(editor: &Editor, initial_skip: bool) -> Result<bool, LexicalError> {
let mut skip_transforms = initial_skip;
loop {
let queued = editor.0.updates.borrow_mut().pop_front();
let Some(queued) = queued else { break };
let pending = editor.pending();
if queued.options.skip_transforms {
skip_transforms = true;
}
if let Some(on_update) = &queued.options.on_update {
let on_update = on_update.clone();
editor
.0
.deferred
.borrow_mut()
.push(Box::new(move || on_update()));
}
if queued.options.discrete {
invariant!(
pending.is_some(),
"Unexpected empty pending editor state on discrete nested update"
);
pending.as_ref().expect("checked").0.flush_sync.set(true);
}
editor.add_tags(&queued.options.tags);
if pending.is_none() {
begin_update(editor, queued.update_fn, &queued.options)?;
} else {
(queued.update_fn)()?;
}
}
Ok(skip_transforms)
}
fn discard_pending_update(editor: &Editor, queued_before: &HashSet<u64>) {
let committed = editor.get_editor_state();
*editor.0.last_notified_selection.borrow_mut() = committed.selection().map(|s| s.get());
*editor.0.pending.borrow_mut() = Some(committed);
{
let mut dirty = editor.0.dirty.borrow_mut();
dirty.dirty_type = DirtyType::FullReconcile;
dirty.leaves = OrderedSet::new();
dirty.elements = OrderedMap::new();
}
editor
.0
.updates
.borrow_mut()
.retain(|u| queued_before.contains(&u.id));
}
pub(crate) fn begin_update(
editor: &Editor,
update_fn: impl FnOnce() -> Result<(), LexicalError>,
options: &UpdateOptions,
) -> Result<(), LexicalError> {
begin_update_with(editor, update_fn, options, false)
}
fn begin_update_with(
editor: &Editor,
update_fn: impl FnOnce() -> Result<(), LexicalError>,
options: &UpdateOptions,
skip_commit: bool,
) -> Result<(), LexicalError> {
editor.add_tags(&options.tags);
if let Some(on_update) = &options.on_update {
let on_update = on_update.clone();
editor
.0
.deferred
.borrow_mut()
.push(Box::new(move || on_update()));
}
let mut skip_transforms = options.skip_transforms;
let current = editor.get_editor_state();
let mut was_cloned = false;
let pending = match editor.pending() {
Some(pending) if !pending.0.read_only.get() => pending,
other => {
let pending = clone_editor_state(other.as_ref().unwrap_or(¤t));
*editor.0.pending.borrow_mut() = Some(pending.clone());
was_cloned = true;
pending
}
};
pending.0.flush_sync.set(options.discrete);
let queued_before: HashSet<u64> = editor.0.updates.borrow().iter().map(|u| u.id).collect();
let previous_active_state = ACTIVE.with(|a| a.borrow().editor_state.clone());
let previously_notified_selection = editor.0.last_notified_selection.borrow().clone();
struct Restore<'a>(&'a Editor, bool);
impl Drop for Restore<'_> {
fn drop(&mut self) {
self.0.0.updating.set(self.1);
INFINITE_TRANSFORM_COUNT.with(|c| c.set(0));
}
}
let restore = Restore(editor, editor.0.updating.replace(true));
let active = Active {
editor: Some(editor.clone()),
editor_state: Some(pending.clone()),
read_only: false,
registry: None,
};
let result = with_active(active, || {
let run = || -> Result<(), LexicalError> {
if was_cloned && let Some(selection) = current.selection() {
*pending.0.selection.borrow_mut() = Some(selection.clone_selection());
}
update_fn()?;
skip_transforms = process_nested_updates(editor, skip_transforms)?;
crate::lexical_selection::apply_selection_transforms(&pending, editor)?;
if editor.dirty_type() != DirtyType::None {
if skip_transforms {
normalize_all_dirty_text_nodes(editor)?;
} else {
apply_all_transforms(editor)?;
}
process_nested_updates(editor, false)?;
garbage_collect_detached_nodes(¤t, &pending, editor);
}
if let Some(selection) = pending.selection() {
if selection.is_range() && editor.0.slots_used.get() {
crate::lexical_selection::clamp_range_selection_to_slot_frame(&selection)?;
}
if let Some(range) = selection.range() {
let node_map = pending.0.node_map.borrow();
invariant!(
node_map.contains_key(&range.anchor.key)
&& node_map.contains_key(&range.focus.key),
"updateEditor: selection has been lost because the previously selected nodes have been removed and selection wasn't moved to another node. Ensure selection changes after removing/replacing a selected node."
);
} else if selection.with_node(|n| n.nodes.is_empty()) == Some(true) {
*pending.0.selection.borrow_mut() = None;
}
}
Ok(())
};
match run() {
Ok(()) => Ok(()),
Err(error) => {
if !was_cloned
&& previous_active_state
.as_ref()
.is_some_and(|s| s.ptr_eq(&pending))
{
return Err(error);
}
discard_pending_update(editor, &queued_before);
let _ = commit_pending_updates(editor);
Err(error)
}
}
});
drop(restore);
result?;
if skip_commit {
return Ok(());
}
let should_update = editor.dirty_type() != DirtyType::None
|| !editor.0.deferred.borrow().is_empty()
|| has_dirty_selection(
pending.selection().as_ref(),
editor.get_editor_state().selection().as_ref(),
);
if should_update {
if pending.0.flush_sync.get() {
pending.0.flush_sync.set(false);
commit_pending_updates(editor)?;
}
} else {
pending.0.flush_sync.set(false);
if was_cloned {
*editor.0.tags.borrow_mut() = OrderedSet::new();
editor.0.deferred.borrow_mut().clear();
*editor.0.pending.borrow_mut() = None;
*editor.0.last_notified_selection.borrow_mut() = previously_notified_selection;
}
}
Ok(())
}
pub(crate) fn update_editor_sync(
editor: &Editor,
f: impl FnOnce() -> Result<(), LexicalError>,
options: Option<&UpdateOptions>,
) -> Result<(), LexicalError> {
let (in_update, read_only) = ACTIVE.with(|a| {
let a = a.borrow();
(
a.editor.as_ref().is_some_and(|e| e.ptr_eq(editor)),
a.read_only,
)
});
match options {
None if in_update && !read_only => f(),
None => {
if in_update {
crate::warnings::console_warn(
"updateEditorSync: an editor update (e.g. a command listener that mutates the editor) ran while a read-only context was on the stack. This most commonly happens when a command is dispatched from inside editor.read(). The update has been deferred to a fresh writable update so it still applies, but dispatching mutations from a read-only context is an anti-pattern — dispatch after editor.read() returns, or via queueMicrotask.",
);
}
begin_update(editor, f, &UpdateOptions::default())
}
Some(options) => begin_update(editor, f, options),
}
}
pub(crate) fn trigger_command_listeners<P: 'static>(
editor: &Editor,
command: &LexicalCommand<P>,
payload: &Rc<P>,
from_editor: &Editor,
) -> Result<bool, LexicalError> {
let _dispatch = CommandDispatchGuard::enter();
let editors = get_editors_to_propagate(editor);
let mut updating_parent_editor: Option<Editor> = None;
if !is_committing_pending_updates() {
for e in &editors {
if !e.0.updating.get() {
e.0.cascade_count.set(0);
}
}
}
if command.id() == crate::commands::SELECTION_CHANGE_COMMAND.id() {
let (in_update, read_only) = ACTIVE.with(|a| {
let a = a.borrow();
(
a.editor.as_ref().is_some_and(|e| e.ptr_eq(editor)),
a.read_only,
)
});
if !in_update || read_only {
let mut handled = false;
update_editor_sync(
editor,
|| {
handled = trigger_command_listeners(editor, command, payload, from_editor)?;
Ok(())
},
None,
)?;
return Ok(handled);
}
*editor.0.last_notified_selection.borrow_mut() =
get_active_editor_state().selection().map(|s| s.get());
}
for priority in (0..=4).rev() {
for (e, current_editor) in editors.iter().enumerate() {
if e > 0 && current_editor.0.updating.get() {
updating_parent_editor = Some(current_editor.clone());
break;
}
let listeners = current_editor.command_listeners(command, priority);
if listeners.is_empty() {
continue;
}
let mut handled = false;
update_editor_sync(
current_editor,
|| {
for listener in &listeners {
if listener(payload, from_editor)? {
handled = true;
return Ok(());
}
}
Ok(())
},
None,
)?;
if handled {
return Ok(true);
}
}
}
if let Some(updating_parent_editor) = updating_parent_editor {
let (command, payload, from_editor) =
(command.clone(), payload.clone(), from_editor.clone());
let parent = updating_parent_editor.clone();
updating_parent_editor.update(
move || {
trigger_command_listeners(&parent, &command, &payload, &from_editor).map(|_| ())
},
UpdateOptions::default(),
)?;
}
Ok(false)
}