pub use super::block_handles::MIN_BLOCK_HANDLE_LENGTH;
use super::block_handles::{
HANDLE_KEY_LENGTH, HandleTable, build_handle_table, handle_in_table, handle_key,
ids_with_prefix,
};
use super::get_extension_dependency::get_extension_output;
use super::positional_block_id::{
ID_ALPHABET, ID_LENGTH, derive_duplicate_id, derive_positional_id, document_key,
};
use super::signals::{Signal, effect, signal};
use crate::editor_state::EditorState;
use crate::extension_core::{
ExtensionBuildState, ExtensionConfigBase, ExtensionInitState, ExtensionRegisterState,
InitialEditorConfig, LexicalExtension, declare_peer_dependency, define_extension,
};
use crate::json::Value;
use crate::node::{LexicalNode, NodeKey};
use crate::node_state::{StateConfig, StateValueConfig, create_state_with, get_state, set_state};
use crate::ordered::{OrderedMap, OrderedSet};
use crate::slot::{
get_slot, get_slot_host, get_slot_name_within_host, get_slot_names, slots_field,
};
use crate::updates::{get_active_editor, internal_get_active_editor_state, read_editor_state};
use crate::{
COLLABORATION_TAG, Editor, HISTORIC_TAG, HISTORY_MERGE_TAG, LexicalError, NodeRef, Unregister,
UpdateListenerPayload, UpdateOptions, get_node_by_key, get_root, has_update_tag,
};
use std::cell::{Cell, RefCell};
use std::collections::{HashMap, HashSet};
use std::rc::{Rc, Weak};
const MAX_HANDLE_CANDIDATES: usize = 10;
const MAX_ID_ATTEMPTS: usize = 32;
const BLOCK_ID_REPAIR_TAG: &str = "block-id-repair";
fn matches_block_id_pattern(value: &str) -> bool {
(1..=64).contains(&value.len())
&& value
.bytes()
.all(|c| c.is_ascii_alphanumeric() || c == b'_' || c == b'-')
}
fn parse_block_id(value: &Value) -> Option<String> {
value
.as_str()
.filter(|id| matches_block_id_pattern(id))
.map(str::to_owned)
}
thread_local! {
static BLOCK_ID_STATE: StateConfig<Option<String>> = create_state_with(
"blockId",
StateValueConfig {
parse: Rc::new(parse_block_id),
unparse: Rc::new(|id: &Option<String>| {
id.as_ref().map_or(Value::Undefined, |id| Value::String(id.clone()))
}),
is_equal: Rc::new(|a: &Option<String>, b: &Option<String>| a == b),
reset_on_copy_node: true,
derived: false,
schema: None,
},
);
}
pub fn block_id_state() -> StateConfig<Option<String>> {
BLOCK_ID_STATE.with(Clone::clone)
}
fn id_of_version(node: &dyn LexicalNode) -> Result<Option<String>, LexicalError> {
Ok(
crate::node_state::get_state_direct(node, &block_id_state())?
.filter(|id| matches_block_id_pattern(id)),
)
}
pub fn get_block_id(node: &NodeRef) -> Result<Option<String>, LexicalError> {
Ok(get_state(node, &block_id_state())?.filter(|id| matches_block_id_pattern(id)))
}
fn set_block_id(node: &NodeRef, id: Option<String>) -> Result<(), LexicalError> {
set_state(node, &block_id_state(), id).map(|_| ())
}
fn output() -> Result<Rc<BlockIdOutput>, LexicalError> {
get_extension_output(&block_id_extension())?
.ok_or_else(|| LexicalError::new("BlockIdExtension has no output"))
}
pub fn get_block_by_id(id: &str) -> Result<Option<NodeRef>, LexicalError> {
(output()?.get_block_by_id)(id)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BlockHandleInvalidReason {
TooShort,
Malformed,
}
impl BlockHandleInvalidReason {
pub fn as_str(self) -> &'static str {
match self {
BlockHandleInvalidReason::TooShort => "too-short",
BlockHandleInvalidReason::Malformed => "malformed",
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum BlockHandleResult {
Found { node: NodeRef },
NotFound { handle: String },
Ambiguous {
handle: String,
candidates: Vec<String>,
},
Invalid {
handle: String,
reason: BlockHandleInvalidReason,
},
}
impl BlockHandleResult {
pub fn status(&self) -> &'static str {
match self {
BlockHandleResult::Found { .. } => "found",
BlockHandleResult::NotFound { .. } => "not-found",
BlockHandleResult::Ambiguous { .. } => "ambiguous",
BlockHandleResult::Invalid { .. } => "invalid",
}
}
pub fn node(&self) -> Option<&NodeRef> {
match self {
BlockHandleResult::Found { node } => Some(node),
_ => None,
}
}
}
fn not_found(handle: &str) -> BlockHandleResult {
BlockHandleResult::NotFound {
handle: handle.to_owned(),
}
}
fn invalid(handle: &str, reason: BlockHandleInvalidReason) -> BlockHandleResult {
BlockHandleResult::Invalid {
handle: handle.to_owned(),
reason,
}
}
pub fn get_block_handle(node: &NodeRef) -> Result<Option<String>, LexicalError> {
(output()?.get_block_handle)(node)
}
pub fn get_block_handles() -> Result<Vec<(String, String)>, LexicalError> {
(output()?.get_block_handles)()
}
pub fn resolve_block_handle(
handle: &str,
options: Option<&BlockHandleOptions>,
) -> Result<BlockHandleResult, LexicalError> {
(output()?.resolve_block_handle)(handle, options)
}
#[derive(Clone, Debug, Default)]
pub struct BlockHandleOptions {
pub read: Option<Vec<(String, String)>>,
}
pub fn is_root_child_block(node: &NodeRef) -> bool {
(node.is_element() || node.is_decorator()) && node.get_parent().is_some_and(|p| p.is_root())
}
pub fn default_is_identified_block(node: &NodeRef) -> bool {
if !node.is_element() && !node.is_decorator() {
return false;
}
let parent = node.get_parent();
if parent.as_ref().is_some_and(NodeRef::is_root) {
return true;
}
if (parent.is_none() && get_slot_host(node).is_none()) || node.is_inline() {
return false;
}
if !node.is_element() {
return true;
}
let latest = node.get_latest();
!latest.is_shadow_root() && latest.declares_inline_children()
}
pub fn generate_block_id() -> String {
use std::hash::BuildHasher;
thread_local! {
static COUNTER: Cell<u64> = const { Cell::new(0) };
}
let count = COUNTER.with(|c| c.replace(c.get().wrapping_add(1)));
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_nanos());
let state = std::collections::hash_map::RandomState::new();
let mut bits = [
state.hash_one((count, nanos, 0u8)),
state.hash_one((count, nanos, 1u8)),
state.hash_one((count, nanos, 2u8)),
];
let mut id = String::with_capacity(ID_LENGTH);
for i in 0..ID_LENGTH {
let word = &mut bits[i / 10];
id.push(ID_ALPHABET[(*word & 63) as usize] as char);
*word >>= 6;
}
id
}
#[derive(Clone)]
pub struct IsIdentifiedBlock(pub Rc<dyn Fn(&NodeRef) -> bool>);
#[derive(Clone)]
pub struct GenerateId(pub Rc<dyn Fn() -> String>);
#[derive(Clone)]
pub struct BlockIdConfig {
pub disabled: bool,
pub is_identified_block: IsIdentifiedBlock,
pub generate_id: GenerateId,
pub repair_transforms: bool,
}
impl Default for BlockIdConfig {
fn default() -> Self {
BlockIdConfig {
disabled: false,
is_identified_block: IsIdentifiedBlock(Rc::new(default_is_identified_block)),
generate_id: GenerateId(Rc::new(generate_block_id)),
repair_transforms: true,
}
}
}
#[derive(Clone, Default)]
pub struct BlockIdConfigOverrides {
pub disabled: Option<bool>,
pub is_identified_block: Option<IsIdentifiedBlock>,
pub generate_id: Option<GenerateId>,
pub repair_transforms: Option<bool>,
}
impl ExtensionConfigBase for BlockIdConfig {
type Partial = BlockIdConfigOverrides;
fn shallow_merge(&self, overrides: &BlockIdConfigOverrides) -> Self {
BlockIdConfig {
disabled: overrides.disabled.unwrap_or(self.disabled),
is_identified_block: overrides
.is_identified_block
.clone()
.unwrap_or_else(|| self.is_identified_block.clone()),
generate_id: overrides
.generate_id
.clone()
.unwrap_or_else(|| self.generate_id.clone()),
repair_transforms: overrides
.repair_transforms
.unwrap_or(self.repair_transforms),
}
}
}
pub type GetBlockByIdFn = Rc<dyn Fn(&str) -> Result<Option<NodeRef>, LexicalError>>;
pub type GetBlockHandleFn = Rc<dyn Fn(&NodeRef) -> Result<Option<String>, LexicalError>>;
pub type GetBlockHandlesFn = Rc<dyn Fn() -> Result<Vec<(String, String)>, LexicalError>>;
pub type ResolveBlockHandleFn =
Rc<dyn Fn(&str, Option<&BlockHandleOptions>) -> Result<BlockHandleResult, LexicalError>>;
#[derive(Clone)]
pub struct BlockIdOutput {
pub disabled: Signal<bool>,
pub get_block_by_id: GetBlockByIdFn,
pub get_block_handle: GetBlockHandleFn,
pub get_block_handles: GetBlockHandlesFn,
pub resolve_block_handle: ResolveBlockHandleFn,
pub is_identified_block: IsIdentifiedBlock,
}
enum HolderKeys {
One(NodeKey),
Many(OrderedSet),
}
#[derive(Default)]
struct BlockIdIndex {
keys_of_id: OrderedMap<HolderKeys>,
id_of_key: OrderedMap<String>,
version: u64,
}
impl BlockIdIndex {
fn clear(&mut self) {
self.keys_of_id = OrderedMap::new();
self.id_of_key = OrderedMap::new();
self.version += 1;
}
fn holders(&self, id: &str) -> Vec<NodeKey> {
match self.keys_of_id.get(id) {
None => Vec::new(),
Some(HolderKeys::One(key)) => vec![key.clone()],
Some(HolderKeys::Many(keys)) => keys.iter().map(str::to_owned).collect(),
}
}
fn is_repeated(&self, id: &str) -> bool {
matches!(self.keys_of_id.get(id), Some(HolderKeys::Many(_)))
}
fn set(&mut self, key: &str, id: &str) {
if self.id_of_key.get(key).map(String::as_str) == Some(id) {
return;
}
self.remove(key);
self.version += 1;
self.id_of_key.set(key, id.to_owned());
match self.keys_of_id.get_mut(id) {
None => self.keys_of_id.set(id, HolderKeys::One(key.to_owned())),
Some(HolderKeys::One(other)) => {
let mut keys = OrderedSet::new();
keys.add(other);
keys.add(key);
self.keys_of_id.set(id, HolderKeys::Many(keys));
}
Some(HolderKeys::Many(keys)) => keys.add(key),
}
}
fn remove(&mut self, key: &str) {
let Some(id) = self.id_of_key.delete(key) else {
return;
};
self.version += 1;
let last = match self.keys_of_id.get_mut(&id) {
Some(HolderKeys::Many(keys)) => {
keys.delete(key);
if keys.len() == 1 {
keys.iter().next().map(str::to_owned)
} else {
return;
}
}
_ => None,
};
match last {
Some(last) => self.keys_of_id.set(&id, HolderKeys::One(last)),
None => {
self.keys_of_id.delete(&id);
}
}
}
}
struct HandleView {
table: HandleTable,
scan: Option<OrderedMap<Vec<NodeKey>>>,
frozen: FrozenLookups,
}
type FrozenLookups = RefCell<
Vec<(
Weak<crate::editor_state::EditorStateInner>,
HashMap<String, Option<NodeRef>>,
)>,
>;
struct ProvisionalId {
id: String,
yielded: Option<String>,
}
pub struct BlockIdRuntime {
config: BlockIdConfig,
index: RefCell<BlockIdIndex>,
active: Cell<bool>,
has_content: Cell<bool>,
placed: RefCell<Rc<OrderedMap<String>>>,
placed_state: RefCell<Option<EditorState>>,
provisional: RefCell<OrderedMap<ProvisionalId>>,
provisional_seen: RefCell<OrderedSet>,
provisional_state: RefCell<Option<EditorState>>,
handles: RefCell<Option<(Rc<HandleView>, u64)>>,
scan: RefCell<Option<(Rc<HandleView>, EditorState)>>,
}
impl BlockIdRuntime {
fn new(config: BlockIdConfig) -> Self {
BlockIdRuntime {
config,
index: RefCell::new(BlockIdIndex::default()),
active: Cell::new(false),
has_content: Cell::new(false),
placed: RefCell::new(Rc::new(OrderedMap::new())),
placed_state: RefCell::new(None),
provisional: RefCell::new(OrderedMap::new()),
provisional_seen: RefCell::new(OrderedSet::new()),
provisional_state: RefCell::new(None),
handles: RefCell::new(None),
scan: RefCell::new(None),
}
}
fn is_identified_block(&self, node: &NodeRef) -> bool {
(self.config.is_identified_block.0)(node)
}
fn get_block_by_id(&self, id: &str) -> Result<Option<NodeRef>, LexicalError> {
let mut found: Option<NodeRef> = None;
if !self.active.get() {
walk((), &mut |node, _| {
if found.is_none()
&& self.is_identified_block(node)
&& get_block_id(node)?.as_deref() == Some(id)
{
found = Some(node.clone());
}
Ok(())
})?;
return Ok(found);
}
for node in live_holders(self, id, &[])? {
if found
.as_ref()
.is_none_or(|f| compare_document_order(&node, f) < 0)
{
found = Some(node);
}
}
Ok(found)
}
}
fn walk<T: Clone>(
context: T,
visit: &mut dyn FnMut(&NodeRef, &T) -> Result<T, LexicalError>,
) -> Result<(), LexicalError> {
let mut stack: Vec<(NodeRef, T)> = Vec::new();
let push_contents = |stack: &mut Vec<(NodeRef, T)>, node: &NodeRef, inner: T| {
if node.is_element() {
let mut child = node.get_last_child();
while let Some(current) = child {
if !current.is_text() {
stack.push((current.clone(), inner.clone()));
}
child = current.get_previous_sibling();
}
}
for name in get_slot_names(node).iter().rev() {
if let Some(slot) = get_slot(node, name) {
stack.push((slot, inner.clone()));
}
}
};
push_contents(&mut stack, &get_root(), context);
while let Some((node, outer)) = stack.pop() {
let inner = visit(&node, &outer)?;
push_contents(&mut stack, &node, inner);
}
Ok(())
}
struct Frame {
parent: Option<Rc<Frame>>,
index: usize,
next: Cell<usize>,
}
fn place_of(frame: &Frame) -> String {
match &frame.parent {
Some(parent) if parent.parent.is_some() => format!("{}.{}", place_of(parent), frame.index),
_ => frame.index.to_string(),
}
}
fn place_blocks(
runtime: &BlockIdRuntime,
is_target: &dyn Fn(&NodeRef) -> bool,
) -> Result<OrderedMap<String>, LexicalError> {
let mut taken: HashSet<String> = HashSet::new();
let mut targets: Vec<(NodeKey, Rc<Frame>)> = Vec::new();
let root_frame = Rc::new(Frame {
parent: None,
index: 0,
next: Cell::new(0),
});
walk(root_frame, &mut |node, frame| {
if !runtime.is_identified_block(node) {
return Ok(frame.clone());
}
let inner = Rc::new(Frame {
parent: Some(frame.clone()),
index: frame.next.get(),
next: Cell::new(0),
});
frame.next.set(frame.next.get() + 1);
if let Some(id) = get_block_id(node)? {
taken.insert(id);
} else if is_target(node) {
targets.push((node.get_key().to_owned(), inner.clone()));
}
Ok(inner)
})?;
let mut placed = OrderedMap::new();
if targets.is_empty() {
return Ok(placed);
}
let key = document_key();
for (node_key, frame) in targets {
let path = place_of(&frame);
let mut id = derive_positional_id(&key, &path);
let mut attempt = 1;
while taken.contains(&id) {
id = derive_positional_id(&key, &format!("{path}#{attempt}"));
attempt += 1;
}
taken.insert(id.clone());
placed.set(&node_key, id);
}
Ok(placed)
}
fn rename_later_holders(
runtime: &BlockIdRuntime,
id: &str,
holders: &[NodeRef],
used: &mut OrderedSet,
) -> Result<Vec<(NodeKey, String)>, LexicalError> {
let mut holders = holders.to_vec();
holders.sort_by(|a, b| compare_document_order(a, b).cmp(&0));
let mut renamed = Vec::new();
for (k, holder) in holders.iter().enumerate().skip(1) {
let mut next = derive_duplicate_id(id, &k.to_string());
let mut n = 1;
while is_id_taken(runtime, &next, used, None)? {
next = derive_duplicate_id(id, &format!("{k}#{n}"));
n += 1;
}
used.add(&next);
renamed.push((holder.get_key().to_owned(), next));
}
Ok(renamed)
}
fn name_unnamed(
runtime: &BlockIdRuntime,
keys: &[NodeKey],
) -> Result<OrderedMap<String>, LexicalError> {
let mut unnamed = OrderedSet::new();
let mut repeated = OrderedSet::new();
for key in keys {
if let Some(node) = get_node_by_key(key)
&& is_live_identified(runtime, &node)
{
match get_block_id(&node)? {
Some(id) => repeated.add(&id),
None => unnamed.add(key),
}
}
}
let mut named = if unnamed.is_empty() {
OrderedMap::new()
} else {
place_blocks(runtime, &|node| unnamed.contains(node.get_key()))?
};
let mut used = OrderedSet::new();
for (_, id) in named.iter() {
used.add(id);
}
let mut ids: Vec<&str> = repeated.iter().collect();
ids.sort_by(|a, b| crate::utf16::cmp(a, b));
for id in ids {
let holders = live_holders(runtime, id, &[])?;
if holders.len() > 1 {
for (key, next) in rename_later_holders(runtime, id, &holders, &mut used)? {
named.set(&key, next);
}
}
}
Ok(named)
}
fn is_live_identified(runtime: &BlockIdRuntime, node: &NodeRef) -> bool {
node.is_attached() && runtime.is_identified_block(node)
}
fn live_holders(
runtime: &BlockIdRuntime,
id: &str,
extra_keys: &[NodeKey],
) -> Result<Vec<NodeRef>, LexicalError> {
let mut seen: HashSet<NodeKey> = HashSet::new();
let mut result = Vec::new();
let indexed = runtime.index.borrow().holders(id);
for key in indexed.iter().chain(extra_keys) {
if !seen.insert(key.clone()) {
continue;
}
if let Some(node) = get_node_by_key(key)
&& is_live_identified(runtime, &node)
&& get_block_id(&node)?.as_deref() == Some(id)
{
result.push(node);
}
}
Ok(result)
}
fn is_id_taken(
runtime: &BlockIdRuntime,
id: &str,
used: &OrderedSet,
except: Option<&str>,
) -> Result<bool, LexicalError> {
Ok(used.contains(id)
|| live_holders(runtime, id, &[])?
.iter()
.any(|holder| Some(holder.get_key()) != except))
}
fn get_container(node: &NodeRef) -> Option<NodeRef> {
node.get_parent().or_else(|| get_slot_host(node))
}
fn compare_document_order(a: &NodeRef, b: &NodeRef) -> i64 {
if a == b {
return 0;
}
let mut below: HashMap<NodeKey, NodeRef> = HashMap::new();
let mut child = a.clone();
let mut container = get_container(a);
while let Some(current) = container {
below.insert(current.get_key().to_owned(), child);
container = get_container(¤t);
child = current;
}
if below.contains_key(b.get_key()) {
return 1;
}
let mut b_child = b.clone();
let mut container = get_container(b);
while let Some(current) = container {
if current == *a {
return -1;
}
let Some(a_child) = below.get(current.get_key()) else {
container = get_container(¤t);
b_child = current;
continue;
};
let a_slot = get_slot_name_within_host(a_child);
let b_slot = get_slot_name_within_host(&b_child);
if a_slot.is_some() || b_slot.is_some() {
let (Some(a_slot), Some(b_slot)) = (a_slot.as_ref(), b_slot.as_ref()) else {
return if a_slot.is_none() { 1 } else { -1 };
};
let names = get_slot_names(¤t);
let position = |name: &String| {
names
.iter()
.position(|n| n == name)
.map_or(-1, |i| i as i64)
};
return position(a_slot) - position(b_slot);
}
let mut na = Some(a_child.clone());
let mut nb = Some(b_child.clone());
while let (Some(x), Some(y)) = (&na, &nb) {
if x == &b_child {
return -1;
} else if y == a_child {
return 1;
}
let (next_a, next_b) = (x.get_next_sibling(), y.get_next_sibling());
na = next_a;
nb = next_b;
}
return if na.is_none() { 1 } else { -1 };
}
compare_keys(a, b)
}
fn compare_keys(a: &NodeRef, b: &NodeRef) -> i64 {
let number = |node: &NodeRef| node.get_key().parse::<i64>().unwrap_or(0);
number(a) - number(b)
}
fn make_fresh_id(runtime: &BlockIdRuntime, used: &mut OrderedSet) -> Result<String, LexicalError> {
for _ in 0..MAX_ID_ATTEMPTS {
let id = (runtime.config.generate_id.0)();
if matches_block_id_pattern(&id) && !is_id_taken(runtime, &id, used, None)? {
used.add(&id);
return Ok(id);
}
}
Err(LexicalError::new(format!(
"BlockIdExtension: generateId returned {MAX_ID_ATTEMPTS} ids in a row that were invalid or already in use"
)))
}
fn node_in(state: &EditorState, key: &str) -> Option<Rc<dyn LexicalNode>> {
state.0.node_map.borrow().get(key).cloned()
}
fn is_load(editor: &Editor, runtime: &BlockIdRuntime) -> bool {
let prev_first = node_in(&editor.get_editor_state(), "root")
.and_then(|root| root.element().and_then(|e| e.first.clone()));
!runtime.has_content.get() || prev_first.is_some_and(|first| get_node_by_key(&first).is_none())
}
struct Assignment<'a> {
runtime: &'a BlockIdRuntime,
prev_state: EditorState,
placed_before: Rc<OrderedMap<String>>,
used: OrderedSet,
lineage: OrderedMap<NodeKey>,
}
impl Assignment<'_> {
fn prev_node(&self, key: &str) -> Option<Rc<dyn LexicalNode>> {
node_in(&self.prev_state, key)
}
fn prev_id_of_key(&self, key: &str) -> Result<Option<String>, LexicalError> {
if let Some(placed) = self.placed_before.get(key) {
return Ok(Some(placed.clone()));
}
self.prev_node(key)
.map_or(Ok(None), |node| id_of_version(&*node))
}
fn held_before(&self, key: &str, id: &str) -> bool {
self.placed_before.get(key).map(String::as_str) == Some(id)
|| self
.runtime
.index
.borrow()
.id_of_key
.get(key)
.map(String::as_str)
== Some(id)
}
fn inherit(&mut self, node: &NodeRef, id: &str, from_key: &str) -> Result<(), LexicalError> {
self.lineage.set(node.get_key(), from_key.to_owned());
self.runtime.provisional.borrow_mut().delete(node.get_key());
self.used.add(id);
if get_block_id(node)?.as_deref() != Some(id) {
set_block_id(node, Some(id.to_owned()))?;
}
Ok(())
}
fn is_taken(&self, id: &str, except: Option<&str>) -> Result<bool, LexicalError> {
is_id_taken(self.runtime, id, &self.used, except)
}
}
fn is_removed(key: Option<&str>) -> bool {
key.and_then(get_node_by_key)
.is_some_and(|node| !node.is_attached())
}
fn is_provisional(runtime: &BlockIdRuntime, node: &NodeRef) -> Result<bool, LexicalError> {
let entry = runtime
.provisional
.borrow()
.get(node.get_key())
.map(|entry| (entry.yielded.is_none(), entry.id.clone()));
Ok(match entry {
Some((true, id)) => get_block_id(node)?.as_deref() == Some(id.as_str()),
_ => false,
})
}
fn assign_block_ids(
editor: &Editor,
runtime: &BlockIdRuntime,
keys: Vec<NodeKey>,
) -> Result<(), LexicalError> {
if keys.is_empty() {
return Ok(());
}
if has_update_tag(COLLABORATION_TAG) || has_update_tag(HISTORIC_TAG) {
return Ok(());
}
let blocks: Vec<NodeRef> = keys
.iter()
.filter_map(|key| get_node_by_key(key))
.filter(|node| is_live_identified(runtime, node))
.collect();
if blocks.is_empty() {
return Ok(());
}
let mut block_keys = OrderedSet::new();
for node in &blocks {
block_keys.add(node.get_key());
}
let pending_state = editor.pending();
let same_update = match (&*runtime.provisional_state.borrow(), &pending_state) {
(Some(a), Some(b)) => a.ptr_eq(b),
(None, None) => true,
_ => false,
};
if !same_update {
*runtime.provisional.borrow_mut() = OrderedMap::new();
*runtime.provisional_seen.borrow_mut() = OrderedSet::new();
*runtime.provisional_state.borrow_mut() = pending_state;
}
for key in block_keys.iter() {
runtime.provisional_seen.borrow_mut().add(key);
}
for node in &blocks {
let entry = runtime
.provisional
.borrow()
.get(node.get_key())
.and_then(|entry| Some((entry.id.clone(), entry.yielded.clone()?)));
if let Some((id, yielded)) = entry
&& get_block_id(node)?.as_deref() == Some(id.as_str())
{
let seen: Vec<NodeKey> = runtime
.provisional_seen
.borrow()
.iter()
.map(str::to_owned)
.collect();
if live_holders(runtime, &yielded, &seen)?.is_empty() {
runtime.provisional.borrow_mut().delete(node.get_key());
set_block_id(node, Some(yielded))?;
}
}
}
let prev_state = editor.get_editor_state();
let placed_before = if runtime
.placed_state
.borrow()
.as_ref()
.is_some_and(|s| s.ptr_eq(&prev_state))
{
runtime.placed.borrow().clone()
} else {
Rc::new(OrderedMap::new())
};
let mut a = Assignment {
runtime,
prev_state,
placed_before,
used: OrderedSet::new(),
lineage: OrderedMap::new(),
};
let load = is_load(editor, runtime);
if !a.placed_before.is_empty() {
for node in &blocks {
let key = node.get_key();
if let Some(placed) = a.placed_before.get(key).cloned() {
let id = get_block_id(node)?;
let prev_id = a.prev_node(key).map_or(Ok(None), |n| id_of_version(&*n))?;
if (id.is_none() || id == prev_id) && !a.is_taken(&placed, Some(key))? {
a.inherit(node, &placed, key)?;
}
}
}
}
let is_id_less = |a: &Assignment, node: &NodeRef, id: &str| -> Result<bool, LexicalError> {
if runtime
.provisional
.borrow()
.get(node.get_key())
.is_some_and(|entry| entry.id == id)
{
return Ok(true);
}
Ok(live_holders(runtime, id, &[])?
.iter()
.any(|holder| holder != node && a.held_before(holder.get_key(), id)))
};
let new_blocks: Vec<NodeRef> = blocks
.iter()
.filter(|node| a.prev_node(node.get_key()).is_none())
.cloned()
.collect();
for node in &new_blocks {
if !node.is_element() {
continue;
}
let first_child = node.get_first_child();
let mut source_key: Option<NodeKey> = None;
let mut child = first_child.clone();
let mut is_first = true;
while let Some(current) = child {
if source_key.is_some() {
break;
}
if let Some(parent_key) = a
.prev_node(current.get_key())
.and_then(|prev_child| prev_child.base().parent.clone())
&& (is_first || is_removed(Some(&parent_key)))
{
source_key = Some(parent_key);
}
is_first = false;
child = current.get_next_sibling();
}
let Some(source_key) = source_key else {
continue;
};
let own_id = get_block_id(node)?;
let Some(id) = a.prev_id_of_key(&source_key)? else {
continue;
};
if let Some(own_id) = &own_id
&& *own_id != id
&& !is_id_less(&a, node, own_id)?
{
continue;
}
if is_removed(Some(&source_key)) {
if !a.is_taken(&id, Some(&source_key))? {
a.inherit(node, &id, &source_key)?;
}
continue;
}
let source = get_node_by_key(&source_key);
let prev_source_first = a
.prev_node(&source_key)
.and_then(|n| n.element().map(|e| e.first.clone()));
if let (Some(first_child), Some(source), Some(prev_first)) =
(&first_child, &source, prev_source_first)
&& source.is_element()
&& source.is_attached()
&& source.get_children_size() == 0
&& prev_first.as_deref() == Some(first_child.get_key())
&& get_block_id(source)?.as_deref() == Some(id.as_str())
&& !a.used.contains(&id)
{
let fresh = make_fresh_id(runtime, &mut a.used)?;
set_block_id(source, Some(fresh))?;
a.inherit(node, &id, &source_key)?;
}
}
let mut resolved = OrderedSet::new();
for start in &new_blocks {
let mut stack: Vec<NodeRef> = vec![start.clone()];
while let Some(node) = stack.last().cloned() {
let key = node.get_key().to_owned();
if resolved.contains(&key) {
stack.pop();
continue;
}
let prev_sibling = node.get_previous_sibling();
if let Some(prev_sibling) = &prev_sibling
&& a.prev_node(prev_sibling.get_key()).is_none()
&& block_keys.contains(prev_sibling.get_key())
&& !resolved.contains(prev_sibling.get_key())
{
stack.push(prev_sibling.clone());
continue;
}
stack.pop();
resolved.add(&key);
if a.lineage.contains(&key)
|| (get_block_id(&node)?.is_some() && !is_provisional(runtime, &node)?)
{
continue;
}
let removed_key: Option<NodeKey> = if let Some(host) = get_slot_host(&node) {
let prev_host = a.prev_node(host.get_key());
match (prev_host, get_slot_name_within_host(&node)) {
(Some(prev_host), Some(name)) => {
slots_field(&*prev_host).and_then(|slots| slots.get(&name).cloned())
}
_ => None,
}
} else if let Some(prev_sibling) = &prev_sibling {
let anchor_key = if a.prev_node(prev_sibling.get_key()).is_some() {
Some(prev_sibling.get_key().to_owned())
} else {
a.lineage.get(prev_sibling.get_key()).cloned()
};
anchor_key
.and_then(|k| a.prev_node(&k))
.and_then(|anchor| anchor.base().next.clone())
} else {
node.get_parent()
.and_then(|parent| a.prev_node(parent.get_key()))
.and_then(|prev_parent| prev_parent.element().and_then(|e| e.first.clone()))
};
if let Some(removed_key) = removed_key
&& is_removed(Some(&removed_key))
&& let Some(id) = a.prev_id_of_key(&removed_key)?
&& !a.is_taken(&id, Some(&removed_key))?
{
a.inherit(&node, &id, &removed_key)?;
}
}
}
let mut candidates_by_id: OrderedMap<Vec<NodeKey>> = OrderedMap::new();
let mut need_fresh: Vec<NodeRef> = Vec::new();
for node in &blocks {
match get_block_id(node)? {
Some(id) => match candidates_by_id.get_mut(&id) {
Some(list) => list.push(node.get_key().to_owned()),
None => candidates_by_id.set(&id, vec![node.get_key().to_owned()]),
},
None => need_fresh.push(node.clone()),
}
}
let mut repeated: OrderedMap<Vec<NodeRef>> = OrderedMap::new();
let mut yielded_of: OrderedMap<String> = OrderedMap::new();
for (id, keys_with_id) in candidates_by_id.iter() {
let holders = live_holders(runtime, id, keys_with_id)?;
if holders.len() > 1 {
repeated.set(id, holders);
}
}
let mut repeated_ids: Vec<String> = repeated.keys().map(str::to_owned).collect();
repeated_ids.sort_by(|x, y| crate::utf16::cmp(x, y));
for id in &repeated_ids {
let holders = repeated.get(id).expect("a repeated id").clone();
a.used.add(id);
let existing: Vec<NodeRef> = holders
.iter()
.filter(|holder| a.held_before(holder.get_key(), id))
.cloned()
.collect();
let shared = if existing.len() > 1 {
Some(existing.clone())
} else if load {
Some(holders.clone())
} else {
None
};
let keepers: Vec<NodeRef> = if let Some(shared) = shared {
for (key, next) in rename_later_holders(runtime, id, &shared, &mut a.used)? {
let node = get_node_by_key(&key).expect("a holder of the active state");
set_block_id(&node, Some(next))?;
}
shared
} else if existing.len() == 1 {
existing
} else {
let mut continuing = Vec::new();
for node in &holders {
if let Some(from) = a.lineage.get(node.get_key()).cloned()
&& is_removed(Some(&from))
&& a.prev_id_of_key(&from)?.as_deref() == Some(id.as_str())
{
continuing.push(node.clone());
}
}
let pool = if continuing.is_empty() {
&holders
} else {
&continuing
};
let first = pool[1..].iter().fold(&pool[0], |best, node| {
if compare_keys(node, best) < 0 {
node
} else {
best
}
});
vec![first.clone()]
};
for node in &holders {
if !keepers.contains(node) {
need_fresh.push(node.clone());
yielded_of.set(node.get_key(), id.clone());
}
}
}
let mut random = need_fresh.clone();
if load && !need_fresh.is_empty() {
let mut fresh = OrderedSet::new();
for node in &need_fresh {
fresh.add(node.get_key());
}
let placed = place_blocks(runtime, &|node| fresh.contains(node.get_key()))?;
random = Vec::new();
for node in &need_fresh {
let key = node.get_key();
match placed.get(key) {
Some(id) if !a.is_taken(id, Some(key))? => {
a.used.add(id);
set_block_id(node, Some(id.clone()))?;
}
_ => random.push(node.clone()),
}
}
}
random.sort_by(|x, y| compare_keys(x, y).cmp(&0));
for node in &random {
let id = make_fresh_id(runtime, &mut a.used)?;
set_block_id(node, Some(id.clone()))?;
if a.prev_node(node.get_key()).is_none() {
runtime.provisional.borrow_mut().set(
node.get_key(),
ProvisionalId {
id,
yielded: yielded_of.get(node.get_key()).cloned(),
},
);
}
}
Ok(())
}
fn sync_index(
runtime: &BlockIdRuntime,
editor_state: &EditorState,
changes: Option<&UpdateListenerPayload>,
) -> Result<Vec<NodeKey>, LexicalError> {
let mut needs_repair: Vec<NodeKey> = Vec::new();
let mut touched_ids = OrderedSet::new();
let mut visit = |node: &NodeRef| -> Result<(), LexicalError> {
let key = node.get_key();
if is_live_identified(runtime, node) {
match get_block_id(node)? {
Some(id) => {
runtime.index.borrow_mut().set(key, &id);
touched_ids.add(&id);
}
None => {
runtime.index.borrow_mut().remove(key);
needs_repair.push(key.to_owned());
}
}
} else {
runtime.index.borrow_mut().remove(key);
}
Ok(())
};
let incremental = changes.filter(|changes| {
!(changes.dirty_leaves.is_empty()
&& changes.dirty_elements.len() == 1
&& changes.dirty_elements[0].0 == "root")
});
if let Some(changes) = incremental {
let prev_state = &changes.prev_editor_state;
let remove_subtree = |key: &str| {
let mut stack: Vec<NodeKey> = vec![key.to_owned()];
while let Some(k) = stack.pop() {
if node_in(editor_state, &k).is_some() {
continue;
}
runtime.index.borrow_mut().remove(&k);
let Some(prev_node) = node_in(prev_state, &k) else {
continue;
};
if let Some(element) = prev_node.element() {
let mut child = element.first.clone();
while let Some(current) = child {
child = node_in(prev_state, ¤t).and_then(|n| n.base().next.clone());
stack.push(current);
}
}
if let Some(slots) = slots_field(&*prev_node) {
stack.extend(slots.values().cloned());
}
}
};
let mut visit_key = |key: &str| -> Result<(), LexicalError> {
match node_in(editor_state, key) {
Some(node) => {
if node.text().is_none() {
visit(&NodeRef::new(key))?;
}
}
None => remove_subtree(key),
}
Ok(())
};
for (key, intentional) in &changes.dirty_elements {
let same_version = match (node_in(editor_state, key), node_in(prev_state, key)) {
(Some(x), Some(y)) => std::ptr::addr_eq(Rc::as_ptr(&x), Rc::as_ptr(&y)),
_ => false,
};
if *intentional || !same_version {
visit_key(key)?;
}
}
for key in &changes.dirty_leaves {
visit_key(key)?;
}
} else {
runtime.index.borrow_mut().clear();
walk((), &mut |node, _| visit(node))?;
}
for id in touched_ids.iter() {
if runtime.index.borrow().is_repeated(id) {
let holders = live_holders(runtime, id, &[])?;
if holders.len() > 1 {
needs_repair.extend(holders.iter().map(|h| h.get_key().to_owned()));
}
}
}
Ok(needs_repair)
}
fn sync(
runtime: &BlockIdRuntime,
editor_state: &EditorState,
changes: Option<&UpdateListenerPayload>,
) -> Result<Vec<NodeKey>, LexicalError> {
let repairs = sync_index(runtime, editor_state, changes)?;
if !runtime.has_content.get() && !get_root().is_empty() {
runtime.has_content.set(true);
}
*runtime.placed.borrow_mut() = Rc::new(if repairs.is_empty() {
OrderedMap::new()
} else {
name_unnamed(runtime, &repairs)?
});
*runtime.placed_state.borrow_mut() = Some(editor_state.clone());
Ok(repairs)
}
fn schedule_repair(
editor: &Editor,
runtime: &Rc<BlockIdRuntime>,
keys: Vec<NodeKey>,
) -> Result<(), LexicalError> {
let with_transforms = runtime.config.repair_transforms;
let runtime = runtime.clone();
editor.update(
move || {
let mut attached = Vec::new();
for key in &keys {
if let Some(node) = get_node_by_key(key)
&& node.is_attached()
{
if with_transforms {
node.mark_dirty();
} else if !attached.contains(key) {
attached.push(key.clone());
}
}
}
if !with_transforms {
let editor = get_active_editor().expect("an update has an editor");
assign_block_ids(&editor, &runtime, attached)?;
}
Ok(())
},
UpdateOptions {
discrete: true,
tags: vec![HISTORY_MERGE_TAG.to_owned(), BLOCK_ID_REPAIR_TAG.to_owned()],
skip_transforms: !with_transforms,
..UpdateOptions::default()
},
)
}
fn upgrade(editor: &Weak<crate::editor::EditorInner>) -> Option<Editor> {
editor.upgrade().map(Editor)
}
fn register_block_ids(
editor: &Editor,
runtime: &Rc<BlockIdRuntime>,
) -> Result<Unregister, LexicalError> {
let candidates: Rc<RefCell<OrderedSet>> = Rc::new(RefCell::new(OrderedSet::new()));
runtime.index.borrow_mut().clear();
runtime.active.set(true);
runtime.has_content.set(false);
let current_state = editor.get_editor_state();
let initial_repairs = read_editor_state(Some(editor), ¤t_state, || {
sync(runtime, ¤t_state, None)
})?;
let mut cleanups: Vec<Unregister> = Vec::new();
{
let weak = editor.weak();
let runtime = runtime.clone();
cleanups.push(editor.register_update_listener(move |payload| {
let Some(editor) = upgrade(&weak) else {
return;
};
let Ok(repairs) = read_editor_state(Some(&editor), &payload.editor_state, || {
sync(&runtime, &payload.editor_state, Some(payload))
}) else {
return;
};
if !repairs.is_empty() {
if !payload.tags.iter().any(|t| t == BLOCK_ID_REPAIR_TAG) {
let _ = schedule_repair(&editor, &runtime, repairs);
} else {
crate::warnings::console_warn(
"BlockIdExtension: a repair update left blocks without a unique id; is $isIdentifiedBlock stable?",
);
}
}
}));
}
for class in editor.registered_nodes_in_order() {
let node_type = class.node_type();
if node_type == "root" || node_type == "linebreak" || (class.is_text)() {
continue;
}
let candidates = candidates.clone();
let runtime = runtime.clone();
cleanups.push(editor.register_node_transform(node_type, move |node| {
if runtime.is_identified_block(node) {
candidates.borrow_mut().add(node.get_key());
} else if get_block_id(node)?.is_some()
&& node_in(
&get_active_editor()
.expect("a transform has an editor")
.get_editor_state(),
node.get_key(),
)
.is_none()
&& !has_update_tag(COLLABORATION_TAG)
&& !has_update_tag(HISTORIC_TAG)
{
set_block_id(node, None)?;
}
Ok(())
}));
}
{
let candidates = candidates.clone();
let runtime = runtime.clone();
cleanups.push(editor.register_node_transform("root", move |_| {
let editor = get_active_editor().expect("a transform has an editor");
if editor.0.dirty.borrow().elements.contains("root")
&& !candidates.borrow().is_empty()
&& is_load(&editor, &runtime)
{
return Ok(());
}
let keys: Vec<NodeKey> = std::mem::take(&mut *candidates.borrow_mut())
.iter()
.map(str::to_owned)
.collect();
assign_block_ids(&editor, &runtime, keys)
}));
}
if !initial_repairs.is_empty() {
schedule_repair(editor, runtime, initial_repairs)?;
}
let runtime = runtime.clone();
Ok(Box::new(move || {
for cleanup in cleanups.into_iter().rev() {
cleanup();
}
runtime.active.set(false);
runtime.index.borrow_mut().clear();
*runtime.placed.borrow_mut() = Rc::new(OrderedMap::new());
*runtime.placed_state.borrow_mut() = None;
*runtime.provisional.borrow_mut() = OrderedMap::new();
*runtime.provisional_seen.borrow_mut() = OrderedSet::new();
*runtime.provisional_state.borrow_mut() = None;
*runtime.handles.borrow_mut() = None;
*runtime.scan.borrow_mut() = None;
*candidates.borrow_mut() = OrderedSet::new();
}))
}
fn active_editor() -> Result<Editor, LexicalError> {
get_active_editor().ok_or_else(|| {
LexicalError::new(
"Unable to find an active editor. This method can only be used synchronously during the callback of editor.update(), editor.read(), or editor.getEditorState().read(..., {editor}).",
)
})
}
fn get_handle_view(
editor: &Editor,
runtime: &BlockIdRuntime,
) -> Result<Rc<HandleView>, LexicalError> {
if runtime.active.get() {
let version = runtime.index.borrow().version;
if let Some((view, built_at)) = &*runtime.handles.borrow()
&& *built_at == version
{
return Ok(view.clone());
}
let table = build_handle_table(runtime.index.borrow().keys_of_id.keys());
let view = Rc::new(HandleView {
table,
scan: None,
frozen: RefCell::default(),
});
*runtime.handles.borrow_mut() = Some((view.clone(), version));
return Ok(view);
}
let committed = editor.get_editor_state();
if let Some((view, state)) = &*runtime.scan.borrow()
&& state.ptr_eq(&committed)
{
return Ok(view.clone());
}
let keys_of_id = read_editor_state(Some(editor), &committed, || {
let mut keys: OrderedMap<Vec<NodeKey>> = OrderedMap::new();
walk((), &mut |node, _| {
if runtime.is_identified_block(node)
&& let Some(id) = get_block_id(node)?
{
match keys.get_mut(&id) {
Some(list) => list.push(node.get_key().to_owned()),
None => keys.set(&id, vec![node.get_key().to_owned()]),
}
}
Ok(())
})?;
Ok::<_, LexicalError>(keys)
})?;
let table = build_handle_table(keys_of_id.keys());
let view = Rc::new(HandleView {
table,
scan: Some(keys_of_id),
frozen: RefCell::default(),
});
*runtime.scan.borrow_mut() = Some((view.clone(), committed));
Ok(view)
}
fn lookup(
runtime: &BlockIdRuntime,
view: &HandleView,
id: &str,
) -> Result<Option<NodeRef>, LexicalError> {
let Some(state) = internal_get_active_editor_state().filter(|s| s.0.read_only.get()) else {
return lookup_now(runtime, view, id);
};
{
let mut frozen = view.frozen.borrow_mut();
frozen.retain(|(state, _)| state.strong_count() > 0);
if let Some(node) = frozen
.iter()
.find(|(s, _)| std::ptr::eq(s.as_ptr(), Rc::as_ptr(&state.0)))
.and_then(|(_, found)| found.get(id))
{
return Ok(node.clone());
}
}
let node = lookup_now(runtime, view, id)?;
let mut frozen = view.frozen.borrow_mut();
match frozen
.iter_mut()
.find(|(s, _)| std::ptr::eq(s.as_ptr(), Rc::as_ptr(&state.0)))
{
Some((_, found)) => {
found.insert(id.to_owned(), node.clone());
}
None => frozen.push((
Rc::downgrade(&state.0),
HashMap::from([(id.to_owned(), node.clone())]),
)),
}
Ok(node)
}
fn lookup_now(
runtime: &BlockIdRuntime,
view: &HandleView,
id: &str,
) -> Result<Option<NodeRef>, LexicalError> {
let Some(scan) = &view.scan else {
return runtime.get_block_by_id(id);
};
let mut found: Option<NodeRef> = None;
for key in scan.get(id).into_iter().flatten() {
if let Some(node) = get_node_by_key(key)
&& is_live_identified(runtime, &node)
&& get_block_id(&node)?.as_deref() == Some(id)
&& found
.as_ref()
.is_none_or(|f| compare_document_order(&node, f) < 0)
{
found = Some(node);
}
}
Ok(found)
}
fn get_handle_of(runtime: &BlockIdRuntime, node: &NodeRef) -> Result<Option<String>, LexicalError> {
if !is_live_identified(runtime, node) {
return Ok(None);
}
let Some(id) = get_block_id(node)? else {
return Ok(None);
};
let view = get_handle_view(&active_editor()?, runtime)?;
let Some(handle) = view.table.handles.get(&id) else {
return Ok(None);
};
Ok((lookup(runtime, &view, &id)?.as_ref() == Some(node)).then(|| handle.clone()))
}
fn get_all_handles(runtime: &BlockIdRuntime) -> Result<Vec<(String, String)>, LexicalError> {
let view = get_handle_view(&active_editor()?, runtime)?;
let mut result = Vec::new();
for (id, handle) in view.table.handles.iter() {
if lookup(runtime, &view, id)?.is_some() {
result.push((id.to_owned(), handle.clone()));
}
}
Ok(result)
}
enum ReadResolution {
Id(String),
Result(BlockHandleResult),
}
fn resolve_in_read(read: &[(String, String)], handle: &str) -> ReadResolution {
let read_get = |id: &str| read.iter().find(|(k, _)| k == id).map(|(_, v)| v);
if handle.len() > HANDLE_KEY_LENGTH {
return if read_get(handle).is_some() {
ReadResolution::Id(handle.to_owned())
} else {
ReadResolution::Result(not_found(handle))
};
}
if handle.len() < MIN_BLOCK_HANDLE_LENGTH {
return ReadResolution::Result(invalid(handle, BlockHandleInvalidReason::TooShort));
}
let mut matches: Vec<(String, &str)> = Vec::new();
for (id, _) in read {
let key = handle_key(id);
if key.starts_with(handle) {
matches.push((key, id));
}
}
if matches.is_empty() {
return ReadResolution::Result(not_found(handle));
}
if matches.len() > 1 {
matches.sort_by(|(x, _), (y, _)| crate::utf16::cmp(x, y));
let candidates = matches
.iter()
.take(MAX_HANDLE_CANDIDATES)
.map(|(key, id)| read_get(id).cloned().unwrap_or_else(|| key.clone()))
.collect();
return ReadResolution::Result(BlockHandleResult::Ambiguous {
handle: handle.to_owned(),
candidates,
});
}
ReadResolution::Id(matches[0].1.to_owned())
}
fn found_or_not(node: Option<NodeRef>, handle: &str) -> BlockHandleResult {
match node {
Some(node) => BlockHandleResult::Found { node },
None => not_found(handle),
}
}
fn resolve_handle(
runtime: &BlockIdRuntime,
handle: &str,
options: Option<&BlockHandleOptions>,
) -> Result<BlockHandleResult, LexicalError> {
if !matches_block_id_pattern(handle) {
return Ok(invalid(handle, BlockHandleInvalidReason::Malformed));
}
if let Some(read) = options.and_then(|o| o.read.as_ref()) {
return Ok(match resolve_in_read(read, handle) {
ReadResolution::Result(result) => result,
ReadResolution::Id(id) => found_or_not(runtime.get_block_by_id(&id)?, handle),
});
}
if handle.len() > HANDLE_KEY_LENGTH {
return Ok(found_or_not(runtime.get_block_by_id(handle)?, handle));
}
if handle.len() < MIN_BLOCK_HANDLE_LENGTH {
return Ok(invalid(handle, BlockHandleInvalidReason::TooShort));
}
let view = get_handle_view(&active_editor()?, runtime)?;
let mut found: Option<NodeRef> = None;
let mut candidates: Vec<String> = Vec::new();
for id in ids_with_prefix(&view.table, handle) {
if let Some(node) = lookup(runtime, &view, &id)? {
found = Some(node);
if candidates.len() < MAX_HANDLE_CANDIDATES {
candidates.push(handle_in_table(&view.table, &id));
}
}
}
if candidates.len() > 1 {
return Ok(BlockHandleResult::Ambiguous {
handle: handle.to_owned(),
candidates,
});
}
Ok(found_or_not(found, handle))
}
pub type BlockIdExtensionType = LexicalExtension<BlockIdConfig, BlockIdOutput, BlockIdRuntime>;
fn make() -> Rc<BlockIdExtensionType> {
define_extension(LexicalExtension {
peer_dependencies: vec![declare_peer_dependency::<crate::json::Object>(
"@lexical/NodeStructure",
None,
)],
init: Some(Rc::new(
|_: &mut InitialEditorConfig, config: &BlockIdConfig, _: &ExtensionInitState| {
Ok(BlockIdRuntime::new(config.clone()))
},
)),
build: Some(Rc::new(
|_: &Editor, config: &BlockIdConfig, state: &ExtensionBuildState<BlockIdRuntime>| {
let runtime = state.get_init_result()?;
let (r1, r2, r3, r4) = (
runtime.clone(),
runtime.clone(),
runtime.clone(),
runtime.clone(),
);
Ok(BlockIdOutput {
disabled: signal(config.disabled),
get_block_by_id: Rc::new(move |id| r1.get_block_by_id(id)),
get_block_handle: Rc::new(move |node| get_handle_of(&r2, node)),
get_block_handles: Rc::new(move || get_all_handles(&r3)),
resolve_block_handle: Rc::new(move |handle, options| {
resolve_handle(&r4, handle, options)
}),
is_identified_block: config.is_identified_block.clone(),
})
},
)),
register: Some(Rc::new(
|editor: &Editor,
_: &BlockIdConfig,
state: &ExtensionRegisterState<BlockIdRuntime, BlockIdOutput>| {
let output = state.get_output().expect("BlockIdExtension has a build");
let runtime = state.get_init_result()?;
let editor = editor.weak();
Ok(effect(move || {
if output.disabled.value() {
return None;
}
let editor = upgrade(&editor)?;
register_block_ids(&editor, &runtime).ok()
}))
},
)),
..LexicalExtension::new("@lexical/extension/BlockId", BlockIdConfig::default())
})
}
thread_local! {
static BLOCK_ID_EXTENSION: Rc<BlockIdExtensionType> = make();
}
pub fn block_id_extension() -> Rc<BlockIdExtensionType> {
BLOCK_ID_EXTENSION.with(Rc::clone)
}