#![allow(clippy::missing_errors_doc)]
use crate::coordinate::{CellRef, Col, Range, Row};
#[cfg(feature = "formulas")]
use crate::error::CellError;
#[cfg(feature = "formulas")]
use crate::formula::CustomFunctions;
#[cfg(feature = "formulas")]
use crate::formula::eval::{Dependencies, Engine, Origin};
#[cfg(feature = "formulas")]
use crate::formula::value::Value;
use crate::model::{CellValue, Spreadsheet, Worksheet};
#[cfg(feature = "write")]
use crate::writer::csv::write_csv_to;
#[cfg(feature = "write")]
use crate::writer::html::{HtmlOptions, write_html_to};
#[cfg(feature = "write")]
use crate::writer::ods::write_ods_to;
#[cfg(feature = "write")]
use crate::writer::xls::write_xls_to;
#[cfg(feature = "write")]
use crate::writer::xlsx::write_xlsx_to;
use wasm_bindgen::JsCast;
use wasm_bindgen::prelude::*;
#[wasm_bindgen(typescript_custom_section)]
const TYPES: &'static str = r#"
/** What a cell can hold on the JS side. An error cell reads as its code, `#DIV/0!`. */
export type CellValue = number | string | boolean | null;
/** A rectangle of cells, row by row, as `getRange` returns it. */
export type CellGrid = CellValue[][];
/**
* One row with its styling, as `getRowAt` returns it. `formatted` is `null`
* when the call asked for values alone. `bold` is one byte per cell, 0 or 1.
*/
export interface SheetRow {
values: CellValue[];
formatted: string[] | null;
bold: Uint8Array;
indent: Uint32Array;
hidden: boolean;
}
/** Where a drawing object sits, in the 1-based numbers a user sees. */
export interface ObjectAnchor {
kind: "twoCell" | "oneCell" | "absolute";
row: number | null;
column: number | null;
}
/** How a sheet is frozen and shown, as `sheetView` returns it. */
export interface SheetViewInfo {
frozenRows: number;
frozenColumns: number;
zoom: number | null;
showGridLines: boolean;
showRowColHeaders: boolean;
rightToLeft: boolean;
topLeftCell: string | null;
}
/** A name that stands for a formula, as `definedNames` returns it. */
export interface WorkbookName {
name: string;
formula: string;
sheet: number | null;
hidden: boolean;
}
/** A rule limiting what a cell accepts, as `dataValidations` returns it. */
export interface SheetValidation {
sqref: string[];
type: string;
operator: string;
formula1: string;
formula2: string;
allowBlank: boolean;
showDropDown: boolean;
}
/** One conditional formatting block, as `conditionalFormats` returns it. */
export interface SheetConditionalFormat {
sqref: string[];
rules: { type: string; priority: number; operator: string | null; formulas: string[]; text: string | null }[];
}
/** The autofilter over a range, as `autoFilter` returns it. */
export interface SheetAutoFilter {
range: string;
columns: { colId: number; kind: "values" | "custom" | "dynamic" | "top10" | "none" }[];
}
/** A pivot report on the sheet, as `pivotTables` returns it. */
export interface SheetPivotTable {
name: string;
location: string | null;
cacheId: number;
rowFields: number;
columnFields: number;
valueFields: number;
}
/** How a sheet or the workbook is locked, as `sheetProtection` returns it. */
export interface ProtectionInfo { locked: boolean; hasPassword: boolean }
/** How `toCsv` writes, and how `Book.readCsv` reads. */
export interface CsvOptions {
delimiter?: string;
contiguous?: boolean;
preserveEmptyFields?: boolean;
}
/** A note on a cell, as `comments` returns it. */
export interface SheetComment { address: string; author: string; text: string }
/** A link over a cell or a block of them, as `hyperlinks` returns it. */
export interface SheetHyperlink {
range: string;
target: string;
external: boolean;
display: string | null;
tooltip: string | null;
}
/** A table over a block of cells, as `tables` returns it. */
export interface SheetTable {
name: string;
displayName: string;
range: string;
headerRowCount: number | null;
totalsRowCount: number | null;
columns: string[];
}
/** A chart on the sheet, as `charts` returns it. */
export interface SheetChart {
name: string;
title: string | null;
kinds: string[];
seriesCount: number;
anchor: ObjectAnchor;
}
/** A picture on the sheet, as `images` returns it. Bytes come from `imageData`. */
export interface SheetImage {
name: string;
description: string;
format: string;
byteLength: number;
anchor: ObjectAnchor;
}
/** A drawn shape, as `shapes` returns it. */
export interface SheetShape {
name: string;
description: string;
geometry: string | null;
text: string;
anchor: ObjectAnchor;
}
/**
* A colour as the file states it: `null` when the file leaves it to the
* reader, `#AARRGGBB` when it names one outright, and `indexed:N` or
* `theme:N` when it points into the legacy palette or the workbook theme -
* a theme colour carries its tint as `theme:4@-0.25`.
*/
export type StyleColor = string | null;
/** One side of a cell's border. */
export interface BorderSide { style: string; color: StyleColor }
/** How a cell is painted, as `cellStyle` returns it. */
export interface CellStyle {
numberFormat: string;
font: {
name: string;
size: number;
bold: boolean;
italic: boolean;
underline: string;
strike: boolean;
color: StyleColor;
};
fill: { pattern: string; foreground: StyleColor; background: StyleColor };
borders: {
left: BorderSide;
right: BorderSide;
top: BorderSide;
bottom: BorderSide;
};
alignment: {
horizontal: string | null;
vertical: string | null;
wrapText: boolean;
shrinkToFit: boolean;
indent: number;
textRotation: number;
};
}
/**
* The styles of a rectangle, as `getRangeStyles` returns them: each distinct
* style once in `styles`, and `grid` - row by row - pointing into it.
*/
export interface RangeStyles {
styles: CellStyle[];
grid: number[][];
}
"#;
#[cfg(feature = "write")]
#[wasm_bindgen(typescript_custom_section)]
const WRITE_TYPES: &'static str = r#"
/**
* A style to write, as `setCellStyle` takes it. Every field is optional and
* what is left out keeps the value the cell had, so `{ font: { bold: true } }`
* makes a cell bold without touching its number format.
*/
export interface CellStylePatch {
numberFormat?: string;
font?: Partial<{
name: string;
size: number;
bold: boolean;
italic: boolean;
underline: string;
strike: boolean;
color: StyleColor;
}>;
fill?: Partial<{ pattern: string; foreground: StyleColor; background: StyleColor }>;
borders?: Partial<{
left: Partial<BorderSide>;
right: Partial<BorderSide>;
top: Partial<BorderSide>;
bottom: Partial<BorderSide>;
}>;
alignment?: Partial<{
horizontal: string | null;
vertical: string | null;
wrapText: boolean;
shrinkToFit: boolean;
indent: number;
textRotation: number;
}>;
}
/**
* Sort keys: a 1-based column number of the sheet (a row number when sorting
* columns) or a header's text; a minus in front sorts largest first.
*/
export type SortKeys = (number | string)[];
/** How `sortRange` reads its range. */
export interface SortRangeOptions {
/** The first row (or column) is a header: it stays put and names keys. */
header?: boolean;
/** Reorder columns left to right instead of rows. */
byColumns?: boolean;
}
/**
* Styles to write over a rectangle, as `setRangeStyles` takes them: `grid`
* points into `styles`, and `null` or `-1` leaves its cell as it is. What
* `getRangeStyles` returns fits here unchanged.
*/
export interface RangeStylesPatch {
styles: CellStylePatch[];
grid: (number | null)[][];
}
"#;
#[wasm_bindgen]
pub struct Book {
book: Spreadsheet,
#[cfg(feature = "formulas")]
deps: Option<Dependencies>,
#[cfg(feature = "formulas")]
custom: CustomFunctions,
}
fn reporter(callback: &js_sys::Function) -> impl Fn(crate::progress::Progress<'_>) + '_ {
move |progress| {
let stage = match progress.stage {
crate::progress::Stage::Reading => "reading",
crate::progress::Stage::Writing => "writing",
crate::progress::Stage::Recalculating => "recalculating",
};
#[expect(
clippy::cast_precision_loss,
reason = "counts of sheets, parts and formulas are far below 2^53"
)]
let report = object(&[
("stage", JsValue::from_str(stage)),
("done", JsValue::from_f64(progress.done as f64)),
(
"total",
progress
.total
.map_or(JsValue::NULL, |t| JsValue::from_f64(t as f64)),
),
("what", JsValue::from_str(progress.what)),
(
"fraction",
progress.fraction().map_or(JsValue::NULL, JsValue::from_f64),
),
]);
let _ = callback.call1(&JsValue::NULL, &report);
}
}
fn js(e: impl std::fmt::Display) -> JsError {
JsError::new(&e.to_string())
}
#[wasm_bindgen]
impl Book {
#[wasm_bindgen(constructor)]
#[must_use]
pub fn new() -> Self {
Self::wrap(Spreadsheet::new())
}
#[wasm_bindgen(js_name = fromXlsx)]
pub fn from_xlsx(bytes: &[u8]) -> Result<Self, JsError> {
crate::reader::xlsx::read_xlsx_from(std::io::Cursor::new(bytes))
.map(Self::wrap)
.map_err(js)
}
#[wasm_bindgen(js_name = read)]
#[expect(
clippy::needless_pass_by_value,
reason = "an optional string crosses the wasm boundary owned"
)]
pub fn read(
bytes: &[u8],
name: Option<String>,
max_expanded: Option<f64>,
on_progress: Option<js_sys::Function>,
) -> Result<Self, JsError> {
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "a byte count from JS is a whole positive number"
)]
let limit = max_expanded.map_or(crate::reader::xlsx::MAX_UNCOMPRESSED_SIZE, |n| n as u64);
match on_progress {
Some(callback) => {
let report = reporter(&callback);
let options = crate::progress::Options::new().reporting(&report);
crate::reader::read_bytes_limited_with(bytes, name.as_deref(), limit, &options)
.map(Self::wrap)
.map_err(js)
}
None => crate::reader::read_bytes_limited(bytes, name.as_deref(), limit)
.map(Self::wrap)
.map_err(js),
}
}
#[wasm_bindgen(js_name = sheetNames)]
#[must_use]
pub fn sheet_names(&self) -> Vec<String> {
self.book
.sheets()
.iter()
.map(|s| s.title().to_owned())
.collect()
}
#[wasm_bindgen(js_name = cellCount)]
#[must_use]
pub fn cell_count(&self, sheet: Option<usize>) -> usize {
match sheet {
Some(index) => self.book.sheet(index).map_or(0, Worksheet::len),
None => self.book.sheets().iter().map(Worksheet::len).sum(),
}
}
#[wasm_bindgen(js_name = addSheet)]
pub fn add_sheet(&mut self, title: &str) -> Result<usize, JsError> {
let sheet = Worksheet::new(title).map_err(js)?;
self.book.add_sheet(sheet).map_err(js)
}
#[wasm_bindgen(unchecked_return_type = "CellValue")]
pub fn get(&self, sheet: usize, address: &str) -> Result<JsValue, JsError> {
self.value_at(sheet, CellRef::parse(address).map_err(js)?)
}
#[wasm_bindgen(js_name = getAt, unchecked_return_type = "CellValue")]
pub fn get_at(&self, sheet: usize, row: u32, column: u32) -> Result<JsValue, JsError> {
self.value_at(sheet, at_index(row, column)?)
}
fn value_at(&self, sheet: usize, at: CellRef) -> Result<JsValue, JsError> {
let sheet = self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?;
Ok(match sheet.get(at).map(|c| &c.value) {
None | Some(CellValue::Empty) => JsValue::NULL,
Some(CellValue::Number(n)) => JsValue::from_f64(*n),
Some(CellValue::Bool(b)) => JsValue::from_bool(*b),
Some(CellValue::Error(e)) => JsValue::from_str(e.as_str()),
Some(v @ (CellValue::Text(_) | CellValue::RichText(_))) => {
JsValue::from_str(&v.plain_text().unwrap_or_default())
}
Some(CellValue::Formula { cached, .. }) => {
cached.as_deref().map_or(JsValue::NULL, cell_to_js)
}
})
}
pub fn set(
&mut self,
index: usize,
address: &str,
#[wasm_bindgen(unchecked_param_type = "CellValue")] value: &JsValue,
) -> Result<(), JsError> {
self.write(index, CellRef::parse(address).map_err(js)?, value)
}
#[wasm_bindgen(js_name = setAt)]
pub fn set_at(
&mut self,
sheet: usize,
row: u32,
column: u32,
#[wasm_bindgen(unchecked_param_type = "CellValue")] value: &JsValue,
) -> Result<(), JsError> {
self.write(sheet, at_index(row, column)?, value)
}
fn write(&mut self, index: usize, at: CellRef, value: &JsValue) -> Result<(), JsError> {
let value = js_to_cell(value)?;
let sheet = self
.book
.sheet_mut(index)
.ok_or_else(|| JsError::new("no such sheet"))?;
#[cfg(feature = "formulas")]
let formula_edit = matches!(value, CellValue::Formula { .. })
|| matches!(
sheet.get(at).map(|c| &c.value),
Some(CellValue::Formula { .. })
);
sheet.set(at, value);
#[cfg(feature = "formulas")]
if let (Some(deps), true) = (self.deps.as_mut(), formula_edit) {
deps.note(&self.book, index, at);
}
Ok(())
}
#[cfg(feature = "formulas")]
#[cfg(feature = "formulas")]
#[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::new();
for arg in args {
js_args.push(&value_to_js_deep(arg));
}
match js_sys::Reflect::apply(&function, &JsValue::NULL, &js_args) {
Ok(value) => js_to_value(&value),
Err(_) => Value::Error(CellError::Value),
}
});
self.deps = None;
}
#[cfg(feature = "formulas")]
#[wasm_bindgen(js_name = unregisterFunction)]
pub fn unregister_function(&mut self, name: &str) -> bool {
self.deps = None;
self.custom.remove(name)
}
#[cfg(feature = "formulas")]
#[wasm_bindgen(js_name = registeredFunctions)]
#[must_use]
pub fn registered_functions(&self) -> Vec<String> {
self.custom.names().map(str::to_owned).collect()
}
#[cfg(feature = "formulas")]
#[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)?;
if self.book.sheet(sheet).is_none() {
return Err(JsError::new("no such sheet"));
}
let mut engine = Engine::with_functions(&self.book, &self.custom);
let got = engine.eval(
Origin::new(sheet, at),
formula.strip_prefix('=').unwrap_or(formula),
);
Ok(value_to_js(&got))
}
#[cfg(feature = "formulas")]
pub fn recalculate(
&mut self,
sheet: Option<usize>,
on_progress: Option<js_sys::Function>,
) -> usize {
let options = crate::progress::Options::new().with_functions(&self.custom);
match on_progress {
Some(callback) => {
let report = reporter(&callback);
let options = options.reporting(&report);
crate::formula::eval::recalculate(&mut self.book, sheet, &options)
}
None => crate::formula::eval::recalculate(&mut self.book, sheet, &options),
}
}
#[cfg(feature = "formulas")]
#[wasm_bindgen(js_name = recalculateCell)]
pub fn recalculate_cell(&mut self, sheet: usize, address: &str) -> Result<bool, JsError> {
let at = CellRef::parse(address).map_err(js)?;
Ok(self.recalculate_cell_inner(sheet, at))
}
#[cfg(feature = "formulas")]
#[wasm_bindgen(js_name = recalculateCellAt)]
pub fn recalculate_cell_at(
&mut self,
sheet: usize,
row: u32,
column: u32,
) -> Result<bool, JsError> {
let at = at_index(row, column)?;
Ok(self.recalculate_cell_inner(sheet, at))
}
#[cfg(feature = "formulas")]
fn recalculate_cell_inner(&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.book, sheet, at, &options)
}
#[cfg(feature = "formulas")]
#[wasm_bindgen(js_name = recalculateFrom)]
pub fn recalculate_from(&mut self, sheet: usize, address: &str) -> Result<usize, JsError> {
self.recalculate_from_many(sheet, vec![address.to_owned()])
}
#[cfg(feature = "formulas")]
#[wasm_bindgen(js_name = recalculateFromAt)]
pub fn recalculate_from_at(
&mut self,
sheet: usize,
row: u32,
column: u32,
) -> Result<usize, JsError> {
let at = at_index(row, column)?;
if self.book.sheet(sheet).is_none() {
return Err(JsError::new("no such sheet"));
}
let deps = self
.deps
.get_or_insert_with(|| Dependencies::of(&self.book));
Ok(deps.recalculate_from(&mut self.book, &[(sheet, at)]))
}
#[cfg(feature = "formulas")]
#[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> {
if self.book.sheet(sheet).is_none() {
return Err(JsError::new("no such sheet"));
}
let mut changed = Vec::with_capacity(addresses.len());
for address in &addresses {
changed.push((sheet, CellRef::parse(address).map_err(js)?));
}
let deps = self
.deps
.get_or_insert_with(|| Dependencies::of(&self.book));
Ok(deps.recalculate_from(&mut self.book, &changed))
}
#[wasm_bindgen(js_name = sheetIndex)]
#[must_use]
pub fn sheet_index(&self, name: &str) -> Option<usize> {
self.book.sheet_index_by_name(name)
}
#[wasm_bindgen(js_name = renameSheet)]
pub fn rename_sheet(&mut self, sheet: usize, title: &str) -> Result<(), JsError> {
self.book
.sheet_mut(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?
.set_title(title)
.map_err(js)
}
#[wasm_bindgen(js_name = activeSheet)]
#[must_use]
pub fn active_sheet(&self) -> usize {
self.book.active_index()
}
#[wasm_bindgen(js_name = setActiveSheet)]
pub fn set_active_sheet(&mut self, sheet: usize) -> Result<(), JsError> {
self.book.set_active(sheet).map_err(js)
}
#[wasm_bindgen(js_name = usedRange)]
#[must_use]
pub fn used_range(&self, sheet: usize) -> Option<String> {
self.book.sheet(sheet)?.dimension().map(|r| r.to_string())
}
#[wasm_bindgen(js_name = getFormula)]
#[must_use]
pub fn get_formula(&self, sheet: usize, address: &str) -> Option<String> {
self.formula_of(sheet, CellRef::parse(address).ok()?)
}
#[wasm_bindgen(js_name = getFormulaAt)]
#[must_use]
pub fn get_formula_at(&self, sheet: usize, row: u32, column: u32) -> Option<String> {
self.formula_of(sheet, at_index(row, column).ok()?)
}
fn formula_of(&self, sheet: usize, at: CellRef) -> Option<String> {
match &self.book.sheet(sheet)?.get(at)?.value {
CellValue::Formula { formula, .. } => Some(formula.clone()),
_ => None,
}
}
#[wasm_bindgen(js_name = getFormatted)]
pub fn get_formatted(&self, sheet: usize, address: &str) -> Result<String, JsError> {
self.formatted(sheet, CellRef::parse(address).map_err(js)?)
}
#[wasm_bindgen(js_name = getFormattedAt)]
pub fn get_formatted_at(&self, sheet: usize, row: u32, column: u32) -> Result<String, JsError> {
self.formatted(sheet, at_index(row, column)?)
}
fn formatted(&self, sheet: usize, at: CellRef) -> Result<String, JsError> {
if self.book.sheet(sheet).is_none() {
return Err(JsError::new("no such sheet"));
}
Ok(self.book.formatted(sheet, at))
}
#[wasm_bindgen(js_name = cellIndent)]
pub fn cell_indent(&self, sheet: usize, address: &str) -> Result<u32, JsError> {
self.indent_of(sheet, CellRef::parse(address).map_err(js)?)
}
#[wasm_bindgen(js_name = cellIndentAt)]
pub fn cell_indent_at(&self, sheet: usize, row: u32, column: u32) -> Result<u32, JsError> {
self.indent_of(sheet, at_index(row, column)?)
}
fn indent_of(&self, sheet: usize, at: CellRef) -> Result<u32, JsError> {
let ws = self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?;
Ok(ws
.get(at)
.and_then(|cell| self.book.styles.get(cell.style))
.map_or(0, |style| style.alignment.indent))
}
#[wasm_bindgen(js_name = mergedRanges)]
pub fn merged_ranges(&self, sheet: usize) -> Result<Vec<String>, JsError> {
Ok(self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?
.merges
.iter()
.map(ToString::to_string)
.collect())
}
#[wasm_bindgen(js_name = cellBold)]
pub fn cell_bold(&self, sheet: usize, address: &str) -> Result<bool, JsError> {
self.bold_of(sheet, CellRef::parse(address).map_err(js)?)
}
#[wasm_bindgen(js_name = cellBoldAt)]
pub fn cell_bold_at(&self, sheet: usize, row: u32, column: u32) -> Result<bool, JsError> {
self.bold_of(sheet, at_index(row, column)?)
}
fn bold_of(&self, sheet: usize, at: CellRef) -> Result<bool, JsError> {
let ws = self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?;
Ok(ws
.get(at)
.and_then(|cell| self.book.styles.get(cell.style))
.is_some_and(|style| style.font.bold))
}
#[wasm_bindgen(js_name = sheetVisibility)]
pub fn sheet_visibility(&self, sheet: usize) -> Result<String, JsError> {
Ok(self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?
.visibility
.as_str()
.unwrap_or("visible")
.to_owned())
}
#[wasm_bindgen(js_name = rowHidden)]
pub fn row_hidden(&self, sheet: usize, row: u32) -> Result<bool, JsError> {
let at = Row::from_one_based(u64::from(row)).map_err(js)?;
Ok(self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?
.rows
.get(&at)
.is_some_and(|props| props.hidden))
}
#[wasm_bindgen(js_name = getRowAt, unchecked_return_type = "SheetRow")]
pub fn get_row_at(
&self,
sheet: usize,
row: u32,
formatted: Option<bool>,
) -> Result<JsValue, JsError> {
let ws = self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?;
let at = Row::from_one_based(u64::from(row)).map_err(js)?;
let width = ws
.row_cells(at)
.last()
.map_or(0, |(col, _)| col.index() + 1);
let values = js_sys::Array::new();
let shown = js_sys::Array::new();
let mut bold = Vec::with_capacity(width as usize);
let mut indent = Vec::with_capacity(width as usize);
let wanted = formatted.unwrap_or(true);
for col in 0..width {
let Some(col) = Col::new(col) else { continue };
let cell_at = CellRef::new(col, at);
let cell = ws.get(cell_at);
values.push(&cell.map_or(JsValue::NULL, |cell| match &cell.value {
CellValue::Formula { cached, .. } => {
cached.as_deref().map_or(JsValue::NULL, cell_to_js)
}
other => cell_to_js(other),
}));
if wanted {
shown.push(&JsValue::from_str(&self.formatted(sheet, cell_at)?));
}
let style = cell.and_then(|cell| self.book.styles.get(cell.style));
bold.push(u8::from(style.is_some_and(|s| s.font.bold)));
indent.push(style.map_or(0, |s| s.alignment.indent));
}
Ok(object(&[
("values", values.into()),
(
"formatted",
if wanted { shown.into() } else { JsValue::NULL },
),
("bold", js_sys::Uint8Array::from(&bold[..]).into()),
("indent", js_sys::Uint32Array::from(&indent[..]).into()),
(
"hidden",
JsValue::from_bool(ws.rows.get(&at).is_some_and(|props| props.hidden)),
),
]))
}
#[wasm_bindgen(js_name = mergedRangesAt)]
pub fn merged_ranges_at(&self, sheet: usize) -> Result<js_sys::Uint32Array, JsError> {
let merges = &self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?
.merges;
let mut out = Vec::with_capacity(merges.len() * 4);
for area in merges {
out.extend_from_slice(&[
area.start.row.one_based(),
area.start.col.one_based(),
area.end.row.one_based(),
area.end.col.one_based(),
]);
}
Ok(js_sys::Uint32Array::from(&out[..]))
}
#[wasm_bindgen(js_name = rowLevel)]
pub fn row_level(&self, sheet: usize, row: u32) -> Result<u8, JsError> {
let row = Row::from_one_based(u64::from(row)).map_err(js)?;
Ok(self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?
.row_outline_level(row))
}
#[wasm_bindgen(js_name = columnLevel)]
pub fn column_level(&self, sheet: usize, column: &str) -> Result<u8, JsError> {
let col = Col::from_letters(column).map_err(js)?;
Ok(self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?
.column_outline_level(col))
}
pub fn clear(&mut self, sheet: usize, address: &str) -> Result<(), JsError> {
self.erase(sheet, CellRef::parse(address).map_err(js)?)
}
#[wasm_bindgen(js_name = clearAt)]
pub fn clear_at(&mut self, sheet: usize, row: u32, column: u32) -> Result<(), JsError> {
self.erase(sheet, at_index(row, column)?)
}
fn erase(&mut self, sheet: usize, at: CellRef) -> Result<(), JsError> {
self.book
.sheet_mut(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?
.remove(at);
#[cfg(feature = "formulas")]
if let Some(deps) = self.deps.as_mut() {
deps.note(&self.book, sheet, at);
}
Ok(())
}
#[wasm_bindgen(js_name = cellStyle, unchecked_return_type = "CellStyle")]
pub fn cell_style(&self, sheet: usize, address: &str) -> Result<JsValue, JsError> {
self.style_of(sheet, CellRef::parse(address).map_err(js)?)
}
#[wasm_bindgen(js_name = cellStyleAt, unchecked_return_type = "CellStyle")]
pub fn cell_style_at(&self, sheet: usize, row: u32, column: u32) -> Result<JsValue, JsError> {
self.style_of(sheet, at_index(row, column)?)
}
#[wasm_bindgen(js_name = getRangeStyles, unchecked_return_type = "RangeStyles")]
pub fn get_range_styles(&self, sheet: usize, range: &str) -> Result<JsValue, JsError> {
self.styles_of(sheet, Range::parse(range).map_err(js)?)
}
#[wasm_bindgen(js_name = getRangeStylesAt, unchecked_return_type = "RangeStyles")]
pub fn get_range_styles_at(
&self,
sheet: usize,
row: u32,
column: u32,
rows: u32,
columns: u32,
) -> Result<JsValue, JsError> {
self.styles_of(sheet, area_at(row, column, rows, columns)?)
}
fn styles_of(&self, sheet: usize, area: Range) -> Result<JsValue, JsError> {
let ws = self.sheet_of(sheet)?;
let mut index: std::collections::HashMap<crate::style::StyleId, u32> =
std::collections::HashMap::new();
let styles = js_sys::Array::new();
let grid = js_sys::Array::new();
for row in area.start.row.index()..=area.end.row.index() {
let line = js_sys::Array::new();
for col in area.start.col.index()..=area.end.col.index() {
let id = Row::new(row)
.zip(Col::new(col))
.and_then(|(row, col)| ws.get(CellRef::new(col, row)))
.map(|cell| cell.style)
.unwrap_or_default();
let at = *index.entry(id).or_insert_with(|| {
let style = self.book.styles.get(id).cloned().unwrap_or_default();
styles.push(&style_to_js(&style)) - 1
});
line.push(&JsValue::from(at));
}
grid.push(&line);
}
Ok(object(&[("styles", styles.into()), ("grid", grid.into())]))
}
fn style_of(&self, sheet: usize, at: CellRef) -> Result<JsValue, JsError> {
let ws = self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?;
let style = ws
.get(at)
.and_then(|cell| self.book.styles.get(cell.style))
.cloned()
.unwrap_or_default();
Ok(style_to_js(&style))
}
#[wasm_bindgen(js_name = getRange, unchecked_return_type = "CellGrid")]
pub fn get_range(&self, sheet: usize, range: &str) -> Result<JsValue, JsError> {
self.grid(sheet, Range::parse(range).map_err(js)?)
}
#[wasm_bindgen(js_name = getRangeAt, unchecked_return_type = "CellGrid")]
pub fn get_range_at(
&self,
sheet: usize,
row: u32,
column: u32,
rows: u32,
columns: u32,
) -> Result<JsValue, JsError> {
self.grid(sheet, area_at(row, column, rows, columns)?)
}
fn grid(&self, sheet: usize, area: Range) -> Result<JsValue, JsError> {
let ws = self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?;
let rows = js_sys::Array::new();
for row in area.start.row.index()..=area.end.row.index() {
let cells = js_sys::Array::new();
for col in area.start.col.index()..=area.end.col.index() {
let value = Row::new(row)
.zip(Col::new(col))
.and_then(|(row, col)| ws.get(CellRef::new(col, row)))
.map_or(JsValue::NULL, |cell| match &cell.value {
CellValue::Formula { cached, .. } => {
cached.as_deref().map_or(JsValue::NULL, cell_to_js)
}
other => cell_to_js(other),
});
cells.push(&value);
}
rows.push(&cells);
}
Ok(rows.into())
}
#[wasm_bindgen(js_name = setRange)]
pub fn set_range(
&mut self,
sheet: usize,
at: &str,
#[wasm_bindgen(unchecked_param_type = "CellGrid")] values: &JsValue,
) -> Result<(), JsError> {
self.write_grid(sheet, CellRef::parse(at).map_err(js)?, values)
}
#[wasm_bindgen(js_name = setRangeAt)]
pub fn set_range_at(
&mut self,
sheet: usize,
row: u32,
column: u32,
#[wasm_bindgen(unchecked_param_type = "CellGrid")] values: &JsValue,
) -> Result<(), JsError> {
self.write_grid(sheet, at_index(row, column)?, values)
}
fn write_grid(
&mut self,
sheet: usize,
start: CellRef,
values: &JsValue,
) -> Result<(), JsError> {
if self.book.sheet(sheet).is_none() {
return Err(JsError::new("no such sheet"));
}
let rows: js_sys::Array = values
.clone()
.dyn_into()
.map_err(|_| JsError::new("values must be an array of rows"))?;
let mut writes = Vec::new();
for (r, row) in rows.iter().enumerate() {
let row: js_sys::Array = row
.dyn_into()
.map_err(|_| JsError::new("every row must be an array"))?;
for (c, value) in row.iter().enumerate() {
let col = u32::try_from(c)
.ok()
.and_then(|c| Col::new(start.col.index() + c))
.ok_or_else(|| JsError::new("range runs past the last column"))?;
let row = u32::try_from(r)
.ok()
.and_then(|r| Row::new(start.row.index() + r))
.ok_or_else(|| JsError::new("range runs past the last row"))?;
writes.push((CellRef::new(col, row), js_to_cell(&value)?));
}
}
#[cfg(feature = "formulas")]
let formulas: Vec<CellRef> = writes
.iter()
.filter(|(_, v)| matches!(v, CellValue::Formula { .. }))
.map(|(at, _)| *at)
.collect();
let ws = self
.book
.sheet_mut(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?;
for (at, value) in writes {
ws.set(at, value);
}
#[cfg(feature = "formulas")]
if let Some(deps) = self.deps.as_mut() {
for at in formulas {
deps.note(&self.book, sheet, at);
}
}
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = toXlsx)]
pub fn to_xlsx(&self, on_progress: Option<js_sys::Function>) -> Result<Vec<u8>, JsError> {
let mut out = std::io::Cursor::new(Vec::new());
match on_progress {
Some(callback) => {
let report = reporter(&callback);
let options = crate::progress::Options::new().reporting(&report);
crate::writer::xlsx::write_xlsx_to_with(&self.book, &mut out, &options)
}
None => write_xlsx_to(&self.book, &mut out),
}
.map_err(js)?;
Ok(out.into_inner())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = toOds)]
pub fn to_ods(&self) -> Result<Vec<u8>, JsError> {
let mut out = std::io::Cursor::new(Vec::new());
write_ods_to(&self.book, &mut out).map_err(js)?;
Ok(out.into_inner())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = toXls)]
pub fn to_xls(&self) -> Result<Vec<u8>, JsError> {
let mut out = Vec::new();
write_xls_to(&self.book, &mut out).map_err(js)?;
Ok(out)
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = toHtml)]
pub fn to_html(&self, sheet: Option<usize>, fragment: Option<bool>) -> Result<String, JsError> {
let mut out = Vec::new();
let options = HtmlOptions {
sheet,
fragment: fragment.unwrap_or(false),
};
write_html_to(&self.book, &mut out, &options).map_err(js)?;
String::from_utf8(out).map_err(js)
}
#[wasm_bindgen(js_name = usedRangeHint)]
pub fn used_range_hint(&self, sheet: usize) -> Result<Option<String>, JsError> {
Ok(self
.sheet_of(sheet)?
.dimension_hint()
.map(|r| r.to_string()))
}
#[wasm_bindgen(js_name = columnWidth)]
pub fn column_width(&self, sheet: usize, column: u32) -> Result<Option<f64>, JsError> {
let col = Col::from_one_based(u64::from(column)).map_err(js)?;
Ok(self.sheet_of(sheet)?.column_width(col))
}
#[wasm_bindgen(js_name = rowHeight)]
pub fn row_height(&self, sheet: usize, row: u32) -> Result<Option<f64>, JsError> {
let at = Row::from_one_based(u64::from(row)).map_err(js)?;
Ok(self.sheet_of(sheet)?.row_height(at))
}
#[wasm_bindgen(unchecked_return_type = "SheetComment[]")]
pub fn comments(&self, sheet: usize) -> Result<JsValue, JsError> {
let out = js_sys::Array::new();
for (at, comment) in &self.sheet_of(sheet)?.comments {
out.push(&object(&[
("address", JsValue::from_str(&at.to_string())),
("author", JsValue::from_str(&comment.author)),
("text", JsValue::from_str(&comment.plain_text())),
]));
}
Ok(out.into())
}
#[wasm_bindgen(unchecked_return_type = "SheetHyperlink[]")]
pub fn hyperlinks(&self, sheet: usize) -> Result<JsValue, JsError> {
use crate::model::LinkTarget;
let out = js_sys::Array::new();
for link in &self.sheet_of(sheet)?.hyperlinks {
let (target, external) = match &link.target {
LinkTarget::Inside(to) => (to, false),
LinkTarget::Outside(to) => (to, true),
};
out.push(&object(&[
("range", JsValue::from_str(&link.range.to_string())),
("target", JsValue::from_str(target)),
("external", JsValue::from_bool(external)),
("display", opt_str(link.display.as_deref())),
("tooltip", opt_str(link.tooltip.as_deref())),
]));
}
Ok(out.into())
}
#[wasm_bindgen(unchecked_return_type = "SheetTable[]")]
pub fn tables(&self, sheet: usize) -> Result<JsValue, JsError> {
let out = js_sys::Array::new();
for table in &self.sheet_of(sheet)?.tables {
let columns = js_sys::Array::new();
for column in &table.columns {
columns.push(&JsValue::from_str(&column.name));
}
out.push(&object(&[
("name", JsValue::from_str(&table.name)),
("displayName", JsValue::from_str(&table.display_name)),
("range", JsValue::from_str(&table.range.to_string())),
("headerRowCount", opt_count(table.header_row_count)),
("totalsRowCount", opt_count(table.totals_row_count)),
("columns", columns.into()),
]));
}
Ok(out.into())
}
#[wasm_bindgen(unchecked_return_type = "SheetChart[]")]
#[expect(
clippy::cast_precision_loss,
reason = "a count of series is far below 2^53"
)]
pub fn charts(&self, sheet: usize) -> Result<JsValue, JsError> {
let out = js_sys::Array::new();
for chart in &self.sheet_of(sheet)?.charts {
let kinds = js_sys::Array::new();
for plot in &chart.plots {
kinds.push(&JsValue::from_str(plot.kind.element()));
}
let title = chart
.title
.as_ref()
.and_then(|t| t.text.as_ref())
.and_then(crate::model::chart::ChartText::shown);
out.push(&object(&[
("name", JsValue::from_str(&chart.name)),
("title", opt_str(title)),
("kinds", kinds.into()),
(
"seriesCount",
JsValue::from_f64(
chart.plots.iter().map(|p| p.series.len()).sum::<usize>() as f64
),
),
("anchor", anchor_to_js(&chart.anchor)),
]));
}
Ok(out.into())
}
#[wasm_bindgen(unchecked_return_type = "SheetImage[]")]
#[expect(
clippy::cast_precision_loss,
reason = "a picture's byte count is far below 2^53"
)]
pub fn images(&self, sheet: usize) -> Result<JsValue, JsError> {
let out = js_sys::Array::new();
for image in &self.sheet_of(sheet)?.images {
out.push(&object(&[
("name", JsValue::from_str(&image.name)),
("description", JsValue::from_str(&image.description)),
("format", JsValue::from_str(image.format.extension())),
("byteLength", JsValue::from_f64(image.data.len() as f64)),
("anchor", anchor_to_js(&image.anchor)),
]));
}
Ok(out.into())
}
#[wasm_bindgen(js_name = imageData)]
pub fn image_data(&self, sheet: usize, index: usize) -> Result<Vec<u8>, JsError> {
self.sheet_of(sheet)?
.images
.get(index)
.map(|image| image.data.clone())
.ok_or_else(|| JsError::new("no such image"))
}
#[wasm_bindgen(unchecked_return_type = "SheetShape[]")]
pub fn shapes(&self, sheet: usize) -> Result<JsValue, JsError> {
let out = js_sys::Array::new();
for shape in &self.sheet_of(sheet)?.shapes {
out.push(&object(&[
("name", JsValue::from_str(&shape.name)),
("description", JsValue::from_str(&shape.description)),
("geometry", opt_str(shape.geometry.as_deref())),
("text", JsValue::from_str(&shape.text)),
("anchor", anchor_to_js(&shape.anchor)),
]));
}
Ok(out.into())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setCellStyle)]
pub fn set_cell_style(
&mut self,
sheet: usize,
address: &str,
#[wasm_bindgen(unchecked_param_type = "CellStylePatch")] patch: &JsValue,
) -> Result<(), JsError> {
let at = CellRef::parse(address).map_err(js)?;
self.paint(sheet, Range::new(at, at), patch)
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setCellStyleAt)]
pub fn set_cell_style_at(
&mut self,
sheet: usize,
row: u32,
column: u32,
#[wasm_bindgen(unchecked_param_type = "CellStylePatch")] patch: &JsValue,
) -> Result<(), JsError> {
let at = at_index(row, column)?;
self.paint(sheet, Range::new(at, at), patch)
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setRangeStyle)]
pub fn set_range_style(
&mut self,
sheet: usize,
range: &str,
#[wasm_bindgen(unchecked_param_type = "CellStylePatch")] patch: &JsValue,
) -> Result<(), JsError> {
self.paint(sheet, Range::parse(range).map_err(js)?, patch)
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setRangeStyles)]
pub fn set_range_styles(
&mut self,
sheet: usize,
at: &str,
#[wasm_bindgen(unchecked_param_type = "RangeStylesPatch")] styles: &JsValue,
) -> Result<(), JsError> {
self.paint_grid(sheet, CellRef::parse(at).map_err(js)?, styles)
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setRangeStylesAt)]
pub fn set_range_styles_at(
&mut self,
sheet: usize,
row: u32,
column: u32,
#[wasm_bindgen(unchecked_param_type = "RangeStylesPatch")] styles: &JsValue,
) -> Result<(), JsError> {
self.paint_grid(sheet, at_index(row, column)?, styles)
}
#[cfg(feature = "write")]
fn paint_grid(&mut self, sheet: usize, start: CellRef, input: &JsValue) -> Result<(), JsError> {
self.sheet_of(sheet)?;
let field = |name: &str| -> Result<js_sys::Array, JsError> {
js_sys::Reflect::get(input, &JsValue::from_str(name))
.ok()
.and_then(|v| v.dyn_into().ok())
.ok_or_else(|| JsError::new(&format!("`{name}` must be an array")))
};
let (patches, grid) = (field("styles")?, field("grid")?);
let patches: Vec<JsValue> = patches.iter().collect();
let mut seen: std::collections::HashMap<
(crate::style::StyleId, usize),
crate::style::StyleId,
> = std::collections::HashMap::new();
let mut writes = Vec::new();
for (r, line) in grid.iter().enumerate() {
let line: js_sys::Array = line
.dyn_into()
.map_err(|_| JsError::new("every row of `grid` must be an array"))?;
for (c, pick) in line.iter().enumerate() {
let Some(pick) = pick.as_f64().filter(|p| *p >= 0.0) else {
continue;
};
#[expect(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
let pick = pick as usize;
let patch = patches
.get(pick)
.ok_or_else(|| JsError::new(&format!("no style {pick} in `styles`")))?;
let at = u32::try_from(r)
.ok()
.and_then(|r| Row::new(start.row.index() + r))
.zip(
u32::try_from(c)
.ok()
.and_then(|c| Col::new(start.col.index() + c)),
)
.map(|(row, col)| CellRef::new(col, row))
.ok_or_else(|| JsError::new("styles run off the sheet"))?;
let old = self
.sheet_of(sheet)?
.get(at)
.map_or_else(Default::default, |cell| cell.style);
let id = if let Some(&id) = seen.get(&(old, pick)) {
id
} else {
if !patch.is_object() {
return Err(JsError::new("a style patch is an object"));
}
let mut style = self.book.styles.get(old).cloned().unwrap_or_default();
apply_style_patch(&mut style, patch)?;
let id = self.book.styles.intern(style);
seen.insert((old, pick), id);
id
};
writes.push((at, id));
}
}
let ws = self
.book
.sheet_mut(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?;
for (at, id) in writes {
ws.entry(at).style = id;
}
Ok(())
}
#[cfg(feature = "write")]
fn paint(&mut self, sheet: usize, area: Range, patch: &JsValue) -> Result<(), JsError> {
if !patch.is_object() {
return Err(JsError::new("a style patch is an object"));
}
let mut seen: std::collections::HashMap<crate::style::StyleId, crate::style::StyleId> =
std::collections::HashMap::new();
for row in area.start.row.index()..=area.end.row.index() {
for col in area.start.col.index()..=area.end.col.index() {
let (Some(row), Some(col)) = (Row::new(row), Col::new(col)) else {
continue;
};
let at = CellRef::new(col, row);
let ws = self
.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?;
let old = ws.get(at).map_or_else(Default::default, |cell| cell.style);
let id = if let Some(&id) = seen.get(&old) {
id
} else {
let mut style = self.book.styles.get(old).cloned().unwrap_or_default();
apply_style_patch(&mut style, patch)?;
let id = self.book.styles.intern(style);
seen.insert(old, id);
id
};
let ws = self
.book
.sheet_mut(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?;
ws.entry(at).style = id;
}
}
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setColumnWidth)]
pub fn set_column_width(
&mut self,
sheet: usize,
column: u32,
width: Option<f64>,
) -> Result<(), JsError> {
let col = Col::from_one_based(u64::from(column)).map_err(js)?;
self.sheet_mut(sheet)?.set_column_width(col, width);
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setRowHeight)]
pub fn set_row_height(
&mut self,
sheet: usize,
row: u32,
height: Option<f64>,
) -> Result<(), JsError> {
let at = Row::from_one_based(u64::from(row)).map_err(js)?;
self.sheet_mut(sheet)?.set_row_height(at, height);
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setColumnHidden)]
pub fn set_column_hidden(
&mut self,
sheet: usize,
column: u32,
hidden: bool,
) -> Result<(), JsError> {
let col = Col::from_one_based(u64::from(column)).map_err(js)?;
self.sheet_mut(sheet)?.set_column_hidden(col, hidden);
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setRowHidden)]
pub fn set_row_hidden(&mut self, sheet: usize, row: u32, hidden: bool) -> Result<(), JsError> {
let at = Row::from_one_based(u64::from(row)).map_err(js)?;
self.sheet_mut(sheet)?.set_row_hidden(at, hidden);
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setSheetVisibility)]
pub fn set_sheet_visibility(&mut self, sheet: usize, state: &str) -> Result<(), JsError> {
if !matches!(state, "visible" | "hidden" | "veryHidden") {
return Err(JsError::new(
r#"visibility is "visible", "hidden" or "veryHidden""#,
));
}
self.sheet_mut(sheet)?.visibility = crate::model::SheetVisibility::parse(state);
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setComment)]
pub fn set_comment(
&mut self,
sheet: usize,
address: &str,
author: &str,
text: &str,
) -> Result<(), JsError> {
let at = CellRef::parse(address).map_err(js)?;
let comment = crate::model::Comment {
author: author.to_owned(),
text: vec![crate::model::TextRun {
text: text.to_owned(),
font: None,
}],
};
self.sheet_mut(sheet)?.comments.insert(at, comment);
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = removeComment)]
pub fn remove_comment(&mut self, sheet: usize, address: &str) -> Result<bool, JsError> {
let at = CellRef::parse(address).map_err(js)?;
Ok(self.sheet_mut(sheet)?.comments.remove(&at).is_some())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setHyperlink)]
pub fn set_hyperlink(
&mut self,
sheet: usize,
range: &str,
target: &str,
inside: Option<bool>,
display: Option<String>,
tooltip: Option<String>,
) -> Result<(), JsError> {
use crate::model::{Hyperlink, LinkTarget};
let area = Range::parse(range).map_err(js)?;
let target = if inside.unwrap_or(false) {
LinkTarget::Inside(target.to_owned())
} else {
LinkTarget::Outside(target.to_owned())
};
let ws = self.sheet_mut(sheet)?;
ws.hyperlinks.retain(|link| link.range != area);
ws.hyperlinks.push(Hyperlink {
range: area,
target,
display,
tooltip,
});
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = removeHyperlink)]
pub fn remove_hyperlink(&mut self, sheet: usize, range: &str) -> Result<bool, JsError> {
let area = Range::parse(range).map_err(js)?;
let ws = self.sheet_mut(sheet)?;
let before = ws.hyperlinks.len();
ws.hyperlinks.retain(|link| link.range != area);
Ok(ws.hyperlinks.len() != before)
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = addTable)]
pub fn add_table(
&mut self,
sheet: usize,
name: &str,
range: &str,
header_row: Option<bool>,
) -> Result<(), JsError> {
use crate::model::table::{Table, TableColumn, TableStyle};
let area = Range::parse(range).map_err(js)?;
let taken = self
.book
.sheets()
.iter()
.flat_map(|ws| &ws.tables)
.any(|t| t.display_name.eq_ignore_ascii_case(name));
if taken {
return Err(JsError::new(
"a table of that name is already in the workbook",
));
}
let header = header_row.unwrap_or(true);
let ws = self.sheet_mut(sheet)?;
let mut columns = Vec::new();
for (index, col) in (area.start.col.index()..=area.end.col.index()).enumerate() {
let named = Col::new(col)
.filter(|_| header)
.and_then(|col| ws.get(CellRef::new(col, area.start.row)))
.and_then(|cell| cell.value.plain_text())
.filter(|text| !text.is_empty());
columns.push(TableColumn {
id: u32::try_from(index + 1).unwrap_or(u32::MAX),
name: named.unwrap_or_else(|| format!("Column{}", index + 1)),
totals_row_function: None,
totals_row_label: None,
calculated_formula: None,
});
}
let id = u32::try_from(ws.tables.len() + 1).unwrap_or(u32::MAX);
ws.tables.push(Table {
id,
name: name.to_owned(),
display_name: name.to_owned(),
range: area,
header_row_count: Some(u32::from(header)),
totals_row_count: None,
auto_filter: header.then_some(area),
columns,
style: Some(TableStyle::default()),
});
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = removeTable)]
pub fn remove_table(&mut self, sheet: usize, name: &str) -> Result<bool, JsError> {
let ws = self.sheet_mut(sheet)?;
let before = ws.tables.len();
ws.tables
.retain(|table| !table.display_name.eq_ignore_ascii_case(name));
Ok(ws.tables.len() != before)
}
#[wasm_bindgen(js_name = sheetView, unchecked_return_type = "SheetViewInfo")]
pub fn sheet_view(&self, sheet: usize) -> Result<JsValue, JsError> {
let view = &self.sheet_of(sheet)?.view;
let frozen = view
.pane
.as_ref()
.filter(|pane| pane.state != crate::model::PaneState::Split);
Ok(object(&[
(
"frozenRows",
JsValue::from_f64(frozen.map_or(0.0, |pane| f64::from(pane.y_split))),
),
(
"frozenColumns",
JsValue::from_f64(frozen.map_or(0.0, |pane| f64::from(pane.x_split))),
),
(
"zoom",
view.zoom_scale
.map_or(JsValue::NULL, |z| JsValue::from_f64(f64::from(z))),
),
("showGridLines", JsValue::from_bool(view.show_grid_lines)),
(
"showRowColHeaders",
JsValue::from_bool(view.show_row_col_headers),
),
("rightToLeft", JsValue::from_bool(view.right_to_left)),
(
"topLeftCell",
opt_str(view.top_left_cell.map(|at| at.to_string()).as_deref()),
),
]))
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = freezePanes)]
pub fn freeze_panes(&mut self, sheet: usize, rows: u32, columns: u32) -> Result<(), JsError> {
use crate::model::{Pane, PanePosition, PaneState};
let ws = self.sheet_mut(sheet)?;
if rows == 0 && columns == 0 {
ws.view.pane = None;
return Ok(());
}
let top_left = at_index(rows + 1, columns + 1)?;
ws.view.pane = Some(Pane {
x_split: columns,
y_split: rows,
top_left_cell: Some(top_left),
active_pane: match (rows, columns) {
(0, _) => PanePosition::TopRight,
(_, 0) => PanePosition::BottomLeft,
_ => PanePosition::BottomRight,
},
state: PaneState::Frozen,
});
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = unfreezePanes)]
pub fn unfreeze_panes(&mut self, sheet: usize) -> Result<(), JsError> {
self.sheet_mut(sheet)?.view.pane = None;
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setZoom)]
pub fn set_zoom(&mut self, sheet: usize, percent: Option<u32>) -> Result<(), JsError> {
if percent.is_some_and(|z| !(10..=400).contains(&z)) {
return Err(JsError::new("a zoom is between 10 and 400 percent"));
}
self.sheet_mut(sheet)?.view.zoom_scale = percent;
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setShowGridLines)]
pub fn set_show_grid_lines(
&mut self,
sheet: usize,
show: bool,
headers: Option<bool>,
) -> Result<(), JsError> {
let view = &mut self.sheet_mut(sheet)?.view;
view.show_grid_lines = show;
if let Some(headers) = headers {
view.show_row_col_headers = headers;
}
Ok(())
}
#[wasm_bindgen(js_name = definedNames, unchecked_return_type = "WorkbookName[]")]
#[must_use]
pub fn defined_names(&self) -> JsValue {
let out = js_sys::Array::new();
for name in &self.book.defined_names {
out.push(&object(&[
("name", JsValue::from_str(&name.name)),
("formula", JsValue::from_str(&name.formula)),
(
"sheet",
name.sheet.map_or(JsValue::NULL, |s| {
#[expect(
clippy::cast_precision_loss,
reason = "a sheet index is far below 2^53"
)]
JsValue::from_f64(s as f64)
}),
),
("hidden", JsValue::from_bool(name.hidden)),
]));
}
out.into()
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = setDefinedName)]
pub fn set_defined_name(
&mut self,
name: &str,
formula: &str,
sheet: Option<usize>,
) -> Result<(), JsError> {
if name.is_empty() {
return Err(JsError::new("a defined name is not empty"));
}
if sheet.is_some_and(|index| self.book.sheet(index).is_none()) {
return Err(JsError::new("no such sheet"));
}
self.book
.defined_names
.retain(|existing| !(existing.name == name && existing.sheet == sheet));
self.book.defined_names.push(crate::model::DefinedName {
name: name.to_owned(),
sheet,
formula: formula.to_owned(),
hidden: false,
});
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = removeDefinedName)]
pub fn remove_defined_name(&mut self, name: &str, sheet: Option<usize>) -> bool {
let before = self.book.defined_names.len();
self.book
.defined_names
.retain(|existing| !(existing.name == name && existing.sheet == sheet));
let removed = self.book.defined_names.len() != before;
if removed {
self.forget_dependencies();
}
removed
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = protectSheet)]
#[expect(
clippy::needless_pass_by_value,
reason = "an optional string crosses the wasm boundary owned"
)]
pub fn protect_sheet(&mut self, sheet: usize, password: Option<String>) -> Result<(), JsError> {
use crate::model::protection::PasswordHash;
let hash = match password.as_deref() {
Some(word) => Some(
PasswordHash::new(word)
.ok_or_else(|| JsError::new("the password could not be hashed"))?,
),
None => None,
};
let protection = &mut self.sheet_mut(sheet)?.protection;
protection.sheet = Some(true);
protection.password = hash;
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = unprotectSheet)]
pub fn unprotect_sheet(&mut self, sheet: usize) -> Result<(), JsError> {
self.sheet_mut(sheet)?.protection = crate::model::protection::SheetProtection::default();
Ok(())
}
#[wasm_bindgen(js_name = sheetProtection, unchecked_return_type = "ProtectionInfo")]
pub fn sheet_protection(&self, sheet: usize) -> Result<JsValue, JsError> {
let protection = &self.sheet_of(sheet)?.protection;
Ok(object(&[
(
"locked",
JsValue::from_bool(protection.sheet.unwrap_or(false)),
),
(
"hasPassword",
JsValue::from_bool(protection.password.is_some()),
),
]))
}
#[wasm_bindgen(js_name = verifySheetPassword)]
pub fn verify_sheet_password(&self, sheet: usize, password: &str) -> Result<bool, JsError> {
Ok(self
.sheet_of(sheet)?
.protection
.password
.as_ref()
.is_some_and(|hash| hash.verify(password)))
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = protectWorkbook)]
#[expect(
clippy::needless_pass_by_value,
reason = "an optional string crosses the wasm boundary owned"
)]
pub fn protect_workbook(
&mut self,
password: Option<String>,
windows: Option<bool>,
) -> Result<(), JsError> {
use crate::model::protection::PasswordHash;
let hash = match password.as_deref() {
Some(word) => Some(
PasswordHash::new(word)
.ok_or_else(|| JsError::new("the password could not be hashed"))?,
),
None => None,
};
self.book.protection.lock_structure = Some(true);
self.book.protection.lock_windows = windows.map(Some).unwrap_or_default();
self.book.protection.workbook_password = hash;
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = unprotectWorkbook)]
pub fn unprotect_workbook(&mut self) {
self.book.protection = crate::model::protection::WorkbookProtection::default();
}
#[wasm_bindgen(js_name = workbookProtection, unchecked_return_type = "ProtectionInfo")]
#[must_use]
pub fn workbook_protection(&self) -> JsValue {
object(&[
(
"locked",
JsValue::from_bool(self.book.protection.lock_structure.unwrap_or(false)),
),
(
"hasPassword",
JsValue::from_bool(self.book.protection.workbook_password.is_some()),
),
])
}
#[wasm_bindgen(js_name = dataValidations, unchecked_return_type = "SheetValidation[]")]
pub fn data_validations(&self, sheet: usize) -> Result<JsValue, JsError> {
let out = js_sys::Array::new();
for rule in &self.sheet_of(sheet)?.data_validations {
out.push(&object(&[
("sqref", ranges_to_js(&rule.sqref)),
("type", JsValue::from_str(rule.kind.as_str())),
("operator", JsValue::from_str(rule.operator.as_str())),
("formula1", JsValue::from_str(&rule.formula1)),
("formula2", JsValue::from_str(&rule.formula2)),
("allowBlank", JsValue::from_bool(rule.allow_blank)),
("showDropDown", JsValue::from_bool(!rule.hide_drop_down)),
]));
}
Ok(out.into())
}
#[wasm_bindgen(
js_name = conditionalFormats,
unchecked_return_type = "SheetConditionalFormat[]"
)]
pub fn conditional_formats(&self, sheet: usize) -> Result<JsValue, JsError> {
let out = js_sys::Array::new();
for block in &self.sheet_of(sheet)?.conditional_formats {
let rules = js_sys::Array::new();
for rule in &block.rules {
let formulas = js_sys::Array::new();
for formula in &rule.formulas {
formulas.push(&JsValue::from_str(formula));
}
rules.push(&object(&[
("type", JsValue::from_str(rule.kind.as_str())),
("priority", JsValue::from_f64(f64::from(rule.priority))),
(
"operator",
rule.operator
.map_or(JsValue::NULL, |op| JsValue::from_str(op.as_str())),
),
("formulas", formulas.into()),
("text", opt_str(rule.text.as_deref())),
]));
}
out.push(&object(&[
("sqref", ranges_to_js(&block.sqref)),
("rules", rules.into()),
]));
}
Ok(out.into())
}
#[wasm_bindgen(js_name = autoFilter, unchecked_return_type = "SheetAutoFilter | undefined")]
pub fn auto_filter(&self, sheet: usize) -> Result<JsValue, JsError> {
use crate::model::autofilter::ColumnFilter;
let Some(filter) = &self.sheet_of(sheet)?.auto_filter else {
return Ok(JsValue::UNDEFINED);
};
let columns = js_sys::Array::new();
for column in &filter.columns {
let kind = match &column.filter {
Some(ColumnFilter::Values { .. }) => "values",
Some(ColumnFilter::Custom { .. }) => "custom",
Some(ColumnFilter::Dynamic { .. }) => "dynamic",
Some(ColumnFilter::Top10 { .. }) => "top10",
None => "none",
};
columns.push(&object(&[
("colId", JsValue::from_f64(f64::from(column.col_id))),
("kind", JsValue::from_str(kind)),
]));
}
Ok(object(&[
("range", JsValue::from_str(&filter.range.to_string())),
("columns", columns.into()),
]))
}
#[wasm_bindgen(js_name = pivotTables, unchecked_return_type = "SheetPivotTable[]")]
#[expect(
clippy::cast_precision_loss,
reason = "counts of pivot fields are far below 2^53"
)]
pub fn pivot_tables(&self, sheet: usize) -> Result<JsValue, JsError> {
let out = js_sys::Array::new();
for pivot in &self.sheet_of(sheet)?.pivot_tables {
out.push(&object(&[
("name", JsValue::from_str(&pivot.name)),
(
"location",
opt_str(pivot.location.map(|r| r.to_string()).as_deref()),
),
("cacheId", JsValue::from_f64(f64::from(pivot.cache_id))),
(
"rowFields",
JsValue::from_f64(pivot.row_fields.len() as f64),
),
(
"columnFields",
JsValue::from_f64(pivot.column_fields.len() as f64),
),
(
"valueFields",
JsValue::from_f64(pivot.data_fields.len() as f64),
),
]));
}
Ok(out.into())
}
#[wasm_bindgen(js_name = arrayFormulas)]
pub fn array_formulas(&self, sheet: usize) -> Result<Vec<String>, JsError> {
Ok(self
.sheet_of(sheet)?
.array_formulas
.iter()
.map(ToString::to_string)
.collect())
}
#[wasm_bindgen(js_name = externalBooks)]
#[must_use]
pub fn external_books(&self) -> Vec<JsValue> {
self.book
.external
.iter()
.map(|book| opt_str(book.path.as_deref()))
.collect()
}
#[cfg(feature = "write")]
pub fn merge(&mut self, sheet: usize, range: &str) -> Result<(), JsError> {
let area = Range::parse(range).map_err(js)?;
let ws = self
.book
.sheet_mut(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?;
if !ws.merges.contains(&area) {
ws.merges.push(area);
}
Ok(())
}
#[cfg(feature = "write")]
pub fn unmerge(&mut self, sheet: usize, range: &str) -> Result<bool, JsError> {
let area = Range::parse(range).map_err(js)?;
let ws = self
.book
.sheet_mut(sheet)
.ok_or_else(|| JsError::new("no such sheet"))?;
let before = ws.merges.len();
ws.merges.retain(|m| *m != area);
Ok(ws.merges.len() != before)
}
#[cfg(feature = "write")]
#[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())?;
crate::edit::insert_rows_with(&mut self.book, sheet, row, count, origin).map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[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)?;
crate::edit::remove_rows(&mut self.book, sheet, row, count).map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[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())?;
crate::edit::insert_columns_with(&mut self.book, sheet, col, count, origin).map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[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)?;
crate::edit::remove_columns(&mut self.book, sheet, col, count).map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[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 = Range::parse(range).map_err(js)?;
let at = CellRef::parse(to).map_err(js)?;
crate::edit::copy_range(&mut self.book, sheet, area, to_sheet.unwrap_or(sheet), at)
.map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[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 = Range::parse(range).map_err(js)?;
let at = CellRef::parse(to).map_err(js)?;
crate::edit::move_range(&mut self.book, sheet, area, to_sheet.unwrap_or(sheet), at)
.map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[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,
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())?;
crate::edit::insert_cells_with(&mut self.book, sheet, area, axis_of(shift)?, origin)
.map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[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| {
js_sys::Reflect::get(options, &JsValue::from_str(name))
.ok()
.and_then(|v| v.as_bool())
.unwrap_or(false)
};
let options = crate::edit::SortOptions {
header: options.is_object() && flag("header"),
orientation: if options.is_object() && flag("byColumns") {
crate::edit::Axis::Columns
} else {
crate::edit::Axis::Rows
},
};
let keys = sort_keys_of(keys)?;
crate::edit::sort_range_with(&mut self.book, sheet, area, &keys, options).map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[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)?;
crate::edit::sort_table(&mut self.book, name, &keys).map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[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> {
use crate::edit::Axis;
let area = Range::parse(range).map_err(js)?;
let (axis, back) = match direction {
"down" => (Axis::Rows, false),
"right" => (Axis::Columns, false),
"up" => (Axis::Rows, true),
"left" => (Axis::Columns, true),
_ => {
return Err(JsError::new(
r#"a fill goes "down", "right", "up" or "left""#,
));
}
};
if back {
crate::edit::fill_series_back(&mut self.book, sheet, area, axis)
} else {
crate::edit::fill_series(&mut self.book, sheet, area, axis)
}
.map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[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)?;
crate::edit::fill(&mut self.book, sheet, area, crate::edit::Axis::Rows).map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[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)?;
crate::edit::fill(&mut self.book, sheet, area, crate::edit::Axis::Columns).map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = removeCells)]
pub fn remove_cells(&mut self, sheet: usize, range: &str, shift: &str) -> Result<(), JsError> {
let area = Range::parse(range).map_err(js)?;
crate::edit::remove_cells(&mut self.book, sheet, area, axis_of(shift)?).map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = moveSheet)]
pub fn move_sheet(&mut self, from: usize, to: usize) -> Result<(), JsError> {
crate::edit::move_sheet(&mut self.book, from, to).map_err(js)
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = removeSheet)]
pub fn remove_sheet(&mut self, sheet: usize) -> Result<(), JsError> {
crate::edit::remove_sheet(&mut self.book, sheet).map_err(js)?;
self.forget_dependencies();
Ok(())
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = toCsv)]
pub fn to_csv(&self, sheet: usize) -> Result<String, JsError> {
self.csv(sheet, ',')
}
#[cfg(feature = "write")]
#[wasm_bindgen(js_name = toCsvWith)]
pub fn to_csv_with(
&self,
sheet: usize,
#[wasm_bindgen(unchecked_param_type = "CsvOptions")] options: &JsValue,
) -> Result<String, JsError> {
let delimiter = match field(options, "delimiter") {
Some(value) => one_char(&value)?,
None => ',',
};
self.csv(sheet, delimiter)
}
#[cfg(feature = "write")]
fn csv(&self, sheet: usize, delimiter: char) -> Result<String, JsError> {
let mut out = Vec::new();
write_csv_to(&self.book, sheet, &mut out, delimiter).map_err(js)?;
String::from_utf8(out).map_err(js)
}
#[wasm_bindgen(js_name = readCsv)]
pub fn read_csv(
bytes: &[u8],
#[wasm_bindgen(unchecked_param_type = "CsvOptions")] options: &JsValue,
) -> Result<Book, JsError> {
let mut parsed = crate::reader::csv::CsvOptions::default();
if let Some(value) = field(options, "delimiter") {
parsed.delimiter = Some(one_char(&value)?);
}
if let Some(value) = field(options, "contiguous") {
parsed.contiguous = value.is_truthy();
}
if let Some(value) = field(options, "preserveEmptyFields") {
parsed.preserve_empty_fields = value.is_truthy();
}
Ok(Self::wrap(crate::reader::csv::read_csv_bytes(
bytes, &parsed,
)))
}
}
impl Book {
#[cfg(feature = "write")]
fn sheet_mut(&mut self, sheet: usize) -> Result<&mut Worksheet, JsError> {
self.book
.sheet_mut(sheet)
.ok_or_else(|| JsError::new("no such sheet"))
}
fn sheet_of(&self, sheet: usize) -> Result<&Worksheet, JsError> {
self.book
.sheet(sheet)
.ok_or_else(|| JsError::new("no such sheet"))
}
#[cfg(feature = "write")]
#[cfg_attr(
not(feature = "formulas"),
expect(clippy::unused_self, reason = "there is no index without the engine")
)]
fn forget_dependencies(&mut self) {
#[cfg(feature = "formulas")]
{
self.deps = None;
}
}
fn wrap(book: Spreadsheet) -> Self {
Self {
book,
#[cfg(feature = "formulas")]
deps: None,
#[cfg(feature = "formulas")]
custom: CustomFunctions::new(),
}
}
}
impl Default for Book {
fn default() -> Self {
Self::new()
}
}
fn at_index(row: u32, column: u32) -> Result<CellRef, JsError> {
let row = Row::from_one_based(u64::from(row)).map_err(js)?;
let col = Col::from_one_based(u64::from(column)).map_err(js)?;
Ok(CellRef::new(col, row))
}
fn area_at(row: u32, column: u32, rows: u32, columns: u32) -> Result<Range, JsError> {
if rows == 0 || columns == 0 {
return Err(JsError::new("a range covers at least one row and column"));
}
let start = at_index(row, column)?;
let end = at_index(row + rows - 1, column + columns - 1)?;
Ok(Range::new(start, end))
}
fn js_to_cell(value: &JsValue) -> Result<CellValue, JsError> {
if let Some(n) = value.as_f64() {
Ok(CellValue::Number(n))
} else if let Some(b) = value.as_bool() {
Ok(CellValue::Bool(b))
} else if let Some(s) = value.as_string() {
Ok(match s.strip_prefix('=') {
Some(formula) => CellValue::Formula {
formula: formula.to_owned(),
cached: None,
},
None => CellValue::text(s),
})
} else if value.is_null() || value.is_undefined() {
Ok(CellValue::Empty)
} else {
Err(JsError::new(
"value must be a number, boolean, string or null",
))
}
}
#[cfg(feature = "formulas")]
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 cell_to_js(value: &CellValue) -> JsValue {
match value {
CellValue::Number(n) => JsValue::from_f64(*n),
CellValue::Bool(b) => JsValue::from_bool(*b),
CellValue::Error(e) => JsValue::from_str(e.as_str()),
CellValue::Text(_) | CellValue::RichText(_) => {
JsValue::from_str(&value.plain_text().unwrap_or_default())
}
CellValue::Empty | CellValue::Formula { .. } => JsValue::NULL,
}
}
#[cfg(feature = "formulas")]
fn value_to_js_deep(value: &Value) -> JsValue {
match value {
Value::Array(rows) => {
let out = js_sys::Array::new();
for row in rows.iter() {
let line = js_sys::Array::new();
for cell in row {
line.push(&value_to_js_deep(cell));
}
out.push(&line);
}
out.into()
}
Value::Lambda(_) => JsValue::NULL,
other => value_to_js(other),
}
}
#[cfg(feature = "formulas")]
fn value_to_js(value: &Value) -> JsValue {
match value {
Value::Blank => 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::Lambda(_) => JsValue::NULL,
Value::Array(rows) => rows
.first()
.and_then(|r| r.first())
.map_or(JsValue::NULL, value_to_js),
}
}
fn color_to_js(color: &crate::style::Color) -> JsValue {
use crate::style::Color;
match color {
Color::Auto => JsValue::NULL,
Color::Argb(argb) => JsValue::from_str(&format!("#{argb:08X}")),
Color::Indexed(i) => JsValue::from_str(&format!("indexed:{i}")),
Color::Theme { id, tint } => JsValue::from_str(&if *tint == 0 {
format!("theme:{id}")
} else {
format!("theme:{id}@{}", f64::from(*tint) / 1_000_000.0)
}),
}
}
fn field(object: &JsValue, key: &str) -> Option<JsValue> {
let value = js_sys::Reflect::get(object, &JsValue::from_str(key)).ok()?;
(!value.is_undefined()).then_some(value)
}
#[cfg(feature = "write")]
fn color_from_js(value: &JsValue) -> Result<crate::style::Color, JsError> {
use crate::style::Color;
if value.is_null() {
return Ok(Color::Auto);
}
let text = value
.as_string()
.ok_or_else(|| JsError::new("a colour is a string or null"))?;
if let Some(index) = text.strip_prefix("indexed:") {
return index
.parse()
.map(Color::Indexed)
.map_err(|_| JsError::new("indexed:N takes a number"));
}
if let Some(rest) = text.strip_prefix("theme:") {
let (id, tint) = match rest.split_once('@') {
Some((id, tint)) => {
let tint: f64 = tint
.parse()
.map_err(|_| JsError::new("a theme tint is a number between -1 and 1"))?;
#[expect(
clippy::cast_possible_truncation,
reason = "a tint is between -1 and 1, and the file stores it in millionths"
)]
(id, (tint * 1_000_000.0).round() as i32)
}
None => (rest, 0),
};
return id
.parse()
.map(|id| Color::Theme { id, tint })
.map_err(|_| JsError::new("theme:N takes a number"));
}
Color::from_argb_str(text.strip_prefix('#').unwrap_or(&text))
.ok_or_else(|| JsError::new("a colour is #AARRGGBB, indexed:N, theme:N or null"))
}
#[cfg(feature = "write")]
fn number(value: &JsValue, what: &str) -> Result<f64, JsError> {
value
.as_f64()
.ok_or_else(|| JsError::new(&format!("{what} is a number")))
}
#[cfg(feature = "write")]
fn patch_font(font: &mut crate::style::Font, patch: &JsValue) -> Result<(), JsError> {
use crate::style::Underline;
if let Some(name) = field(patch, "name") {
font.name = name
.as_string()
.ok_or_else(|| JsError::new("a font name is a string"))?;
}
if let Some(size) = field(patch, "size") {
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "a font size in hundredths of a point is a small positive number"
)]
{
font.size = (number(&size, "a font size")? * 100.0).round() as u32;
}
}
if let Some(bold) = field(patch, "bold") {
font.bold = bold.is_truthy();
}
if let Some(italic) = field(patch, "italic") {
font.italic = italic.is_truthy();
}
if let Some(strike) = field(patch, "strike") {
font.strike = strike.is_truthy();
}
if let Some(underline) = field(patch, "underline") {
font.underline = underline
.as_string()
.map(|u| Underline::parse(&u))
.ok_or_else(|| JsError::new("an underline is a string"))?;
}
if let Some(color) = field(patch, "color") {
font.color = color_from_js(&color)?;
}
Ok(())
}
#[cfg(feature = "write")]
fn patch_fill(fill: &mut crate::style::Fill, patch: &JsValue) -> Result<(), JsError> {
if let Some(pattern) = field(patch, "pattern") {
fill.pattern = pattern
.as_string()
.map(|p| crate::style::Pattern::parse(&p))
.ok_or_else(|| JsError::new("a fill pattern is a string"))?;
}
if let Some(color) = field(patch, "foreground") {
fill.foreground = color_from_js(&color)?;
}
if let Some(color) = field(patch, "background") {
fill.background = color_from_js(&color)?;
}
Ok(())
}
#[cfg(feature = "write")]
fn patch_borders(borders: &mut crate::style::Borders, patch: &JsValue) -> Result<(), JsError> {
for (key, side) in [
("left", &mut borders.left),
("right", &mut borders.right),
("top", &mut borders.top),
("bottom", &mut borders.bottom),
] {
let Some(patch) = field(patch, key) else {
continue;
};
if let Some(kind) = field(&patch, "style") {
side.style = kind
.as_string()
.map(|s| crate::style::BorderStyle::parse(&s))
.ok_or_else(|| JsError::new("a border style is a string"))?;
}
if let Some(color) = field(&patch, "color") {
side.color = color_from_js(&color)?;
}
}
Ok(())
}
#[cfg(feature = "write")]
fn patch_alignment(
alignment: &mut crate::style::Alignment,
patch: &JsValue,
) -> Result<(), JsError> {
use crate::style::{HorizontalAlign, VerticalAlign};
if let Some(horizontal) = field(patch, "horizontal") {
alignment.horizontal = horizontal
.as_string()
.map_or(HorizontalAlign::General, |h| HorizontalAlign::parse(&h));
}
if let Some(vertical) = field(patch, "vertical") {
alignment.vertical = vertical
.as_string()
.map_or(VerticalAlign::Bottom, |v| VerticalAlign::parse(&v));
}
if let Some(wrap) = field(patch, "wrapText") {
alignment.wrap_text = wrap.is_truthy();
}
if let Some(shrink) = field(patch, "shrinkToFit") {
alignment.shrink_to_fit = shrink.is_truthy();
}
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "indent steps and a rotation in degrees are small positive numbers"
)]
{
if let Some(indent) = field(patch, "indent") {
alignment.indent = number(&indent, "an indent")? as u32;
}
if let Some(rotation) = field(patch, "textRotation") {
alignment.text_rotation = number(&rotation, "a text rotation")? as u32;
}
}
Ok(())
}
#[cfg(feature = "write")]
fn apply_style_patch(style: &mut crate::style::Style, patch: &JsValue) -> Result<(), JsError> {
if let Some(code) = field(patch, "numberFormat") {
let code = code
.as_string()
.ok_or_else(|| JsError::new("a number format is a string"))?;
style.number_format = if code == crate::style::format::GENERAL {
crate::style::NumberFormat::General
} else {
crate::style::NumberFormat::Custom(code)
};
}
if let Some(font) = field(patch, "font") {
patch_font(&mut style.font, &font)?;
}
if let Some(fill) = field(patch, "fill") {
patch_fill(&mut style.fill, &fill)?;
}
if let Some(borders) = field(patch, "borders") {
patch_borders(&mut style.borders, &borders)?;
}
if let Some(alignment) = field(patch, "alignment") {
patch_alignment(&mut style.alignment, &alignment)?;
}
Ok(())
}
#[cfg(feature = "write")]
fn axis_of(shift: &str) -> Result<crate::edit::Axis, JsError> {
match shift {
"down" | "up" => Ok(crate::edit::Axis::Rows),
"right" | "left" => Ok(crate::edit::Axis::Columns),
_ => Err(JsError::new(
r#"a shift is "down", "up", "right" or "left""#,
)),
}
}
fn one_char(value: &JsValue) -> Result<char, JsError> {
value
.as_string()
.and_then(|text| {
let mut chars = text.chars();
chars.next().filter(|_| chars.next().is_none())
})
.ok_or_else(|| JsError::new("a delimiter is one character"))
}
fn ranges_to_js(ranges: &[Range]) -> JsValue {
let out = js_sys::Array::new();
for area in ranges {
out.push(&JsValue::from_str(&area.to_string()));
}
out.into()
}
fn opt_str(text: Option<&str>) -> JsValue {
text.map_or(JsValue::NULL, JsValue::from_str)
}
fn opt_count(count: Option<u32>) -> JsValue {
count.map_or(JsValue::NULL, |n| JsValue::from_f64(f64::from(n)))
}
fn anchor_to_js(anchor: &crate::model::chart::Anchor) -> JsValue {
use crate::model::chart::Anchor;
let (kind, at) = match anchor {
Anchor::TwoCell { from, .. } => ("twoCell", Some(from)),
Anchor::OneCell { from, .. } => ("oneCell", Some(from)),
Anchor::Absolute { .. } => ("absolute", None),
};
object(&[
("kind", JsValue::from_str(kind)),
(
"row",
at.map_or(JsValue::NULL, |m| {
JsValue::from_f64(f64::from(m.row.one_based()))
}),
),
(
"column",
at.map_or(JsValue::NULL, |m| {
JsValue::from_f64(f64::from(m.col.one_based()))
}),
),
])
}
fn object(fields: &[(&str, JsValue)]) -> JsValue {
let out = js_sys::Object::new();
for (key, value) in fields {
let _ = js_sys::Reflect::set(&out, &JsValue::from_str(key), value);
}
out.into()
}
fn border_to_js(border: &crate::style::Border) -> JsValue {
object(&[
("style", JsValue::from_str(border.style.as_str())),
("color", color_to_js(&border.color)),
])
}
fn style_to_js(style: &crate::style::Style) -> JsValue {
let font = object(&[
("name", JsValue::from_str(&style.font.name)),
(
"size",
JsValue::from_f64(f64::from(style.font.size) / 100.0),
),
("bold", JsValue::from_bool(style.font.bold)),
("italic", JsValue::from_bool(style.font.italic)),
(
"underline",
JsValue::from_str(style.font.underline.as_str()),
),
("strike", JsValue::from_bool(style.font.strike)),
("color", color_to_js(&style.font.color)),
]);
let fill = object(&[
("pattern", JsValue::from_str(style.fill.pattern.as_str())),
("foreground", color_to_js(&style.fill.foreground)),
("background", color_to_js(&style.fill.background)),
]);
let borders = object(&[
("left", border_to_js(&style.borders.left)),
("right", border_to_js(&style.borders.right)),
("top", border_to_js(&style.borders.top)),
("bottom", border_to_js(&style.borders.bottom)),
]);
let alignment = object(&[
(
"horizontal",
style
.alignment
.horizontal
.as_str()
.map_or(JsValue::NULL, JsValue::from_str),
),
(
"vertical",
style
.alignment
.vertical
.as_str()
.map_or(JsValue::NULL, JsValue::from_str),
),
("wrapText", JsValue::from_bool(style.alignment.wrap_text)),
(
"shrinkToFit",
JsValue::from_bool(style.alignment.shrink_to_fit),
),
(
"indent",
JsValue::from_f64(f64::from(style.alignment.indent)),
),
(
"textRotation",
JsValue::from_f64(f64::from(style.alignment.text_rotation)),
),
]);
object(&[
(
"numberFormat",
JsValue::from_str(style.number_format.code()),
),
("font", font),
("fill", fill),
("borders", borders),
("alignment", alignment),
])
}
#[cfg(feature = "write")]
fn copy_origin_of(name: Option<&str>) -> Result<crate::edit::CopyOrigin, JsError> {
use crate::edit::CopyOrigin;
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:?}"
))),
}
}
#[cfg(feature = "write")]
fn sort_keys_of(keys: &JsValue) -> Result<Vec<crate::edit::SortKey>, JsError> {
use crate::edit::{SortBy, SortKey};
let keys: js_sys::Array = keys
.clone()
.dyn_into()
.map_err(|_| JsError::new("sort keys are an array"))?;
keys.iter()
.map(|key| {
if let Some(n) = key.as_f64() {
#[expect(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
let line = n.abs() as u32;
let line = line
.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()
}