use super::import::CompiledOverlayRules;
use super::import::{
DomImportConfigOverrides, DomImportContext, DomImportRule, DomPreprocessContext,
DomPreprocessFn, ImportNext, ImportStateConfig, PreprocessNext, create_import_state,
define_import_rule, define_overlay_rules, dom_import_extension, import_overlays,
sel::{self, AttrMatch},
};
use super::internal::dom_render_extension::{dom_override, dom_render_extension};
use super::internal::types::{
DomOverrideOptions, DomRenderConfigOverrides, DomRenderMatch, DomRenderMatchConfig,
};
use crate::dom::DomNode;
use crate::extension::{
BlockIdExtensionType, Signal, block_id_extension, block_id_state, get_block_handle,
get_block_id, get_extension_dependency, get_extension_output, signal,
};
use crate::extension_core::{
ExtensionBuildState, ExtensionConfigBase, ExtensionInitState, ExtensionRegisterState,
InitialEditorConfig, LexicalExtension, config_extension, define_extension,
};
use crate::json::Value;
use crate::lexical_dom::DomExportOutput;
use crate::lexical_utils::{get_node_by_key, is_root_or_shadow_root};
use crate::node::NodeRef;
use crate::node_state::set_state;
use crate::{Editor, LexicalError};
use std::cell::RefCell;
use std::rc::Rc;
pub const BLOCK_ID_ATTRIBUTE: &str = "data-block-id";
pub const BLOCK_HANDLE_ATTRIBUTE: &str = "data-block-handle";
pub const BLOCK_WRAPPER_ID_ATTRIBUTE: &str = "data-block-wrapper-id";
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BlockIdHtmlConfig {
pub export: bool,
pub handles: bool,
pub import: bool,
}
impl Default for BlockIdHtmlConfig {
fn default() -> Self {
Self {
export: true,
handles: false,
import: true,
}
}
}
#[derive(Clone, Debug, Default)]
pub struct BlockIdHtmlConfigOverrides {
pub export: Option<bool>,
pub handles: Option<bool>,
pub import: Option<bool>,
}
impl ExtensionConfigBase for BlockIdHtmlConfig {
type Partial = BlockIdHtmlConfigOverrides;
fn shallow_merge(&self, overrides: &BlockIdHtmlConfigOverrides) -> Self {
Self {
export: overrides.export.unwrap_or(self.export),
handles: overrides.handles.unwrap_or(self.handles),
import: overrides.import.unwrap_or(self.import),
}
}
}
pub struct BlockIdHtmlOutput {
pub export: Signal<bool>,
pub handles: Signal<bool>,
pub import: Signal<bool>,
}
#[derive(Default)]
pub struct BlockIdHtmlRuntime {
imported: RefCell<Vec<String>>,
wrapper_id_lookups: std::cell::Cell<usize>,
}
impl BlockIdHtmlRuntime {
#[cfg(test)]
pub(crate) fn wrapper_id_lookups(&self) -> usize {
self.wrapper_id_lookups.get()
}
fn add(&self, key: String) {
let mut imported = self.imported.borrow_mut();
if !imported.contains(&key) {
imported.push(key);
}
}
}
pub type BlockIdHtmlExtensionType =
LexicalExtension<BlockIdHtmlConfig, BlockIdHtmlOutput, BlockIdHtmlRuntime>;
fn is_block_for_id(node: &NodeRef) -> bool {
(node.is_element() || node.is_decorator()) && !node.is_inline()
}
fn parse_attribute(value: Option<String>) -> Option<String> {
block_id_state().parse(&value.map_or(Value::Null, Value::String))
}
fn html_dependency() -> Result<(Rc<BlockIdHtmlOutput>, Rc<BlockIdHtmlRuntime>), LexicalError> {
let dep = get_extension_dependency(&block_id_html_extension())?;
let missing = || LexicalError::new("BlockIdHTMLExtension has a build and an init");
Ok((
dep.output.ok_or_else(missing)?,
dep.init.ok_or_else(missing)?,
))
}
fn is_identified_block(node: &NodeRef) -> Result<bool, LexicalError> {
let output = get_extension_output::<_, _, _>(&block_id_extension())?
.ok_or_else(|| LexicalError::new("BlockIdExtension has a build"))?;
Ok((output.is_identified_block.0)(node))
}
fn block_id_import_rule() -> DomImportRule {
define_import_rule(
Some("@lexical/html/block-id"),
sel::any().attr(BLOCK_ID_ATTRIBUTE, AttrMatch::Present),
|_: &DomImportContext, el: &DomNode, next: ImportNext<'_>| {
let nodes = next()?;
let (output, runtime) = html_dependency()?;
if !output.import.peek() {
return Ok(nodes);
}
if let Some(id) = parse_attribute(el.get_attribute(BLOCK_ID_ATTRIBUTE))
&& let Some(node) = nodes.iter().find(|node| is_block_for_id(node))
&& get_block_id(node)?.is_none()
{
set_state(node, &block_id_state(), Some(id))?;
runtime.add(node.get_key().to_owned());
}
Ok(nodes)
},
)
}
#[derive(Default)]
struct PendingWrapperIdsState {
pending: Vec<(String, String)>,
active: Vec<(String, DomNode)>,
}
impl PendingWrapperIdsState {
fn get(&self, key: &str) -> Option<&String> {
self.pending
.iter()
.find(|(k, _)| k == key)
.map(|(_, id)| id)
}
fn set(&mut self, key: String, id: String) {
match self.pending.iter_mut().find(|(k, _)| *k == key) {
Some(entry) => entry.1 = id,
None => self.pending.push((key, id)),
}
}
fn delete(&mut self, key: &str) {
self.pending.retain(|(k, _)| k != key);
}
}
#[derive(Clone)]
struct PendingWrapperIds(Rc<RefCell<PendingWrapperIdsState>>);
impl PartialEq for PendingWrapperIds {
fn eq(&self, other: &Self) -> bool {
Rc::ptr_eq(&self.0, &other.0)
}
}
fn pending_wrapper_ids() -> ImportStateConfig<Option<PendingWrapperIds>> {
thread_local! {
static STATE: ImportStateConfig<Option<PendingWrapperIds>> =
create_import_state("blockWrapperIds", || None);
}
STATE.with(Clone::clone)
}
fn block_wrapper_id_import_rule() -> DomImportRule {
define_import_rule(
Some("@lexical/html/block-wrapper-id"),
sel::any().attr(BLOCK_WRAPPER_ID_ATTRIBUTE, AttrMatch::Present),
|ctx: &DomImportContext, el: &DomNode, next: ImportNext<'_>| {
let nodes = next()?;
let (output, _) = html_dependency()?;
if !output.import.peek() {
return Ok(nodes);
}
if let Some(id) = parse_attribute(el.get_attribute(BLOCK_WRAPPER_ID_ATTRIBUTE))
&& let Some(waiting) = ctx.session.get(&pending_wrapper_ids())
&& let Some(node) = nodes.iter().find(|node| is_block_for_id(node))
{
let mut waiting = waiting.0.borrow_mut();
waiting.set(node.get_key().to_owned(), id);
waiting.active.push((node.get_key().to_owned(), el.clone()));
}
Ok(nodes)
},
)
}
fn block_wrapper_id_resolve_rule() -> DomImportRule {
define_import_rule(
Some("@lexical/html/block-wrapper-id-resolve"),
sel::any(),
|ctx: &DomImportContext, el: &DomNode, next: ImportNext<'_>| {
let waiting = ctx.session.get(&pending_wrapper_ids());
let from = waiting.as_ref().map_or(0, |w| w.0.borrow().active.len());
let nodes = next()?;
let Some(waiting) = waiting else {
return Ok(nodes);
};
let mut waiting = waiting.0.borrow_mut();
if waiting.active.len() == from {
return Ok(nodes);
}
let (_, runtime) = html_dependency()?;
let mut kept = from;
for k in from..waiting.active.len() {
runtime
.wrapper_id_lookups
.set(runtime.wrapper_id_lookups.get() + 1);
let (key, entry_el) = waiting.active[k].clone();
let Some(id) = waiting.get(&key).cloned() else {
continue;
};
let holder = get_node_by_key(&key).and_then(|node| node.get_parent());
if let Some(holder) = holder.filter(|holder| {
holder.get_children_size() == 1
&& !is_root_or_shadow_root(holder)
&& is_block_for_id(holder)
}) && get_block_id(&holder)?.is_none()
{
set_state(&holder, &block_id_state(), Some(id))?;
runtime.add(holder.get_key().to_owned());
waiting.delete(&key);
} else if entry_el == *el || entry_el.parent_element().as_ref() == Some(el) {
waiting.active[kept] = (key, entry_el);
kept += 1;
} else {
waiting.delete(&key);
}
}
waiting.active.truncate(kept);
Ok(nodes)
},
)
}
thread_local! {
static OVERLAYS: (Rc<CompiledOverlayRules>, Rc<CompiledOverlayRules>) = (
define_overlay_rules(&[
block_id_import_rule().into(),
block_wrapper_id_import_rule().into(),
]),
define_overlay_rules(&[block_wrapper_id_resolve_rule().into()]),
);
}
fn contains_wrapper_id(node: &DomNode) -> bool {
node.child_nodes().iter().any(|child| {
(child.is_element() && child.has_attribute(BLOCK_WRAPPER_ID_ATTRIBUTE))
|| contains_wrapper_id(child)
})
}
fn install_block_id_import_overlay(
dom: &DomNode,
ctx: &DomPreprocessContext,
next: PreprocessNext<'_>,
) -> Result<(), LexicalError> {
let wrapped = contains_wrapper_id(dom);
if wrapped {
ctx.session.set(
&pending_wrapper_ids(),
Some(PendingWrapperIds(Rc::default())),
);
}
let (import, resolve) = OVERLAYS.with(Clone::clone);
ctx.session.update(&import_overlays(), |mut prev| {
prev.push(import);
if wrapped {
prev.push(resolve);
}
prev
});
next()
}
fn block_id_export_override() -> Rc<DomRenderMatch> {
dom_override(
None,
DomRenderMatchConfig {
export_dom: Some(Rc::new(|_, node, next, _| {
let mut output: DomExportOutput = next()?;
let (html, _) = html_dependency()?;
let Some(element) = output.element.clone().filter(DomNode::is_element) else {
return Ok(output);
};
if !html.export.peek() || !is_identified_block(node)? {
return Ok(output);
}
if html.handles.peek() {
if let Some(handle) = get_block_handle(node)? {
element.set_attribute(BLOCK_HANDLE_ATTRIBUTE, &handle);
}
} else if let Some(id) = get_block_id(node)? {
element.set_attribute(BLOCK_ID_ATTRIBUTE, &id);
if let Some(after) = output.after.take() {
output.after = Some(Box::new(move |generated: &DomNode| {
let first = generated
.is_element()
.then(|| generated.children().first().cloned())
.flatten();
let result = after(generated)?;
if generated.is_element()
&& generated.parent_node().is_none()
&& result.as_ref() == Some(generated)
&& let Some(first) = first
&& first.parent_node().as_ref() != Some(generated)
&& first.parent_node().is_some()
{
first.set_attribute(BLOCK_WRAPPER_ID_ATTRIBUTE, &id);
}
Ok(result)
}));
}
}
Ok(output)
})),
..DomRenderMatchConfig::default()
},
DomOverrideOptions {
disabled_for_session: Some(Rc::new(|_| {
!get_extension_output(&block_id_html_extension())
.ok()
.flatten()
.is_some_and(|html| html.export.peek())
})),
..DomOverrideOptions::default()
},
)
}
fn make() -> Rc<BlockIdHtmlExtensionType> {
let block_id: Rc<BlockIdExtensionType> = block_id_extension();
define_extension(LexicalExtension {
dependencies: vec![
block_id.into(),
config_extension(
&dom_render_extension(),
[DomRenderConfigOverrides {
overrides: Some(vec![block_id_export_override()]),
..DomRenderConfigOverrides::default()
}],
),
config_extension(
&dom_import_extension(),
[DomImportConfigOverrides {
preprocess: Some(vec![
Rc::new(install_block_id_import_overlay) as DomPreprocessFn
]),
..DomImportConfigOverrides::default()
}],
),
],
init: Some(Rc::new(
|_: &mut InitialEditorConfig, _: &BlockIdHtmlConfig, _: &ExtensionInitState| {
Ok(BlockIdHtmlRuntime::default())
},
)),
build: Some(Rc::new(
|_: &Editor,
config: &BlockIdHtmlConfig,
_: &ExtensionBuildState<BlockIdHtmlRuntime>| {
Ok(BlockIdHtmlOutput {
export: signal(config.export),
handles: signal(config.handles),
import: signal(config.import),
})
},
)),
register: Some(Rc::new(
|editor: &Editor,
_: &BlockIdHtmlConfig,
state: &ExtensionRegisterState<BlockIdHtmlRuntime, BlockIdHtmlOutput>| {
let runtime = state.get_init_result()?;
Ok(editor.register_node_transform("root", move |_| {
let imported = std::mem::take(&mut *runtime.imported.borrow_mut());
for key in imported {
if let Some(node) = get_node_by_key(&key)
&& node.is_attached()
&& !is_identified_block(&node)?
{
set_state(&node, &block_id_state(), None)?;
}
}
Ok(())
}))
},
)),
..LexicalExtension::new("@lexical/html/BlockIdHTML", BlockIdHtmlConfig::default())
})
}
thread_local! {
static BLOCK_ID_HTML_EXTENSION: Rc<BlockIdHtmlExtensionType> = make();
}
pub fn block_id_html_extension() -> Rc<BlockIdHtmlExtensionType> {
BLOCK_ID_HTML_EXTENSION.with(Rc::clone)
}