use super::import_dependencies;
use super::table_node::{
is_scrollable_tables_active, set_scrollable_tables_active, set_sticky_scrollbar_active,
};
use super::table_nodes;
use super::table_plugin_helpers::{register_table_cell_unmerge_transform, register_table_plugin};
use super::table_selection_helpers::register_table_selection_observer;
use crate::editor::DirtyType;
use crate::extension::named_signals_config;
use crate::extension::signals::effect;
use crate::extension_core::{
ExtensionBuildState, ExtensionRegisterState, LexicalExtension, define_extension,
};
use crate::merge_register::merge_register;
use crate::updates::get_active_editor;
use crate::{Editor, UpdateOptions};
use std::cell::Cell;
use std::rc::Rc;
named_signals_config! {
pub struct TableConfig;
pub struct TableConfigOverrides;
pub struct TableOutput {
has_cell_merge: bool,
has_cell_background_color: bool,
has_tab_handler: bool,
has_horizontal_scroll: bool,
has_sticky_scrollbar: bool,
has_nested_tables: bool,
}
}
pub type TableExtensionType = LexicalExtension<TableConfig, TableOutput, ()>;
fn full_reconcile(editor: &Editor) {
let _ = editor.update(
|| {
if let Some(editor) = get_active_editor() {
editor.0.dirty.borrow_mut().dirty_type = DirtyType::FullReconcile;
}
Ok(())
},
UpdateOptions::default(),
);
}
fn make_table_extension() -> Rc<TableExtensionType> {
define_extension(LexicalExtension {
build: Some(Rc::new(
|_: &Editor, config: &TableConfig, _: &ExtensionBuildState<()>| {
Ok(TableOutput::of(config))
},
)),
dependencies: import_dependencies(),
nodes: table_nodes(),
register: Some(Rc::new(
|editor: &Editor, _: &TableConfig, state: &ExtensionRegisterState<(), TableOutput>| {
let stores = state.get_output().expect("TableExtension has a build");
let prev_sticky = Rc::new(Cell::new(false));
let (weak, s) = (editor.weak(), stores.clone());
let scroll = effect(move || {
let has_horizontal_scroll = s.has_horizontal_scroll.value();
let has_sticky = s.has_sticky_scrollbar.value() && has_horizontal_scroll;
let editor = weak.upgrade().map(Editor)?;
let had_horizontal_scroll = is_scrollable_tables_active(&editor);
if had_horizontal_scroll != has_horizontal_scroll {
set_scrollable_tables_active(&editor, has_horizontal_scroll);
}
set_sticky_scrollbar_active(&editor, has_sticky);
if had_horizontal_scroll != has_horizontal_scroll
|| prev_sticky.get() != has_sticky
{
full_reconcile(&editor);
}
prev_sticky.set(has_sticky);
None
});
let s = stores.clone();
let plugin = register_table_plugin(editor, move || s.has_nested_tables.peek())?;
let (weak, s) = (editor.weak(), stores.clone());
let observer = effect(move || {
let has_tab_handler = s.has_tab_handler.value();
let editor = weak.upgrade().map(Editor)?;
Some(register_table_selection_observer(&editor, has_tab_handler))
});
let (weak, s) = (editor.weak(), stores.clone());
let unmerge = effect(move || {
if s.has_cell_merge.value() {
return None;
}
let editor = weak.upgrade().map(Editor)?;
Some(register_table_cell_unmerge_transform(&editor))
});
let (weak, s) = (editor.weak(), stores);
let background = effect(move || {
if s.has_cell_background_color.value() {
return None;
}
let editor = weak.upgrade().map(Editor)?;
Some(editor.register_node_transform("tablecell", |node| {
if node.get_background_color().is_some() {
node.set_background_color(None);
}
Ok(())
}))
});
Ok(merge_register(vec![
scroll, plugin, observer, unmerge, background,
]))
},
)),
..LexicalExtension::new(
"@lexical/table/Table",
TableConfig {
has_cell_background_color: true,
has_cell_merge: true,
has_horizontal_scroll: true,
has_nested_tables: false,
has_sticky_scrollbar: false,
has_tab_handler: true,
},
)
})
}
thread_local! {
static TABLE_EXTENSION: Rc<TableExtensionType> = make_table_extension();
}
pub fn table_extension() -> Rc<TableExtensionType> {
TABLE_EXTENSION.with(Rc::clone)
}