use crate::lexical_selection::get_selection;
use crate::link::is_link_node;
use crate::menu::{MenuOption, MenuSelectOption, NodeMenu};
use crate::merge_register::merge_register;
use crate::updates::on_update;
use crate::{
COMMAND_PRIORITY_BEFORE_EDITOR, COMMAND_PRIORITY_EDITOR, Editor, EditorReadMode,
LexicalCommand, LexicalError, MutationListenerOptions, NodeKey, NodeMutation, NodeRef,
PASTE_COMMAND, PASTE_TAG, PasteCommandType, Unregister, UpdateOptions, get_node_by_key,
};
use std::any::Any;
use std::cell::{Cell, RefCell};
use std::rc::Rc;
#[derive(Clone)]
pub struct EmbedMatchResult {
pub url: String,
pub id: String,
pub data: Option<Rc<dyn Any>>,
}
pub trait EmbedConfig {
fn embed_type(&self) -> &str;
fn parse_url(&self, _text: &str) -> Option<EmbedMatchResult> {
None
}
fn parse_url_async(&self, text: &str, done: ParseUrlDone) {
done.resolve(self.parse_url(text));
}
fn insert_node(&self, editor: &Editor, result: &EmbedMatchResult) -> Result<(), LexicalError>;
}
pub struct ParseUrlDone(Option<Box<dyn FnOnce(Option<EmbedMatchResult>)>>);
impl ParseUrlDone {
pub fn resolve(mut self, result: Option<EmbedMatchResult>) {
if let Some(resolve) = self.0.take() {
resolve(result);
}
}
}
pub const INSERT_EMBED_COMMAND: LexicalCommand<String> =
LexicalCommand::constant(u64::MAX - 30, "INSERT_EMBED_COMMAND");
pub struct AutoEmbedOption {
pub title: String,
pub on_select: Rc<dyn Fn(Option<NodeRef>) -> Result<(), LexicalError>>,
}
impl MenuOption for AutoEmbedOption {
fn key(&self) -> &str {
&self.title
}
fn title(&self) -> Option<&str> {
Some(&self.title)
}
}
fn is_word(unit: u16) -> bool {
matches!(unit, 0x30..=0x39 | 0x41..=0x5A | 0x61..=0x7A | 0x5F)
}
fn is_host_unit(unit: u16) -> bool {
is_word(unit) && unit != 0x5F || b"-@:%._+~#=".iter().any(|&c| u16::from(c) == unit)
}
fn is_tld_unit(unit: u16) -> bool {
is_word(unit) && unit != 0x5F || unit == u16::from(b'(') || unit == u16::from(b')')
}
fn is_path_unit(unit: u16) -> bool {
is_word(unit) || b"-()@:%+.~#?&/=".iter().any(|&c| u16::from(c) == unit)
}
fn match_url_at(units: &[u16], start: usize) -> Option<usize> {
let has = |at: usize, text: &str| {
text.encode_utf16()
.enumerate()
.all(|(i, u)| units.get(at + i) == Some(&u))
};
let mut prefixes = Vec::new();
if has(start, "http") {
let scheme = if has(start + 4, "s") {
start + 5
} else {
start + 4
};
if has(scheme, "://") {
let after = scheme + 3;
if has(after, "www.") {
prefixes.push(after + 4);
}
prefixes.push(after);
}
}
if has(start, "www.") {
prefixes.push(start + 4);
}
prefixes.into_iter().find_map(|prefix| {
let host_max = units[prefix..]
.iter()
.take(256)
.take_while(|&&u| is_host_unit(u))
.count();
(1..=host_max).rev().find_map(|host| {
let dot = prefix + host;
if units.get(dot) != Some(&u16::from(b'.')) {
return None;
}
let tld_max = units[dot + 1..]
.iter()
.take(6)
.take_while(|&&u| is_tld_unit(u))
.count();
(1..=tld_max).rev().find_map(|tld| {
let end = dot + 1 + tld;
let before = is_word(units[end - 1]);
let after = units.get(end).is_some_and(|&u| is_word(u));
(before != after).then(|| {
end + units[end..]
.iter()
.take_while(|&&u| is_path_unit(u))
.count()
})
})
})
})
}
pub fn url_matcher(text: &str) -> Option<(usize, String)> {
let units: Vec<u16> = text.encode_utf16().collect();
(0..units.len()).find_map(|start| {
match_url_at(&units, start).map(|end| (start, String::from_utf16_lossy(&units[start..end])))
})
}
pub fn is_single_token(text: &str) -> bool {
!text.is_empty()
&& !text
.chars()
.any(crate::selection_deletion::is_js_whitespace)
}
pub type GetMenuOptions =
Rc<dyn Fn(&Rc<dyn EmbedConfig>, Rc<dyn Fn()>, Rc<dyn Fn()>) -> Vec<Rc<AutoEmbedOption>>>;
pub type OpenEmbedModalForConfig = Rc<dyn Fn(&Rc<dyn EmbedConfig>)>;
pub type DisableMenuFor = Rc<dyn Fn(&NodeRef) -> bool>;
pub struct AutoEmbedConfig {
pub embed_configs: Vec<Rc<dyn EmbedConfig>>,
pub get_menu_options: GetMenuOptions,
pub on_open_embed_modal_for_config: Option<OpenEmbedModalForConfig>,
pub disable_menu_for: Option<DisableMenuFor>,
pub menu_command_priority: i8,
}
#[derive(Clone)]
struct EmbedMatch {
embed_config: Rc<dyn EmbedConfig>,
key: NodeKey,
result: EmbedMatchResult,
url: String,
}
struct AutoEmbedState {
editor: Editor,
config: AutoEmbedConfig,
menu: NodeMenu<AutoEmbedOption>,
embed_match: RefCell<Option<EmbedMatch>>,
is_single_token_paste: Cell<bool>,
latest_check: Cell<u64>,
}
fn get_current_link(key: &str, url: &str) -> Option<NodeRef> {
get_node_by_key(key).filter(|link| {
is_link_node(link) && link.is_attached() && link.get_url().as_deref() == Some(url)
})
}
impl AutoEmbedState {
fn is_menu_disabled_for_node(&self, link: &NodeRef) -> bool {
self.config
.disable_menu_for
.as_ref()
.is_some_and(|f| f(link))
}
fn reset(self: &Rc<Self>) {
if self.embed_match.borrow_mut().take().is_some() {
self.render();
}
}
fn render(self: &Rc<Self>) {
let embed_match = self.embed_match.borrow().clone();
match embed_match {
None => {
self.menu.set_node_key(None);
self.menu.menu().set_options(Vec::new());
}
Some(embed_match) => {
let (embed, dismiss) = (Rc::downgrade(self), Rc::downgrade(self));
let options = (self.config.get_menu_options)(
&embed_match.embed_config,
Rc::new(move || {
if let Some(state) = embed.upgrade() {
state.embed_link_via_active_embed_config();
}
}),
Rc::new(move || {
if let Some(state) = dismiss.upgrade() {
state.reset();
}
}),
);
self.menu.set_node_key(Some(embed_match.key));
self.menu.menu().set_options(options);
}
}
}
fn check_if_link_node_is_embeddable(self: &Rc<Self>, key: &str) {
let check = self.latest_check.get() + 1;
self.latest_check.set(check);
let url = self.editor.get_editor_state().read(|| {
let link = get_node_by_key(key).filter(is_link_node)?;
if self.is_menu_disabled_for_node(&link) {
return None;
}
link.get_url()
});
let Some(url) = url else { return };
self.try_embed_config(self.config.embed_configs.len(), check, key.to_owned(), url);
}
fn try_embed_config(self: &Rc<Self>, index: usize, check: u64, key: NodeKey, url: String) {
let Some(index) = index.checked_sub(1) else {
return;
};
let embed_config = self.config.embed_configs[index].clone();
let state = Rc::downgrade(self);
let (parsed_config, parsed_url) = (embed_config.clone(), url.clone());
embed_config.parse_url_async(
&url,
ParseUrlDone(Some(Box::new(move |result| {
let Some(state) = state.upgrade() else { return };
if check != state.latest_check.get() {
return;
}
let Some(result) = result else {
state.try_embed_config(index, check, key, parsed_url);
return;
};
let embeddable = state
.editor
.read_with_mode(EditorReadMode::Pending, || {
get_current_link(&key, &parsed_url)
.is_some_and(|link| !state.is_menu_disabled_for_node(&link))
})
.unwrap_or(false);
if embeddable {
*state.embed_match.borrow_mut() = Some(EmbedMatch {
embed_config: parsed_config,
key,
result,
url: parsed_url,
});
state.render();
}
}))),
);
}
fn embed_link_via_active_embed_config(&self) {
let Some(EmbedMatch {
embed_config,
key,
result,
url,
}) = self.embed_match.borrow().clone()
else {
return;
};
let editor = self.editor.clone();
let outcome = self.editor.update(
move || {
let Some(link) = get_current_link(&key, &url) else {
return Ok(());
};
if get_selection().is_none() {
link.select_end()?;
}
embed_config.insert_node(&editor, &result)?;
if link.is_attached() {
link.remove(false)?;
}
Ok(())
},
UpdateOptions::default(),
);
let _ = outcome;
}
}
pub fn register_auto_embed(
editor: &Editor,
config: AutoEmbedConfig,
) -> Result<(NodeMenu<AutoEmbedOption>, Unregister), LexicalError> {
let on_select_option: MenuSelectOption<AutoEmbedOption> =
Rc::new(|option, target_node, close_menu, _| {
(option.on_select)(target_node)?;
close_menu();
Ok(())
});
let menu_command_priority = config.menu_command_priority;
let state = Rc::new(AutoEmbedState {
editor: editor.clone(),
config,
menu: NodeMenu::new(editor, on_select_option, menu_command_priority),
embed_match: RefCell::new(None),
is_single_token_paste: Cell::new(false),
latest_check: Cell::new(0),
});
let closing = Rc::downgrade(&state);
*state.menu.menu().callbacks().on_close.borrow_mut() = Some(Rc::new(move || {
if let Some(state) = closing.upgrade() {
state.reset();
}
}));
let pasting = Rc::downgrade(&state);
let mut unregisters = vec![editor.register_command(
&PASTE_COMMAND,
move |payload, _| {
let Some(state) = pasting.upgrade() else {
return Ok(false);
};
let is_single_token_paste = match payload {
PasteCommandType::Clipboard(event) => event
.clipboard_data
.as_ref()
.is_some_and(|data| is_single_token(&data.get_data("text/plain"))),
PasteCommandType::Input(_) | PasteCommandType::Keyboard(_) => false,
};
state.is_single_token_paste.set(is_single_token_paste);
if is_single_token_paste {
let state = Rc::downgrade(&state);
on_update(move || {
if let Some(state) = state.upgrade() {
state.is_single_token_paste.set(false);
}
});
}
Ok(false)
},
COMMAND_PRIORITY_BEFORE_EDITOR,
)];
for node_type in ["link", "autolink"] {
let listening = Rc::downgrade(&state);
unregisters.push(editor.register_mutation_listener(
node_type,
move |mutations, payload| {
let Some(state) = listening.upgrade() else {
return;
};
for (key, mutation) in mutations {
let node_key = state.embed_match.borrow().as_ref().map(|m| m.key.clone());
if *mutation == NodeMutation::Created
&& payload.update_tags.iter().any(|t| t == PASTE_TAG)
&& state.is_single_token_paste.get()
{
state.check_if_link_node_is_embeddable(key);
} else if node_key.as_ref() == Some(key) {
state.reset();
}
}
},
MutationListenerOptions {
skip_initialization: true,
},
)?);
}
if state.config.on_open_embed_modal_for_config.is_some() {
let opening = Rc::downgrade(&state);
unregisters.push(editor.register_command(
&INSERT_EMBED_COMMAND,
move |embed_config_type, _| {
let Some(state) = opening.upgrade() else {
return Ok(false);
};
let Some(embed_config) = state
.config
.embed_configs
.iter()
.find(|c| c.embed_type() == embed_config_type)
else {
return Ok(false);
};
if let Some(open) = &state.config.on_open_embed_modal_for_config {
open(embed_config);
}
Ok(true)
},
COMMAND_PRIORITY_EDITOR,
));
}
let menu = state.menu.clone();
let unregister = merge_register(unregisters);
Ok((
menu,
Box::new(move || {
unregister();
state.reset();
}),
))
}