use super::convert::at_index;
use super::{Book, js, reporter};
use crate::coordinate::CellRef;
use crate::error::CellError;
use crate::formula::eval::{Dependencies, Engine, Origin};
use crate::formula::value::Value;
use wasm_bindgen::JsCast;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
impl Book {
#[wasm_bindgen(js_name = registerFunction)]
pub fn register_function(&mut self, name: &str, function: &js_sys::Function) {
let function = function.clone();
self.custom.register(name, move |args| {
let js_args: js_sys::Array = args.iter().map(value_to_js_deep).collect();
match js_sys::Reflect::apply(&function, &JsValue::NULL, &js_args) {
Ok(value) => js_to_value(&value),
Err(_) => Value::Error(CellError::Value),
}
});
self.deps = None;
}
#[wasm_bindgen(js_name = unregisterFunction)]
pub fn unregister_function(&mut self, name: &str) -> bool {
self.deps = None;
self.custom.remove(name)
}
#[wasm_bindgen(js_name = registeredFunctions)]
#[must_use]
pub fn registered_functions(&self) -> Vec<String> {
self.custom.names().map(str::to_owned).collect()
}
#[wasm_bindgen(js_name = goalSeek, unchecked_return_type = "GoalSeekResult")]
pub fn goal_seek(
&mut self,
sheet: usize,
set: &str,
target: f64,
changing: &str,
#[wasm_bindgen(unchecked_optional_param_type = "GoalSeekOptions")] options: &JsValue,
) -> Result<JsValue, JsError> {
use super::convert::{field, object};
use crate::formula::what_if::{SeekLimits, goal_seek_with};
let set = CellRef::parse(set).map_err(js)?;
let changing = CellRef::parse(changing).map_err(js)?;
let mut limits = SeekLimits::of(&self.workbook);
if let Some(n) = field(options, "maxIterations").and_then(|v| v.as_f64()) {
if !(n.fract() == 0.0 && n >= 1.0 && n <= f64::from(u32::MAX)) {
return Err(JsError::new("maxIterations is a whole number from 1"));
}
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "checked whole and in range just above"
)]
let n = n as u32;
limits.max_iterations = n;
}
if let Some(t) = field(options, "tolerance").and_then(|v| v.as_f64()) {
if !(t.is_finite() && t > 0.0) {
return Err(JsError::new("tolerance is a number above 0"));
}
limits.tolerance = t;
}
let functions = crate::progress::Options::new().with_functions(&self.custom);
let found = goal_seek_with(
&mut self.workbook,
(sheet, set),
target,
(sheet, changing),
limits,
&functions,
)
.map_err(js)?;
let number = |n: f64| {
if n.is_finite() {
JsValue::from_f64(n)
} else {
JsValue::NULL
}
};
Ok(object(&[
("value", JsValue::from_f64(found.value)),
("result", number(found.result)),
("iterations", JsValue::from_f64(f64::from(found.iterations))),
("converged", JsValue::from_bool(found.converged)),
]))
}
#[wasm_bindgen(js_name = checkValidation, unchecked_return_type = "ValidationProblem | null")]
pub fn check_validation(
&self,
sheet: usize,
address: &str,
#[wasm_bindgen(unchecked_param_type = "CellValue")] value: &JsValue,
) -> Result<JsValue, JsError> {
use super::convert::{js_to_cell, object, ranges_to_js};
let at = CellRef::parse(address).map_err(js)?;
self.sheet_of(sheet)?;
let value = js_to_cell(value)?;
Ok(
match crate::formula::validation::check(&self.workbook, sheet, at, &value) {
None => JsValue::NULL,
Some(rule) => object(&[
("style", JsValue::from_str(rule.error_style.as_str())),
("title", JsValue::from_str(&rule.error_title)),
("message", JsValue::from_str(&rule.error)),
("sqref", ranges_to_js(&rule.sqref)),
]),
},
)
}
#[wasm_bindgen(js_name = invalidCells)]
pub fn invalid_cells(&self, sheet: usize) -> Result<Vec<String>, JsError> {
self.sheet_of(sheet)?;
Ok(
crate::formula::validation::invalid_cells(&self.workbook, sheet)
.into_iter()
.map(|at| at.to_string())
.collect(),
)
}
#[wasm_bindgen(js_name = validationList)]
pub fn validation_list(&self, sheet: usize, address: &str) -> Result<Vec<String>, JsError> {
use crate::formula::validation::{list_items, rule_at};
let at = CellRef::parse(address).map_err(js)?;
self.sheet_of(sheet)?;
Ok(rule_at(&self.workbook, sheet, at)
.map(|rule| list_items(&self.workbook, sheet, rule))
.unwrap_or_default())
}
#[wasm_bindgen(unchecked_return_type = "CellValue")]
pub fn evaluate(&self, sheet: usize, address: &str, formula: &str) -> Result<JsValue, JsError> {
let at = CellRef::parse(address).map_err(js)?;
self.sheet_of(sheet)?;
let mut engine = Engine::with_functions(&self.workbook, &self.custom);
let got = engine.eval(
Origin::new(sheet, at),
formula.strip_prefix('=').unwrap_or(formula),
);
Ok(value_to_js(&got))
}
#[expect(
clippy::needless_pass_by_value,
reason = "a callback crosses the wasm boundary owned"
)]
pub fn recalculate(
&mut self,
sheet: Option<usize>,
on_progress: Option<js_sys::Function>,
) -> usize {
let report = on_progress.as_ref().map(reporter);
let mut options = crate::progress::Options::new().with_functions(&self.custom);
if let Some(report) = &report {
options = options.reporting(report);
}
crate::formula::eval::recalculate(&mut self.workbook, sheet, &options)
}
#[wasm_bindgen(js_name = recalculateCell)]
pub fn recalculate_cell(&mut self, sheet: usize, address: &str) -> Result<bool, JsError> {
Ok(self.recalculate_one(sheet, CellRef::parse(address).map_err(js)?))
}
#[wasm_bindgen(js_name = recalculateCellAt)]
pub fn recalculate_cell_at(
&mut self,
sheet: usize,
row: u32,
column: u32,
) -> Result<bool, JsError> {
Ok(self.recalculate_one(sheet, at_index(row, column)?))
}
#[wasm_bindgen(js_name = recalculateFrom)]
pub fn recalculate_from(&mut self, sheet: usize, address: &str) -> Result<usize, JsError> {
self.recalculate_changed(sheet, &[CellRef::parse(address).map_err(js)?])
}
#[wasm_bindgen(js_name = recalculateFromAt)]
pub fn recalculate_from_at(
&mut self,
sheet: usize,
row: u32,
column: u32,
) -> Result<usize, JsError> {
self.recalculate_changed(sheet, &[at_index(row, column)?])
}
#[wasm_bindgen(js_name = recalculateFromMany)]
#[expect(
clippy::needless_pass_by_value,
reason = "an array of strings crosses the wasm boundary owned"
)]
pub fn recalculate_from_many(
&mut self,
sheet: usize,
addresses: Vec<String>,
) -> Result<usize, JsError> {
let cells = addresses
.iter()
.map(|address| CellRef::parse(address).map_err(js))
.collect::<Result<Vec<_>, _>>()?;
self.recalculate_changed(sheet, &cells)
}
}
impl Book {
fn recalculate_one(&mut self, sheet: usize, at: CellRef) -> bool {
let options = crate::progress::Options::new().with_functions(&self.custom);
crate::formula::eval::recalculate_cell_with(&mut self.workbook, sheet, at, &options)
}
fn recalculate_changed(&mut self, sheet: usize, cells: &[CellRef]) -> Result<usize, JsError> {
self.sheet_of(sheet)?;
let changed: Vec<_> = cells.iter().map(|&at| (sheet, at)).collect();
let deps = self
.deps
.get_or_insert_with(|| Dependencies::of(&self.workbook));
Ok(deps.recalculate_from(&mut self.workbook, &changed))
}
}
fn js_to_value(value: &JsValue) -> Value {
if let Some(n) = value.as_f64() {
return Value::Number(n);
}
if let Some(b) = value.as_bool() {
return Value::Bool(b);
}
if let Some(text) = value.as_string() {
return match CellError::parse(&text) {
Some(e) => Value::Error(e),
None => Value::Text(text),
};
}
if let Ok(rows) = value.clone().dyn_into::<js_sys::Array>() {
let grid: Vec<Vec<Value>> = rows
.iter()
.map(|row| match row.dyn_into::<js_sys::Array>() {
Ok(cells) => cells.iter().map(|c| js_to_value(&c)).collect(),
Err(one) => vec![js_to_value(&one)],
})
.collect();
return Value::array(grid);
}
Value::Blank
}
fn value_to_js_deep(value: &Value) -> JsValue {
match value {
Value::Array(rows) => rows
.iter()
.map(|row| row.iter().map(value_to_js_deep).collect::<js_sys::Array>())
.collect::<js_sys::Array>()
.into(),
other => value_to_js(other),
}
}
fn value_to_js(value: &Value) -> JsValue {
match value {
Value::Blank | Value::Lambda(_) => JsValue::NULL,
Value::Number(n) => JsValue::from_f64(*n),
Value::Text(t) => JsValue::from_str(t),
Value::Bool(b) => JsValue::from_bool(*b),
Value::Error(e) => JsValue::from_str(e.as_str()),
Value::Array(rows) => rows
.first()
.and_then(|r| r.first())
.map_or(JsValue::NULL, value_to_js),
}
}