use super::convert::{array, col_at, row_at};
use super::{Book, js};
use crate::coordinate::{CellRef, Col, Range, Row};
use crate::edit::{Axis, CopyOrigin, SortBy, SortKey, SortOptions};
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
impl Book {
#[wasm_bindgen(js_name = insertRows)]
#[expect(
clippy::needless_pass_by_value,
reason = "an optional string crosses the wasm boundary owned"
)]
pub fn insert_rows(
&mut self,
sheet: usize,
at: u32,
count: u32,
#[wasm_bindgen(
js_name = "copyOrigin",
unchecked_optional_param_type = "\"before\" | \"after\" | \"none\""
)]
copy_origin: Option<String>,
) -> Result<(), JsError> {
let row = Row::from_one_based(u64::from(at)).map_err(js)?;
let origin = copy_origin_of(copy_origin.as_deref())?;
let done = crate::edit::insert_rows_with(&mut self.workbook, sheet, row, count, origin);
self.edited(done)
}
#[wasm_bindgen(js_name = removeRows)]
pub fn remove_rows(&mut self, sheet: usize, at: u32, count: u32) -> Result<(), JsError> {
let row = Row::from_one_based(u64::from(at)).map_err(js)?;
let done = crate::edit::remove_rows(&mut self.workbook, sheet, row, count);
self.edited(done)
}
#[wasm_bindgen(js_name = insertColumns)]
#[expect(
clippy::needless_pass_by_value,
reason = "an optional string crosses the wasm boundary owned"
)]
pub fn insert_columns(
&mut self,
sheet: usize,
at: u32,
count: u32,
#[wasm_bindgen(
js_name = "copyOrigin",
unchecked_optional_param_type = "\"before\" | \"after\" | \"none\""
)]
copy_origin: Option<String>,
) -> Result<(), JsError> {
let col = Col::from_one_based(u64::from(at)).map_err(js)?;
let origin = copy_origin_of(copy_origin.as_deref())?;
let done = crate::edit::insert_columns_with(&mut self.workbook, sheet, col, count, origin);
self.edited(done)
}
#[wasm_bindgen(js_name = removeColumns)]
pub fn remove_columns(&mut self, sheet: usize, at: u32, count: u32) -> Result<(), JsError> {
let col = Col::from_one_based(u64::from(at)).map_err(js)?;
let done = crate::edit::remove_columns(&mut self.workbook, sheet, col, count);
self.edited(done)
}
#[wasm_bindgen(js_name = insertRowsMany)]
#[expect(
clippy::needless_pass_by_value,
reason = "an optional string crosses the wasm boundary owned"
)]
pub fn insert_rows_many(
&mut self,
sheet: usize,
#[wasm_bindgen(unchecked_param_type = "[number, number][]")] places: &JsValue,
#[wasm_bindgen(
js_name = "copyOrigin",
unchecked_optional_param_type = "\"before\" | \"after\" | \"none\""
)]
copy_origin: Option<String>,
) -> Result<(), JsError> {
let at = places_of(places, row_at)?;
let origin = copy_origin_of(copy_origin.as_deref())?;
let done = crate::edit::insert_rows_many(&mut self.workbook, sheet, &at, origin);
self.edited(done)
}
#[wasm_bindgen(js_name = removeRowsMany)]
pub fn remove_rows_many(
&mut self,
sheet: usize,
#[wasm_bindgen(unchecked_param_type = "[number, number][]")] places: &JsValue,
) -> Result<(), JsError> {
let spans = places_of(places, row_at)?;
let done = crate::edit::remove_rows_many(&mut self.workbook, sheet, &spans);
self.edited(done)
}
#[wasm_bindgen(js_name = insertColumnsMany)]
#[expect(
clippy::needless_pass_by_value,
reason = "an optional string crosses the wasm boundary owned"
)]
pub fn insert_columns_many(
&mut self,
sheet: usize,
#[wasm_bindgen(unchecked_param_type = "[number, number][]")] places: &JsValue,
#[wasm_bindgen(
js_name = "copyOrigin",
unchecked_optional_param_type = "\"before\" | \"after\" | \"none\""
)]
copy_origin: Option<String>,
) -> Result<(), JsError> {
let at = places_of(places, col_at)?;
let origin = copy_origin_of(copy_origin.as_deref())?;
let done = crate::edit::insert_columns_many(&mut self.workbook, sheet, &at, origin);
self.edited(done)
}
#[wasm_bindgen(js_name = removeColumnsMany)]
pub fn remove_columns_many(
&mut self,
sheet: usize,
#[wasm_bindgen(unchecked_param_type = "[number, number][]")] places: &JsValue,
) -> Result<(), JsError> {
let spans = places_of(places, col_at)?;
let done = crate::edit::remove_columns_many(&mut self.workbook, sheet, &spans);
self.edited(done)
}
#[wasm_bindgen(js_name = insertCells)]
#[expect(
clippy::needless_pass_by_value,
reason = "an optional string crosses the wasm boundary owned"
)]
pub fn insert_cells(
&mut self,
sheet: usize,
range: &str,
#[wasm_bindgen(unchecked_param_type = "\"down\" | \"right\"")] shift: &str,
#[wasm_bindgen(
js_name = "copyOrigin",
unchecked_optional_param_type = "\"before\" | \"after\" | \"none\""
)]
copy_origin: Option<String>,
) -> Result<(), JsError> {
let area = Range::parse(range).map_err(js)?;
let origin = copy_origin_of(copy_origin.as_deref())?;
let done = crate::edit::insert_cells_with(
&mut self.workbook,
sheet,
area,
axis_of(shift)?,
origin,
);
self.edited(done)
}
#[wasm_bindgen(js_name = removeCells)]
pub fn remove_cells(
&mut self,
sheet: usize,
range: &str,
#[wasm_bindgen(unchecked_param_type = "\"up\" | \"left\"")] shift: &str,
) -> Result<(), JsError> {
let area = Range::parse(range).map_err(js)?;
let done = crate::edit::remove_cells(&mut self.workbook, sheet, area, axis_of(shift)?);
self.edited(done)
}
#[wasm_bindgen(js_name = copyRange)]
pub fn copy_range(
&mut self,
sheet: usize,
range: &str,
to: &str,
to_sheet: Option<usize>,
) -> Result<(), JsError> {
let (area, at) = (
Range::parse(range).map_err(js)?,
CellRef::parse(to).map_err(js)?,
);
let done = crate::edit::copy_range(
&mut self.workbook,
sheet,
area,
to_sheet.unwrap_or(sheet),
at,
);
self.edited(done)
}
#[wasm_bindgen(js_name = moveRange)]
pub fn move_range(
&mut self,
sheet: usize,
range: &str,
to: &str,
to_sheet: Option<usize>,
) -> Result<(), JsError> {
let (area, at) = (
Range::parse(range).map_err(js)?,
CellRef::parse(to).map_err(js)?,
);
let done = crate::edit::move_range(
&mut self.workbook,
sheet,
area,
to_sheet.unwrap_or(sheet),
at,
);
self.edited(done)
}
#[wasm_bindgen(js_name = sortRange)]
pub fn sort_range(
&mut self,
sheet: usize,
range: &str,
#[wasm_bindgen(unchecked_param_type = "SortKeys")] keys: &JsValue,
#[wasm_bindgen(unchecked_optional_param_type = "SortRangeOptions")] options: &JsValue,
) -> Result<(), JsError> {
let area = Range::parse(range).map_err(js)?;
let flag = |name: &str| super::convert::field(options, name).is_some_and(|v| v.is_truthy());
let options = SortOptions {
header: flag("header"),
orientation: if flag("byColumns") {
Axis::Columns
} else {
Axis::Rows
},
};
let keys = sort_keys_of(keys)?;
let done = crate::edit::sort_range_with(&mut self.workbook, sheet, area, &keys, options);
self.edited(done)
}
#[wasm_bindgen(js_name = sortTable)]
pub fn sort_table(
&mut self,
name: &str,
#[wasm_bindgen(unchecked_param_type = "SortKeys")] keys: &JsValue,
) -> Result<(), JsError> {
let keys = sort_keys_of(keys)?;
let done = crate::edit::sort_table(&mut self.workbook, name, &keys);
self.edited(done)
}
#[wasm_bindgen(js_name = fillSeries)]
pub fn fill_series(
&mut self,
sheet: usize,
range: &str,
#[wasm_bindgen(unchecked_param_type = "\"down\" | \"right\" | \"up\" | \"left\"")]
direction: &str,
) -> Result<(), JsError> {
let area = Range::parse(range).map_err(js)?;
let fill = match direction {
"down" | "right" => crate::edit::fill_series,
"up" | "left" => crate::edit::fill_series_back,
_ => {
return Err(JsError::new(
r#"a fill goes "down", "right", "up" or "left""#,
));
}
};
let done = fill(&mut self.workbook, sheet, area, axis_of(direction)?);
self.edited(done)
}
#[wasm_bindgen(js_name = fillDown)]
pub fn fill_down(&mut self, sheet: usize, range: &str) -> Result<(), JsError> {
let area = Range::parse(range).map_err(js)?;
let done = crate::edit::fill(&mut self.workbook, sheet, area, Axis::Rows);
self.edited(done)
}
#[wasm_bindgen(js_name = fillRight)]
pub fn fill_right(&mut self, sheet: usize, range: &str) -> Result<(), JsError> {
let area = Range::parse(range).map_err(js)?;
let done = crate::edit::fill(&mut self.workbook, sheet, area, Axis::Columns);
self.edited(done)
}
#[wasm_bindgen(js_name = moveSheet)]
pub fn move_sheet(&mut self, from: usize, to: usize) -> Result<(), JsError> {
crate::edit::move_sheet(&mut self.workbook, from, to).map_err(js)
}
#[wasm_bindgen(js_name = removeSheet)]
pub fn remove_sheet(&mut self, sheet: usize) -> Result<(), JsError> {
let done = crate::edit::remove_sheet(&mut self.workbook, sheet);
self.edited(done)
}
}
impl Book {
fn edited(&mut self, done: crate::error::Result<()>) -> Result<(), JsError> {
done.map_err(js)?;
self.forget_dependencies();
Ok(())
}
}
fn axis_of(direction: &str) -> Result<Axis, JsError> {
match direction {
"down" | "up" => Ok(Axis::Rows),
"right" | "left" => Ok(Axis::Columns),
_ => Err(JsError::new(
r#"a shift is "down", "up", "right" or "left""#,
)),
}
}
fn places_of<T>(
places: &JsValue,
line: fn(u32) -> Result<T, JsError>,
) -> Result<Vec<(T, u32)>, JsError> {
let number = |v: JsValue| {
v.as_f64()
.filter(|n| n.fract() == 0.0 && (0.0..=f64::from(u32::MAX)).contains(n))
.ok_or_else(|| JsError::new("a place is [at, count], two whole numbers"))
};
array(places, "places")?
.iter()
.map(|pair| {
let pair = array(&pair, "a place")?;
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "checked whole and in range just above"
)]
let (at, count) = (number(pair.get(0))? as u32, number(pair.get(1))? as u32);
Ok((line(at)?, count))
})
.collect()
}
fn copy_origin_of(name: Option<&str>) -> Result<CopyOrigin, JsError> {
match name {
Some("none") => Ok(CopyOrigin::Blank),
None | Some("before") => Ok(CopyOrigin::Before),
Some("after") => Ok(CopyOrigin::After),
Some(other) => Err(JsError::new(&format!(
"copyOrigin must be \"before\", \"after\" or \"none\", not {other:?}"
))),
}
}
fn sort_keys_of(keys: &JsValue) -> Result<Vec<SortKey>, JsError> {
array(keys, "sort keys")?
.iter()
.map(|key| {
if let Some(n) = key.as_f64() {
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "a line number of the sheet, saturated if it is not one"
)]
let line = (n.abs() as u32)
.checked_sub(1)
.ok_or_else(|| JsError::new("a sort key counts from 1"))?;
return Ok(SortKey {
by: SortBy::Line(line),
descending: n < 0.0,
});
}
let text = key
.as_string()
.ok_or_else(|| JsError::new("a sort key is a number or a header"))?;
Ok(match text.strip_prefix('-') {
Some(name) => SortKey::header(name).descending(),
None => SortKey::header(text),
})
})
.collect()
}