imprimatur 0.2.0 → 0.4.0

data/ext/imprimatur_native/core/src/read/xlsx/formats.rs

@@ -0,0 +1,155 @@
+//! A workbook's cell formats (`styles.xml`): for each, how it shows numbers
+//! and how it looks.
+
+use std::borrow::Cow;
+use std::sync::Arc;
+
+use crate::Result;
+use crate::read::Budget;
+use crate::read::content::Look;
+use crate::read::numbers::{Shown, built_in, classify};
+use crate::xml::reader::{Event, XmlReader};
+
+/// The cell formats (`cellXfs`), by index.
+#[derive(Default)]
+pub struct Formats {
+    pub shown: Vec<Shown>,
+    pub looks: Vec<Arc<Look>>,
+}
+
+/// Where in `styles.xml` the reader is.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Section {
+    Other,
+    Fonts,
+    Fills,
+    Borders,
+    CellFormats,
+}
+
+/// A font, fill and border by their index, before the formats pick them.
+#[derive(Default)]
+struct Parts {
+    codes: Vec<(u32, String)>,
+    fonts: Vec<Look>,
+    fills: Vec<Option<String>>,
+    borders: Vec<Option<String>>,
+}
+
+pub fn formats(text: &str, budget: &Budget<'_>) -> Result<Formats> {
+    let mut xml = XmlReader::new(text, budget.max_depth());
+    let (mut parts, mut section, mut side) = (Parts::default(), Section::Other, "");
+    let mut formats = Formats { shown: Vec::new(), looks: Vec::new() };
+    while let Some(event) = xml.next()? {
+        match event {
+            Event::Start(tag) => match (section, tag.name()) {
+                (_, "numFmt") => {
+                    if let (Some(id), Some(code)) = (tag.attr("numFmtId"), tag.attr("formatCode")) {
+                        parts.codes.push((id.parse().unwrap_or(u32::MAX), code.into_owned()));
+                    }
+                }
+                (_, "fonts") => section = Section::Fonts,
+                (_, "fills") => section = Section::Fills,
+                (_, "borders") => section = Section::Borders,
+                (_, "cellXfs") => section = Section::CellFormats,
+                (Section::Fonts, "font") => parts.fonts.push(Look::default()),
+                (Section::Fonts, name) => font_part(&mut parts.fonts, name, tag),
+                (Section::Fills, "fill") => parts.fills.push(None),
+                (Section::Fills, "fgColor") => {
+                    if let Some(fill) = parts.fills.last_mut() {
+                        *fill = tag.attr("rgb").map(|rgb| rgb.to_uppercase());
+                    }
+                }
+                (Section::Borders, "border") => parts.borders.push(None),
+                (Section::Borders, name) if side.is_empty() => {
+                    side = name;
+                    if name == "left"
+                        && let Some(border) = parts.borders.last_mut()
+                    {
+                        *border = tag.attr("style").map(Cow::into_owned);
+                    }
+                }
+                (Section::CellFormats, "xf") => {
+                    let id = |name| tag.parse::<usize>(name);
+                    let number = tag.parse("numFmtId").unwrap_or(0);
+                    let custom = parts.codes.iter().find(|(id, _)| *id == number);
+                    let shown = custom.map_or_else(|| built_in(number), |(_, code)| classify(code));
+                    let font = parts.fonts.get(id("fontId").unwrap_or(0));
+                    let mut look = font.cloned().unwrap_or_default();
+                    look.fill = parts.fills.get(id("fillId").unwrap_or(0)).cloned().flatten();
+                    look.border = parts.borders.get(id("borderId").unwrap_or(0)).cloned().flatten();
+                    look.number_format = custom.map_or_else(
+                        || built_in_code(number).map_or_else(|| number.to_string(), str::to_owned),
+                        |(_, code)| code.clone(),
+                    );
+                    formats.shown.push(shown);
+                    formats.looks.push(Arc::new(look));
+                }
+                (Section::CellFormats, "alignment") => {
+                    if let Some(look) = formats.looks.last_mut().map(Arc::make_mut) {
+                        look.align = tag.attr("horizontal").map(Cow::into_owned);
+                        look.valign = tag.attr("vertical").map(Cow::into_owned);
+                        look.wrap = tag.on("wrapText");
+                    }
+                }
+                _ => {}
+            },
+            Event::End(name) => match name {
+                "fonts" | "fills" | "borders" | "cellXfs" => section = Section::Other,
+                _ if name == side => side = "",
+                _ => {}
+            },
+            Event::Text(_) => {}
+        }
+    }
+    Ok(formats)
+}
+
+/// A property of the font being read.
+fn font_part(fonts: &mut [Look], name: &str, tag: crate::xml::reader::Tag<'_>) {
+    let Some(font) = fonts.last_mut() else { return };
+    match name {
+        "b" => font.bold = tag.flag("val"),
+        "i" => font.italic = tag.flag("val"),
+        "u" => font.underline = tag.attr("val").is_none_or(|style| style != "none"),
+        "sz" => font.size = tag.parse("val").unwrap_or(0.0),
+        "name" => font.font = tag.attr("val").map(Cow::into_owned).unwrap_or_default(),
+        "color" => font.color = tag.attr("rgb").map(|rgb| rgb.to_uppercase()),
+        _ => {}
+    }
+}
+
+/// The codes of Excel's built-in number formats (ECMA-376 Part 1, 18.8.30).
+const fn built_in_code(id: u32) -> Option<&'static str> {
+    Some(match id {
+        0 => "General",
+        1 => "0",
+        2 => "0.00",
+        3 => "#,##0",
+        4 => "#,##0.00",
+        9 => "0%",
+        10 => "0.00%",
+        11 => "0.00E+00",
+        12 => "# ?/?",
+        13 => "# ??/??",
+        14 => "mm-dd-yy",
+        15 => "d-mmm-yy",
+        16 => "d-mmm",
+        17 => "mmm-yy",
+        18 => "h:mm AM/PM",
+        19 => "h:mm:ss AM/PM",
+        20 => "h:mm",
+        21 => "h:mm:ss",
+        22 => "m/d/yy h:mm",
+        37 => "#,##0 ;(#,##0)",
+        38 => "#,##0 ;[Red](#,##0)",
+        39 => "#,##0.00;(#,##0.00)",
+        40 => "#,##0.00;[Red](#,##0.00)",
+        45 => "mm:ss",
+        46 => "[h]:mm:ss",
+        47 => "mmss.0",
+        48 => "##0.0E+0",
+        49 => "@",
+        _ => return None,
+    })
+}

data/ext/imprimatur_native/core/src/read/xlsx.rs

@@ -3,19 +3,21 @@
 //! digits), formulas without a cached result as `=FORMULA`, then the sheet's
 //! comments.
 
+mod formats;
 #[cfg(test)]
 mod tests;
 
 use std::sync::Arc;
 
+use self::formats::{Formats, formats};
 use super::Budget;
-use super::content::{Grid, Note, Sheet, Value};
-use super::numbers::{Shown, push_number, styles};
+use super::content::{Columns, Grid, Note, Sheet, Styled, Validation, Value};
+use super::numbers::{Shown, push_number};
 use super::package::Package;
 use crate::Result;
 use crate::xlsx::parse_cell_reference;
 use crate::xlsx::text::unescape as unescape_xstring;
-use crate::xml::reader::{Event, XmlReader};
+use crate::xml::reader::{Event, Tag, XmlReader};
 
 /// A cell's `t` attribute.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -51,13 +53,24 @@ impl Strings {
     }
 }
 
-/// Where a cell's text events go.
+/// Where a cell's text events go, or a validation's formulas'.
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum Into {
     Nowhere,
     Value,
     Formula,
     Inline,
+    First,
+    Second,
+}
+
+/// What a sheet holds besides its cells' values.
+#[derive(Default)]
+struct Parts {
+    columns: Vec<Columns>,
+    validations: Vec<Validation>,
+    /// Cells with a format of their own: row, column, format.
+    styled: Vec<(u32, u32, usize)>,
 }
 
 pub fn content(package: &Package<'_>, budget: &Budget<'_>) -> Result<Vec<Sheet>> {
@@ -67,21 +80,31 @@ pub fn content(package: &Package<'_>, budget: &Budget<'_>) -> Result<Vec<Sheet>>
     let (listed, date1904) = workbook(&text, &relationships, budget)?;
     let strings = package
         .parse_related(&relationships, "sharedStrings", |text| shared_strings(text, budget))?;
-    let shown = package.parse_related(&relationships, "styles", |text| styles(text, budget))?;
-    let book = Book { strings: &strings, shown: &shown, date1904 };
+    let formats = package.parse_related(&relationships, "styles", |text| formats(text, budget))?;
+    let book = Book { strings: &strings, shown: &formats.shown, date1904 };
     let mut sheets = Vec::with_capacity(listed.len());
     let mut scratch = String::new();
     for sheet in listed {
         budget.check()?;
         let Some(text) = package.text(&sheet.part)? else { continue };
-        let cells = cells(&text, &book, &mut scratch, budget)?;
+        let (cells, parts) = cells(&text, &book, &mut scratch, budget)?;
         let comments = match package.related(&sheet.part, "comments")? {
             Some(part) => package
                 .text(&part)?
                 .map_or_else(|| Ok(Vec::new()), |text| comments(&text, budget))?,
             None => Vec::new(),
         };
-        sheets.push(Sheet { name: sheet.name, hidden: sheet.hidden, cells, comments });
+        let styles = styled(&parts.styled, &formats);
+        let (columns, validations) = (parts.columns, parts.validations);
+        sheets.push(Sheet {
+            name: sheet.name,
+            hidden: sheet.hidden,
+            cells,
+            comments,
+            columns,
+            validations,
+            styles,
+        });
     }
     Ok(sheets)
 }
@@ -155,8 +178,13 @@ struct Head {
     style: usize,
 }
 
-fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>) -> Result<Grid> {
-    let mut grid = Grid::default();
+fn cells(
+    text: &str,
+    book: &Book<'_>,
+    scratch: &mut String,
+    budget: &Budget<'_>,
+) -> Result<(Grid, Parts)> {
+    let (mut grid, mut parts, mut rule) = (Grid::default(), Parts::default(), None);
     let mut xml = XmlReader::new(text, budget.max_depth());
     let (mut row, mut next_row, mut next_column) = (0_u32, 0_u32, 0_u32);
     let (mut value, mut formula, mut inline) = (String::new(), String::new(), String::new());
@@ -166,10 +194,7 @@ fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>)
         match event {
             Event::Start(tag) => match tag.name() {
                 "row" => {
-                    row = tag
-                        .attr("r")
-                        .and_then(|r| r.parse::<u32>().ok())
-                        .map_or(next_row, |r| r.saturating_sub(1));
+                    row = tag.parse::<u32>("r").map_or(next_row, |r| r.saturating_sub(1));
                     next_column = 0;
                 }
                 "c" => {
@@ -186,7 +211,7 @@ fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>)
                         Some("d") => Kind::Iso,
                         _ => Kind::Number,
                     };
-                    let style = tag.attr("s").and_then(|s| s.parse().ok()).unwrap_or(0);
+                    let style = tag.parse("s").unwrap_or(0);
                     head = Some(Head { row: at_row, column, kind, style });
                     value.clear();
                     formula.clear();
@@ -198,17 +223,36 @@ fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>)
                     into = Into::Inline;
                 }
                 "rPh" => xml.skip()?,
+                "col" => parts.columns.extend(columns(tag)),
+                "dataValidation" => rule = Some(validation(tag)),
+                "formula1" if rule.is_some() => (into, value) = (Into::First, String::new()),
+                "formula2" if rule.is_some() => (into, value) = (Into::Second, String::new()),
                 _ => {}
             },
             Event::Text(text) => match into {
-                Into::Value => value.push_str(&text),
+                Into::Value | Into::First | Into::Second => value.push_str(&text),
                 Into::Formula => formula.push_str(&text),
                 Into::Inline => inline.push_str(&unescape_xstring(&text)),
                 Into::Nowhere => {}
             },
             Event::End("v" | "f" | "t") => into = Into::Nowhere,
+            Event::End(end @ ("formula1" | "formula2")) => {
+                if let Some(rule) = rule.as_mut() {
+                    let formula = Some(std::mem::take(&mut value));
+                    if end == "formula1" {
+                        rule.formula1 = formula;
+                    } else {
+                        rule.formula2 = formula;
+                    }
+                }
+                into = Into::Nowhere;
+            }
+            Event::End("dataValidation") => parts.validations.extend(rule.take()),
             Event::End("c") => {
                 if let Some(head) = head.take() {
+                    if head.style != 0 {
+                        parts.styled.push((head.row, head.column, head.style));
+                    }
                     write_cell(&mut grid, &head, book, [&value, &formula, &inline], scratch);
                     next_column = head.column + 1;
                 }
@@ -217,7 +261,7 @@ fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>)
             Event::End(_) => {}
         }
     }
-    Ok(grid.finish())
+    Ok((grid.finish(), parts))
 }
 
 fn write_cell(
@@ -272,6 +316,48 @@ fn write_cell(
     grid.end_cell(head.row, head.column, kind);
 }
 
+/// A `<col>`: a run of columns, from 0.
+fn columns(tag: Tag<'_>) -> Option<Columns> {
+    let number = |name| tag.parse::<u32>(name);
+    let (first, last) = (number("min")?.checked_sub(1)?, number("max")?.checked_sub(1)?);
+    let width = tag.parse("width");
+    let hidden = tag.on("hidden");
+    Some(Columns { first, last, width, hidden })
+}
+
+/// A `<dataValidation>`, its formulas still to come.
+fn validation(tag: Tag<'_>) -> Validation {
+    let text = |name| tag.attr(name).map(std::borrow::Cow::into_owned);
+    Validation {
+        range: text("sqref").unwrap_or_default(),
+        kind: text("type").unwrap_or_else(|| "none".to_owned()),
+        operator: text("operator"),
+        allow_blank: tag.on("allowBlank"),
+        // Inverted in the file format: showDropDown="1" hides the arrow.
+        dropdown: !tag.on("showDropDown"),
+        alert: tag
+            .on("showErrorMessage")
+            .then(|| text("errorStyle").unwrap_or_else(|| "stop".to_owned())),
+        error_title: text("errorTitle"),
+        error: text("error"),
+        prompt_title: text("promptTitle"),
+        prompt: text("prompt"),
+        ..Validation::default()
+    }
+}
+
+/// The formatted cells with their look; formats the workbook lacks are
+/// left out.
+fn styled(cells: &[(u32, u32, usize)], formats: &Formats) -> Vec<Styled> {
+    cells
+        .iter()
+        .filter_map(|&(row, column, format)| {
+            let look = Arc::clone(formats.looks.get(format)?);
+            Some(Styled { row, column, look })
+        })
+        .collect()
+}
+
 /// The sheet's comments.
 fn comments(text: &str, budget: &Budget<'_>) -> Result<Vec<Note>> {
     let mut xml = XmlReader::new(text, budget.max_depth());
@@ -286,8 +372,7 @@ fn comments(text: &str, budget: &Budget<'_>) -> Result<Vec<Note>> {
                 "author" => in_author = true,
                 "comment" => {
                     position = parse_cell_reference(&tag.attr("ref").unwrap_or_default()).ok();
-                    author_id =
-                        tag.attr("authorId").and_then(|id| id.parse().ok()).unwrap_or(usize::MAX);
+                    author_id = tag.parse("authorId").unwrap_or(usize::MAX);
                     body.clear();
                 }
                 "t" => in_text = true,

data/ext/imprimatur_native/core/src/read.rs

@@ -35,9 +35,13 @@ mod xlsx;
 pub(crate) use budget::Budget;
 pub use budget::Limits;
 pub use content::{
-    Block, Bounds, Cell, Content, Grid, Mark, Note, Page, Placed, Sheet, Text, Value,
+    Block, Bounds, Cell, Columns, Content, Grid, Look, Mark, Note, Page, Placed, Sheet, Styled,
+    Text, Validation, Value,
 };
+#[cfg(test)]
+pub(crate) use image::png;
 pub use image::{Image, ImageFormat, ImageLocation};
+pub(crate) use image::{PngColor, png_with_transparency};
 
 use crate::zip::reader::ZipReader;
 use crate::{Error, Result};

data/ext/imprimatur_native/core/src/script.rs

@@ -0,0 +1,116 @@
+//! Scripts and the direction they are written in, for reading text back
+//! in order and for writing it with the right direction.
+
+#[cfg(test)]
+mod tests;
+
+use crate::style::TextDirection;
+
+/// What a character is, for the direction of the text around it (its
+/// UAX #9 bidirectional class, simplified).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Class {
+    /// A letter of Hebrew or another right-to-left script but Arabic's, or
+    /// the right-to-left mark.
+    Right,
+    /// A letter of the Arabic script (Arabic, Persian, Urdu..., Syriac,
+    /// Thaana): right to left, and the digits after it are Arabic numbers.
+    Arabic,
+    /// Any other letter, or the left-to-right mark.
+    Left,
+    /// A number: its digits read left to right in any line, but in a
+    /// right-to-left run the spaces between two numbers read right to left.
+    Number,
+    /// Arabic-Indic digits (not the Persian ones), and digits after Arabic
+    /// letters: a number that only `,` `.` `:` `/` join, and no sign goes
+    /// with (UAX #9, W2).
+    ArabicNumber,
+    /// Spaces, punctuation and symbols: they take the direction around them.
+    Neutral,
+}
+
+impl Class {
+    pub const fn right_to_left(self) -> bool {
+        matches!(self, Self::Right | Self::Arabic)
+    }
+
+    pub const fn number(self) -> bool {
+        matches!(self, Self::Number | Self::ArabicNumber)
+    }
+
+    pub const fn strong(self) -> bool {
+        matches!(self, Self::Right | Self::Arabic | Self::Left)
+    }
+}
+
+/// The letters and digits of some text, by direction.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct Counts {
+    pub right: usize,
+    pub left: usize,
+    pub numbers: usize,
+}
+
+impl Counts {
+    pub fn add(&mut self, text: &str) {
+        for ch in text.chars() {
+            match class(ch) {
+                Class::Right | Class::Arabic => self.right += 1,
+                Class::Left if ch.is_alphabetic() => self.left += 1,
+                Class::Number | Class::ArabicNumber => self.numbers += 1,
+                Class::Left | Class::Neutral => {}
+            }
+        }
+    }
+
+    /// Whether more of the letters read right to left than left to right.
+    pub const fn right_to_left(self) -> bool {
+        self.right > self.left
+    }
+
+    /// The direction most of the letters read in; `None` without a letter.
+    pub const fn direction(self) -> Option<TextDirection> {
+        if self.right > self.left {
+            Some(TextDirection::RightToLeft)
+        } else if self.left > 0 {
+            Some(TextDirection::LeftToRight)
+        } else {
+            None
+        }
+    }
+}
+
+/// The direction of a character.
+///
+/// Right to left: Hebrew (and Yiddish, Ladino), Arabic (and Persian, Urdu,
+/// Pashto, Sindhi, Kurdish, Uyghur), Syriac, Thaana (Dhivehi), N'Ko,
+/// Samaritan, Mandaic, their presentation forms; Adlam (Fulani), Hanifi
+/// Rohingya, Mende Kikakui, Yezidi, Garay and the historic scripts
+/// (Phoenician, Aramaic, Sogdian...); and the right-to-left mark. Of
+/// those, the Arabic script (with Syriac, Thaana, Hanifi Rohingya and the
+/// Siyaq numbers) is set apart. Digits are numbers, the Persian ones
+/// (Extended Arabic-Indic) too; Arabic-Indic ones are Arabic numbers. The
+/// Arabic comma, percent sign and separators are neutral, like their Latin
+/// counterparts.
+pub fn class(ch: char) -> Class {
+    match ch {
+        '0'..='9' | '\u{06F0}'..='\u{06F9}' => Class::Number,
+        '\u{0660}'..='\u{0669}' => Class::ArabicNumber,
+        '\u{060C}' | '\u{066A}'..='\u{066C}' => Class::Neutral,
+        '\u{0600}'..='\u{07BF}'
+        | '\u{0860}'..='\u{08FF}'
+        | '\u{FB50}'..='\u{FDFF}'
+        | '\u{FE70}'..='\u{FEFC}'
+        | '\u{10D00}'..='\u{10D3F}'
+        | '\u{10EC0}'..='\u{10EFF}'
+        | '\u{1EC70}'..='\u{1EEFF}' => Class::Arabic,
+        '\u{0590}'..='\u{08FF}'
+        | '\u{200F}'
+        | '\u{FB1D}'..='\u{FB4F}'
+        | '\u{10800}'..='\u{10FFF}'
+        | '\u{1E800}'..='\u{1EFFF}' => Class::Right,
+        '\u{200E}' => Class::Left,
+        ch if ch.is_alphanumeric() => Class::Left,
+        _ => Class::Neutral,
+    }
+}

data/ext/imprimatur_native/core/src/style.rs

@@ -3,6 +3,7 @@
 #[cfg(test)]
 mod tests;
 
+use crate::script::{Class, class};
 use crate::{Error, Result};
 
 /// An opaque RGB color.
@@ -40,6 +41,17 @@ impl Color {
     pub(crate) fn argb(self) -> String {
         format!("FF{:06X}", self.0)
     }
+
+    /// `#RRGGBB`, as SVG takes it.
+    pub(crate) fn hex(self) -> String {
+        format!("#{:06X}", self.0)
+    }
+
+    /// Red, green and blue bytes.
+    pub(crate) const fn bytes(self) -> [u8; 3] {
+        let [_, r, g, b] = self.0.to_be_bytes();
+        [r, g, b]
+    }
 }
 
 /// Horizontal alignment within the cell.
@@ -72,6 +84,26 @@ pub enum TextDirection {
 }
 
 impl TextDirection {
+    /// The direction text takes on its own, the way Word and browsers settle
+    /// a paragraph left to automatic: that of its first letter (UAX #9, P2).
+    /// `None` when it has no letter: digits, punctuation, nothing.
+    ///
+    /// ```
+    /// use imprimatur::style::TextDirection;
+    ///
+    /// assert_eq!(TextDirection::of("2024 شهادة"), Some(TextDirection::RightToLeft));
+    /// assert_eq!(TextDirection::of("ISO 9001 אישור"), Some(TextDirection::LeftToRight));
+    /// assert_eq!(TextDirection::of("1,250.50"), None);
+    /// ```
+    #[must_use]
+    pub fn of(text: &str) -> Option<Self> {
+        text.chars().find_map(|ch| match class(ch) {
+            Class::Right | Class::Arabic => Some(Self::RightToLeft),
+            Class::Left => Some(Self::LeftToRight),
+            Class::Number | Class::ArabicNumber | Class::Neutral => None,
+        })
+    }
+
     /// `readingOrder`: 1 left to right, 2 right to left (0 is context).
     pub(crate) const fn reading_order(self) -> &'static str {
         match self {

data/ext/imprimatur_native/core/src/xlsx/autofit.rs

@@ -0,0 +1,60 @@
+//! Column widths from the cells. There is no font to measure text with, so
+//! a column is as wide as its widest cell's character count says, scaled by
+//! that cell's font.
+
+#[cfg(test)]
+mod tests;
+
+use std::collections::BTreeMap;
+
+use super::cell::Cell;
+use super::format::Font;
+use super::worksheet::Worksheet;
+
+/// Excel's widest column, in characters.
+const MAX_WIDTH: f64 = 255.0;
+
+/// The width each column without one of its own needs for its widest cell:
+/// `(characters + 3) × points / 10`, a bold cell counting one and a half
+/// times, at most 255. Formulas are left out: their results are unknown.
+pub fn widths(sheet: &Worksheet, base: &Font) -> BTreeMap<u16, f64> {
+    let mut widths = BTreeMap::new();
+    for (_, cells) in sheet.rows() {
+        for (&column, entry) in cells {
+            if sheet.column_widths().contains_key(&column) {
+                continue;
+            }
+            let Some(characters) = characters(&entry.cell) else {
+                continue;
+            };
+            let font = usize::try_from(entry.style)
+                .ok()
+                .and_then(|style| style.checked_sub(1))
+                .and_then(|index| sheet.formats().get(index))
+                .map_or(base, |format| &format.font);
+            let bold = if font.bold { 1.5 } else { 1.0 };
+            #[expect(
+                clippy::cast_precision_loss,
+                reason = "a cell holds at most 32 767 characters"
+            )]
+            let width = (characters as f64 + 3.0) * f64::from(font.half_points(base)) / 20.0 * bold;
+            let width = (width.min(MAX_WIDTH) * 100.0).round() / 100.0;
+            let widest = widths.entry(column).or_insert(0.0_f64);
+            *widest = widest.max(width);
+        }
+    }
+    widths
+}
+
+/// How many characters a cell shows unformatted: a text's longest line,
+/// a number's digits, `TRUE`, a date as `yyyy-mm-dd` and a time
+/// `yyyy-mm-dd hh:mm:ss`.
+fn characters(cell: &Cell) -> Option<usize> {
+    match cell {
+        Cell::Text(text) => text.split('\n').map(|line| line.chars().count()).max(),
+        Cell::Number(number) => Some(number.to_string().len()),
+        Cell::Bool(value) => Some(if *value { 4 } else { 5 }),
+        Cell::DateTime(date) => Some(if date.has_time() { 19 } else { 10 }),
+        Cell::Formula(_) => None,
+    }
+}

data/ext/imprimatur_native/core/src/xlsx/date.rs

@@ -90,6 +90,12 @@ impl DateTime {
         Self { hour: 0, minute: 0, second: 0, nanosecond: 0, ..self }
     }
 
+    /// Year, month and day.
+    #[must_use]
+    pub const fn year_month_day(&self) -> (u16, u8, u8) {
+        (self.year, self.month, self.day)
+    }
+
     /// Hours, minutes and seconds.
     #[must_use]
     pub const fn time_of_day(&self) -> (u8, u8, u8) {
@@ -147,7 +153,7 @@ const fn days_in_month(year: u16, month: u8) -> u8 {
 
 /// The calendar date `days` after 1970-01-01: the inverse of
 /// [`days_from_civil`] (Howard Hinnant's `civil_from_days`).
-const fn civil_from_days(days: i64) -> (i64, i64, i64) {
+pub const fn civil_from_days(days: i64) -> (i64, i64, i64) {
     let days = days + 719_468;
     let era = days.div_euclid(146_097);
     let day_of_era = days - era * 146_097;