Lines
1.18 %
Functions
0.66 %
Branches
100 %
//! Split management for transaction forms.
use wasm_bindgen::JsCast;
use wasm_bindgen::prelude::*;
use web_sys::{Element, HtmlElement, HtmlInputElement};
use crate::autocomplete;
/// Returns the current number of split entries in the DOM.
/// Exported to window for htmx hx-vals usage.
#[wasm_bindgen(js_name = getSplitCount)]
#[must_use]
pub fn get_split_count() -> u32 {
web_sys::window()
.and_then(|w| w.document())
.and_then(|d| d.query_selector_all(".split-entry").ok())
.map_or(0, |list| list.length())
}
/// Sets up event handlers for split management.
pub fn setup_split_handlers() {
setup_split_removal_handler();
setup_currency_change_handler();
fn setup_split_removal_handler() {
let Some(document) = web_sys::window().and_then(|w| w.document()) else {
return;
};
let callback = Closure::wrap(Box::new(move |event: web_sys::MouseEvent| {
let Some(target) = event.target() else {
let Ok(el) = target.dyn_into::<HtmlElement>() else {
if !el.class_list().contains("remove-split-btn") {
handle_split_removal(&el);
}) as Box<dyn FnMut(_)>);
let _ = document.add_event_listener_with_callback("click", callback.as_ref().unchecked_ref());
callback.forget();
fn handle_split_removal(button: &HtmlElement) {
let split_count = document
.query_selector_all(".split-entry")
.map_or(0, |list| list.length());
if split_count <= 1 {
if let Some(window) = web_sys::window() {
let _ = window.alert_with_message(
"Cannot remove the last split. At least one split is required.",
);
let Some(split_entry) = button.closest(".split-entry").ok().flatten() else {
split_entry.remove();
update_split_labels();
fn update_split_labels() {
let Ok(splits) = document.query_selector_all(".split-entry") else {
for i in 0..splits.length() {
let Some(node) = splits.get(i) else {
continue;
let Ok(split) = node.dyn_into::<Element>() else {
if let Some(label) = split.query_selector(".split-label").ok().flatten() {
label.set_text_content(Some(&format!("Split {}", i + 1)));
let _ = split.set_attribute("data-split-index", &i.to_string());
fn setup_currency_change_handler() {
let callback = Closure::wrap(Box::new(move |event: web_sys::Event| {
let Ok(input) = target.dyn_into::<HtmlInputElement>() else {
let class_list = input.class_name();
if !class_list.contains("commodity-value") {
let Some(split_entry) = input.closest(".split-entry").ok().flatten() else {
check_currency_mismatch(&split_entry);
let _ = document.add_event_listener_with_callback("change", callback.as_ref().unchecked_ref());
fn check_currency_mismatch(split_entry: &Element) {
let from_commodity = split_entry
.query_selector(r#".commodity-value[data-field="from-commodity"]"#)
.ok()
.flatten()
.and_then(|el| el.dyn_into::<HtmlInputElement>().ok())
.map(|input| input.value());
let to_commodity = split_entry
.query_selector(r#".commodity-value[data-field="to-commodity"]"#)
let Some(amount_converted_group) = split_entry
.query_selector(".amount-converted-group")
else {
let show_converted = match (from_commodity, to_commodity) {
(Some(from), Some(to)) if !from.is_empty() && !to.is_empty() => from != to,
_ => false,
if show_converted {
let _ = amount_converted_group.class_list().remove_1("hidden-field");
} else {
let _ = amount_converted_group.class_list().add_1("hidden-field");
/// Initializes the transaction form on page load.
pub fn initialize_transaction_form() {
let Some(window) = web_sys::window() else {
let Some(document) = window.document() else {
set_default_datetime(&document);
fetch_initial_split();
fn set_default_datetime(document: &web_sys::Document) {
let Some(date_input) = document
.get_element_by_id("date")
let current_value = date_input.value();
if current_value.is_empty() {
set_current_local_time(&date_input);
convert_utc_to_local(&date_input, ¤t_value);
fn set_current_local_time(date_input: &HtmlInputElement) {
let now = js_sys::Date::new_0();
let offset_ms = now.get_timezone_offset() * 60.0 * 1000.0;
let local_time = now.get_time() - offset_ms;
let local_date = js_sys::Date::new(&JsValue::from_f64(local_time));
let iso_string = local_date.to_iso_string();
let datetime_local = iso_string
.as_string()
.map(|s| s.chars().take(16).collect::<String>())
.unwrap_or_default();
date_input.set_value(&datetime_local);
fn convert_utc_to_local(date_input: &HtmlInputElement, utc_value: &str) {
let utc_string = format!("{utc_value}Z");
let utc_date = js_sys::Date::new(&JsValue::from_str(&utc_string));
if utc_date.get_time().is_nan() {
let offset_ms = utc_date.get_timezone_offset() * 60.0 * 1000.0;
let local_time = utc_date.get_time() - offset_ms;
fn fetch_initial_split() {
let Some(container) = document.get_element_by_id("splits-container") else {
autocomplete::init_all();
// If there are already splits (pre-rendered), handle prefill.
if container
.query_selector(".split-entry")
.is_some()
{
wasm_bindgen_futures::spawn_local(async move {
apply_prefill().await;
});
// Fallback: fetch the initial split if none exists
let url = "/api/transaction/split/create?display_index=0";
let Ok(response) = fetch_text(url).await else {
web_sys::console::error_1(&"Error loading initial split".into());
container.set_inner_html(&response);
/// Applies whichever prefill the page requested: a single from-account
/// (`window.prefilledFromAccount`) or a full template draft
/// (`window.prefilledDraft`). The draft path wins when present.
async fn apply_prefill() {
if get_prefilled_draft().is_some() {
prefill_from_draft().await;
} else if let Some(account) = get_prefilled_account() {
prefill_from_account(&account).await;
async fn fetch_text(url: &str) -> Result<String, JsValue> {
let window = web_sys::window().ok_or("no window")?;
let response = wasm_bindgen_futures::JsFuture::from(window.fetch_with_str(url)).await?;
let response: web_sys::Response = response.dyn_into()?;
let text = wasm_bindgen_futures::JsFuture::from(response.text()?).await?;
text.as_string().ok_or_else(|| "not a string".into())
async fn fetch_json(url: &str) -> Result<String, JsValue> {
let headers = web_sys::Headers::new()?;
headers.set("Accept", "application/json")?;
let opts = web_sys::RequestInit::new();
opts.set_method("GET");
opts.set_headers(&headers);
let request = web_sys::Request::new_with_str_and_init(url, &opts)?;
let response =
wasm_bindgen_futures::JsFuture::from(window.fetch_with_request(&request)).await?;
fn get_prefilled_account() -> Option<String> {
let window = web_sys::window()?;
js_sys::Reflect::get(&window, &"prefilledFromAccount".into())
.and_then(|v| v.as_string())
async fn prefill_from_account(account_id: &str) {
let Some(first_split) = document.query_selector(".split-entry").ok().flatten() else {
let Some(hidden_input) = first_split
.query_selector(r#".account-value[data-field="from-account"]"#)
let Some(display_input) = first_split
.query_selector(r#".account-display[data-field="from-account"]"#)
hidden_input.set_value(account_id);
let Ok(accounts_json) = fetch_json("/api/account/list").await else {
let Ok(accounts) = serde_json::from_str::<Vec<AccountInfo>>(&accounts_json) else {
if let Some(account) = accounts.iter().find(|a| a.id == account_id) {
display_input.set_value(&account.name);
#[derive(serde::Deserialize)]
struct AccountInfo {
id: String,
name: String,
struct CommodityInfo {
symbol: String,
/// A template-rendered transfer row (matches the server's `PrefilledRow`).
#[derive(serde::Deserialize, Default)]
struct PrefilledRow {
amount: String,
from_account: String,
from_commodity: String,
to_account: String,
to_commodity: String,
amount_converted: Option<String>,
#[serde(default)]
from_tags: Vec<PrefilledTag>,
to_tags: Vec<PrefilledTag>,
struct PrefilledTag {
value: String,
struct PrefilledDraft {
note: Option<String>,
date: Option<String>,
rows: Vec<PrefilledRow>,
tags: Vec<PrefilledTag>,
fn get_prefilled_draft() -> Option<PrefilledDraft> {
let value = js_sys::Reflect::get(&window, &"prefilledDraft".into()).ok()?;
if value.is_undefined() || value.is_null() {
return None;
serde_wasm_bindgen::from_value(value).ok()
/// Fills the form from a rendered template draft: note, date, every transfer
/// row (adding rows as needed), and transaction-level tags. Display names are
/// resolved from the account/commodity list endpoints; the submitted hidden
/// inputs always carry the canonical uuids.
async fn prefill_from_draft() {
let Some(draft) = get_prefilled_draft() else {
if let Some(note) = draft.note.as_deref() {
set_input_value_by_id(&document, "note", note);
if let Some(date) = draft.date.as_deref() {
set_input_value_by_id(&document, "date", date);
// Resolve display-name lookups once, shared across rows.
let accounts = fetch_json("/api/account/list")
.await
.and_then(|j| serde_json::from_str::<Vec<AccountInfo>>(&j).ok())
let commodities = fetch_json("/api/commodity/list")
.and_then(|j| serde_json::from_str::<Vec<CommodityInfo>>(&j).ok())
for (index, row) in draft.rows.iter().enumerate() {
ensure_split_row(&document, index).await;
let Some(split) = nth_split_entry(&document, index) else {
fill_split_row(&split, row, &accounts, &commodities);
prefill_split_tags(&document, &split, index, row);
prefill_tags(&document, &draft.tags);
/// Appends each rendered transaction-level tag as a committed tag row so the
/// form submits them — the rendered draft's tags are preserved, not dropped.
fn prefill_tags(document: &web_sys::Document, tags: &[PrefilledTag]) {
if tags.is_empty() {
let Some(container) = document
.query_selector(".entity-tags-container")
for tag in tags {
crate::entity_form_tag::append_entity_form_tag(
document, &container, &tag.name, &tag.value, "",
crate::autocomplete::init_all();
/// Appends the draft's per-split tags onto a split row. The create form's
/// split-tag rows apply to BOTH legs of the transfer (a row mirrors from→to at
/// submit), so the split's debit and credit draft tags are merged and
/// de-duplicated into one set of rows rather than added per leg. (`prefill.rs`
/// still tracks them per leg for fidelity; the form can't express a single-leg
/// split tag.)
fn prefill_split_tags(
document: &web_sys::Document,
split: &Element,
index: usize,
row: &PrefilledRow,
) {
if row.from_tags.is_empty() && row.to_tags.is_empty() {
let Some(container) = split.query_selector(".split-tags-container").ok().flatten() else {
let idx = index.to_string();
let mut seen: Vec<(&str, &str)> = Vec::new();
for tag in row.from_tags.iter().chain(row.to_tags.iter()) {
let key = (tag.name.as_str(), tag.value.as_str());
if seen.contains(&key) {
seen.push(key);
super::split_tag::append_split_tag(document, &container, &idx, &tag.name, &tag.value);
fn account_name<'a>(accounts: &'a [AccountInfo], id: &str) -> Option<&'a str> {
accounts
.iter()
.find(|a| a.id == id)
.map(|a| a.name.as_str())
fn commodity_symbol<'a>(commodities: &'a [CommodityInfo], id: &str) -> Option<&'a str> {
commodities
.find(|c| c.id == id)
.map(|c| c.symbol.as_str())
fn fill_split_row(
accounts: &[AccountInfo],
commodities: &[CommodityInfo],
set_split_input(split, "input[data-field=\"amount\"]", &row.amount);
if let Some(converted) = row.amount_converted.as_deref() {
set_split_input(split, "input[data-field=\"amount-converted\"]", converted);
fill_entity_field(
split,
".account-value[data-field=\"from-account\"]",
".account-display[data-field=\"from-account\"]",
&row.from_account,
account_name(accounts, &row.from_account),
".account-value[data-field=\"to-account\"]",
".account-display[data-field=\"to-account\"]",
&row.to_account,
account_name(accounts, &row.to_account),
".commodity-value[data-field=\"from-commodity\"]",
".commodity-display[data-field=\"from-commodity\"]",
&row.from_commodity,
commodity_symbol(commodities, &row.from_commodity),
".commodity-value[data-field=\"to-commodity\"]",
".commodity-display[data-field=\"to-commodity\"]",
&row.to_commodity,
commodity_symbol(commodities, &row.to_commodity),
/// Sets a row's hidden uuid input and its display label. The hidden input
/// carries the canonical uuid (always submitted); the display shows the
/// resolved name, falling back to the uuid if the lookup missed.
fn fill_entity_field(
hidden_selector: &str,
display_selector: &str,
id: &str,
display: Option<&str>,
if let Some(hidden) = query_input(split, hidden_selector) {
hidden.set_value(id);
if let Some(input) = query_input(split, display_selector) {
input.set_value(display.unwrap_or(id));
fn query_input(root: &Element, selector: &str) -> Option<HtmlInputElement> {
root.query_selector(selector)
fn set_split_input(split: &Element, selector: &str, value: &str) {
if let Some(input) = query_input(split, selector) {
input.set_value(value);
fn set_input_value_by_id(document: &web_sys::Document, id: &str, value: &str) {
if let Some(input) = document
.get_element_by_id(id)
fn nth_split_entry(document: &web_sys::Document, index: usize) -> Option<Element> {
document
.and_then(|list| list.item(index as u32))
.and_then(|node| node.dyn_into::<Element>().ok())
/// Ensures a split row at `index` exists, fetching and appending one (with the
/// correct `display_index`) when the draft has more rows than the form. Row 0
/// is always pre-rendered.
async fn ensure_split_row(document: &web_sys::Document, index: usize) {
if nth_split_entry(document, index).is_some() {
let url = format!("/api/transaction/split/create?display_index={index}");
let Ok(html) = fetch_text(&url).await else {
let _ = container.insert_adjacent_html("beforeend", &html);
#[cfg(test)]
mod tests {
#[test]
fn split_index_format() {
let index = 2u32;
let label = format!("Split {}", index + 1);
assert_eq!(label, "Split 3");