CSV export: comma and semicolon types named after what the file holds

crates/engine/src/cmd/file.rs

@@ -11,9 +11,17 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!(noundo "file.open", "Open…", ["File"], Some("Cmd+O"), "{path} | {name, base64}, plus {password} for a password-protected workbook and {csvAsText?: bool} to keep every csv/tsv/txt field as text, with no number or date conversion (xlsx, xlsm, xls import, xlsb and ods data import, csv, tsv, txt, json)", always, open),
         cmd!(noundo "file.save", "Save", ["File"], Some("Cmd+S"), "{path?} (xlsx by default; .csv/.tsv/.json/.html/.pdf by extension)", has_doc, save),
         cmd!(noundo "file.saveAs", "Save As…", ["File"], Some("Cmd+Shift+S"), "{path} (.xlsx, .csv, .tsv, .json, .html, or .pdf: a PDF of the active sheet)", has_doc, save_as),
-        cmd!(query "file.saveBytes", "Encode Workbook", [], None, "{format?: xlsx|csv|tsv|json|html} → {base64}", has_doc, save_bytes),
+        cmd!(query "file.saveBytes", "Encode Workbook", [], None, "{format?: xlsx|csv|tsv|json|html, delimiter?, decimal?, bom? (csv, as file.exportCsv)} → {base64}", has_doc, save_bytes),
         cmd!(noundo "file.close", "Close", ["File"], Some("Cmd+W"), "{force?: bool, document?: bool} (closes the active window, or with `document` the workbook and all its windows; the workbook closes with its last window)", has_doc, close),
-        cmd!(noundo "file.exportCsv", "Export as CSV", ["File", "Export"], None, "{path, sheet?}", has_doc, |s, p| export(s, p, "csv")),
+        cmd!(
+            noundo "file.exportCsv",
+            "Export as CSV",
+            ["File", "Export"],
+            None,
+            "{path, sheet?, delimiter?: \",\" | \";\" (default: the delimiter the file was opened with, else \",\"), decimal?: \".\" | \",\" (decimal comma and period-grouped numbers), bom?: bool (UTF-8 byte order mark, which Excel needs to read accents)}",
+            has_doc,
+            |s, p| export(s, p, "csv")
+        ),
         cmd!(noundo "file.exportHtml", "Save as Web Page", ["File", "Export"], None, "{path}", has_doc, |s, p| export(s, p, "html")),
         cmd!("file.properties", "Properties", ["File"], None, "{title?, subject?, author?, company?, keywords?, description?}", has_doc, properties),
         cmd!(
@@ -158,10 +166,41 @@ fn save_bytes(s: &mut Session, p: &Json) -> Result<Json> {
     let d = s.doc()?;
     let name = format!("{}.{fmt}", std::path::Path::new(&d.display_title()).file_stem().and_then(|x| x.to_str()).unwrap_or("Book"));
     // The file name goes into a PivotChart's link to its PivotTable.
-    let bytes = crate::io::save_bytes(&d.wb, &name)?;
+    // The CSV options are read (and checked) only for CSV output.
+    let style = if fmt.eq_ignore_ascii_case("csv") { csv_style(p, &d.wb, "file.saveBytes")? } else { None };
+    let bytes = match style {
+        Some(style) => crate::io::csv_bytes(&d.wb, style)?,
+        None => crate::io::save_bytes(&d.wb, &name)?,
+    };
     Ok(json!({"name": name, "base64": crate::io::base64_encode(&bytes), "bytes": bytes.len()}))
 }
 
+/// The CSV style `delimiter`, `decimal` and `bom` ask for, or `None` when none is given (the export
+/// then writes as it always has).
+fn csv_style(p: &Json, wb: &gridcraft_model::Workbook, cmd: &str) -> Result<Option<crate::io::CsvStyle>> {
+    let given = |k: &str| p.get(k).filter(|v| !v.is_null());
+    if ["delimiter", "decimal", "bom"].iter().all(|k| given(k).is_none()) {
+        return Ok(None);
+    }
+    let delimiter = match given("delimiter").map(|v| v.as_str()) {
+        // Unasked, keep the separator the file was opened with (tab too), as plain CSV saves do.
+        None => wb.csv_delimiter.unwrap_or(b','),
+        Some(Some(",")) => b',',
+        Some(Some(";")) => b';',
+        Some(_) => return Err(bad(cmd, "`delimiter` is \",\" or \";\"")),
+    };
+    let decimal_comma = match given("decimal").map(|v| v.as_str()) {
+        None | Some(Some(".")) => false,
+        Some(Some(",")) => true,
+        Some(_) => return Err(bad(cmd, "`decimal` is \".\" or \",\"")),
+    };
+    let bom = match given("bom") {
+        None => false,
+        Some(v) => v.as_bool().ok_or_else(|| bad(cmd, "`bom` is true or false"))?,
+    };
+    Ok(Some(crate::io::CsvStyle { delimiter, decimal_comma, bom }))
+}
+
 /// File › Close closes the active window; the workbook closes with its last window.
 fn close(s: &mut Session, p: &Json) -> Result<Json> {
     if !bool_param(p, "document").unwrap_or(false)
@@ -191,7 +230,11 @@ fn export(s: &mut Session, p: &Json, ext: &str) -> Result<Json> {
         wb.set_active_sheet(target_sheet(s, p)?);
     }
     let target = if path.ends_with(&format!(".{ext}")) { path.clone() } else { format!("{path}.{ext}") };
-    let bytes = crate::io::save_bytes(&wb, &target)?;
+    let style = if ext == "csv" { csv_style(p, &wb, "file.exportCsv")? } else { None };
+    let bytes = match style {
+        Some(style) => crate::io::csv_bytes(&wb, style)?,
+        None => crate::io::save_bytes(&wb, &target)?,
+    };
     crate::io::write_file(&target, &bytes)?;
     Ok(json!({"path": target, "bytes": bytes.len()}))
 }

crates/engine/src/io.rs

@@ -248,8 +248,10 @@ pub fn save_bytes_as(wb: &Workbook, path: &str, kind: FileKind) -> Result<Vec<u8
         FileKind::Xlsb => Err(EngineError::Other("XLSB is supported for data import only. Save as .xlsx or another supported export format.".into())),
         FileKind::Ods => Err(EngineError::Other("ODS is supported for data import only. Save as .xlsx or another supported export format.".into())),
         // A workbook read from CSV keeps the separator it was read with (a `;` file stays `;`).
-        FileKind::Csv => wb.sheet(sheet).map(|sh| csv(wb, sh, wb.csv_delimiter.unwrap_or(b','))).transpose().map(Option::unwrap_or_default),
-        FileKind::Tsv => wb.sheet(sheet).map(|sh| csv(wb, sh, b'\t')).transpose().map(Option::unwrap_or_default),
+        FileKind::Csv => {
+            wb.sheet(sheet).map(|sh| csv(wb, sh, CsvStyle::plain(wb.csv_delimiter.unwrap_or(b',')))).transpose().map(Option::unwrap_or_default)
+        }
+        FileKind::Tsv => wb.sheet(sheet).map(|sh| csv(wb, sh, CsvStyle::plain(b'\t'))).transpose().map(Option::unwrap_or_default),
         FileKind::Json => serde_json::to_vec_pretty(wb).map_err(|e| EngineError::Other(e.to_string())),
         FileKind::Html => to_html(wb, sheet).map(String::into_bytes),
     }
@@ -275,23 +277,75 @@ pub fn source_path(path: &str) -> Option<std::path::PathBuf> {
     std::path::absolute(path).ok()
 }
 
+/// How a CSV export is written.
+///
+/// The names say what the file holds. Excel's do not: with the Windows list separator set to `;`
+/// (Italian, German, French… regions), Excel's «CSV UTF-8 (Comma delimited)» writes semicolons
+/// and decimal commas, and its «CSV (Comma delimited)» writes the same in ANSI (observed in Excel
+/// 365 with the Italian interface, 2026-10). GridCraft's comma CSV holds commas, and the
+/// semicolon CSV is a separate, explicit choice.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct CsvStyle {
+    /// Field delimiter (`,` or `;`).
+    pub delimiter: u8,
+    /// Numbers are written with a decimal comma and a period between digit groups (`1.234,5`),
+    /// as regions that use `;` as list separator read them. Dates and times are left as shown.
+    pub decimal_comma: bool,
+    /// A UTF-8 byte order mark first, which Excel needs to read the file as UTF-8 (without it,
+    /// accented letters come out garbled in Excel on Windows).
+    pub bom: bool,
+}
+
+impl CsvStyle {
+    pub const fn plain(delimiter: u8) -> CsvStyle {
+        CsvStyle { delimiter, decimal_comma: false, bom: false }
+    }
+}
+
+/// The active sheet of `wb` as CSV in `style`.
+pub fn csv_bytes(wb: &Workbook, style: CsvStyle) -> Result<Vec<u8>> {
+    match wb.sheet(wb.active_sheet()) {
+        Some(sh) => csv(wb, sh, style),
+        None => Ok(Vec::new()),
+    }
+}
+
 /// Save As CSV/Text writes "the text and values as they are displayed in cells" with "all
 /// characters in each cell" (Microsoft Support, *Excel formatting and features that are not
 /// transferred to other file formats*): number formats applied, never column-width `#####`.
-fn csv(wb: &Workbook, sh: &Sheet, delimiter: u8) -> Result<Vec<u8>> {
-    gridcraft_xlsx::write_csv(sh, delimiter, |c| {
+fn csv(wb: &Workbook, sh: &Sheet, style: CsvStyle) -> Result<Vec<u8>> {
+    let mut body = gridcraft_xlsx::write_csv(sh, style.delimiter, |c| {
+        let value = sh.value(c);
+        let code = wb.styles.get(sh.style_id(c)).num_fmt.as_str();
         // General's grid-width formatting rounds large identifiers to scientific notation.
         // Delimited files have no column width, so preserve the whole numeric value instead.
-        if wb.styles.get(sh.style_id(c)).num_fmt.as_str().eq_ignore_ascii_case("General")
-            && let gridcraft_core::Value::Number(number) = sh.value(c)
+        let text = if code.eq_ignore_ascii_case("General")
+            && let gridcraft_core::Value::Number(number) = value
             && number.is_finite()
         {
             number.to_string()
         } else {
             crate::display::value_text(wb, sh, c)
+        };
+        if style.decimal_comma && value.is_number() && !crate::display::number_format(code).is_date() {
+            // `1,234.5` becomes `1.234,5`: the decimal point and the group separator swap.
+            text.chars()
+                .map(|ch| match ch {
+                    '.' => ',',
+                    ',' => '.',
+                    other => other,
+                })
+                .collect()
+        } else {
+            text
         }
     })
-    .map_err(|e| EngineError::Other(e.to_string()))
+    .map_err(|e| EngineError::Other(e.to_string()))?;
+    if style.bom {
+        // In place: a body near the size cap is not copied into a second buffer.
+        body.splice(0..0, *b"\xEF\xBB\xBF");
+    }
+    Ok(body)
 }
 
 pub(crate) fn esc(s: &str) -> String {

crates/engine/src/tests.rs

@@ -2460,6 +2460,71 @@ fn saving_an_opened_semicolon_csv_keeps_semicolons() {
     std::fs::remove_dir_all(dir).unwrap();
 }
 
+#[test]
+fn csv_export_with_semicolons_decimal_commas_and_a_byte_order_mark() {
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["città", 1.5, 1234.5, "2026-03-15", "a;b"]]})).unwrap();
+    s.execute("home.numberFormat", json!({"range": "C1", "code": "#,##0.00"})).unwrap();
+    s.execute("home.numberFormat", json!({"range": "D1", "code": "dd.mm.yyyy"})).unwrap();
+    let bytes = |s: &mut crate::Session, p: serde_json::Value| {
+        let r = s.execute("file.saveBytes", p).unwrap();
+        crate::io::base64_decode(r["base64"].as_str().unwrap()).unwrap()
+    };
+    // Without the new parameters nothing changes: commas, a decimal point, no byte order mark.
+    let plain = bytes(&mut s, json!({"format": "csv"}));
+    assert_eq!(String::from_utf8(plain).unwrap(), "città,1.5,\"1,234.50\",15.03.2026,a;b\r\n");
+    let comma = bytes(&mut s, json!({"format": "csv", "delimiter": ",", "decimal": ".", "bom": true}));
+    assert_eq!(comma, "\u{feff}città,1.5,\"1,234.50\",15.03.2026,a;b\r\n".as_bytes());
+    // Semicolons and decimal commas: numbers swap their marks, the dotted date stays a date.
+    let semi = bytes(&mut s, json!({"format": "csv", "delimiter": ";", "decimal": ",", "bom": true}));
+    assert_eq!(semi, "\u{feff}città;1,5;1.234,50;15.03.2026;\"a;b\"\r\n".as_bytes());
+    // The file reads back as the same values.
+    let (wb, _) = crate::io::open_bytes("back.csv", &semi).unwrap();
+    assert_eq!(wb.active().unwrap().value(CellRef::new(0, 0)), Value::text("città"));
+    assert_eq!(wb.csv_delimiter, Some(b';'));
+    assert_eq!(wb.active().unwrap().value(CellRef::new(0, 1)), Value::Number(1.5));
+    assert_eq!(wb.active().unwrap().value(CellRef::new(0, 2)), Value::Number(1234.5));
+    // A sheet of numbers only: the decimal commas outnumber the semicolons, and the columns stay.
+    let mut n = crate::Session::new();
+    n.new_workbook();
+    n.execute("range.setValues", json!({"range": "A1", "values": [[1.5, 2.25, 3.125], [4.1, 5.2, 6.3]]})).unwrap();
+    let nums = bytes(&mut n, json!({"format": "csv", "delimiter": ";", "decimal": ","}));
+    assert_eq!(String::from_utf8(nums.clone()).unwrap(), "1,5;2,25;3,125\r\n4,1;5,2;6,3\r\n");
+    let (wb, _) = crate::io::open_bytes("nums.csv", &nums).unwrap();
+    assert_eq!(wb.active().unwrap().value(CellRef::new(1, 2)), Value::Number(6.3));
+    // A file opened with tabs keeps them when only the byte order mark is asked for.
+    std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).csv_delimiter = Some(b'\t');
+    let tabs = bytes(&mut s, json!({"format": "csv", "bom": true}));
+    assert!(tabs.starts_with("\u{feff}città\t1.5\t".as_bytes()));
+    for bad in [json!({"format": "csv", "delimiter": "|"}), json!({"format": "csv", "decimal": ";"}), json!({"format": "csv", "bom": "yes"})] {
+        assert!(s.execute("file.saveBytes", bad.clone()).is_err(), "{bad}");
+    }
+}
+
+#[test]
+fn csv_options_apply_to_csv_only_and_an_empty_csv_keeps_its_byte_order_mark() {
+    let mut s = s();
+    let r = s.execute("file.saveBytes", json!({"format": "csv", "bom": true})).unwrap();
+    assert_eq!(crate::io::base64_decode(r["base64"].as_str().unwrap()).unwrap(), b"\xEF\xBB\xBF");
+    // CSV-only options are ignored, not rejected, by the other formats.
+    assert!(s.execute("file.saveBytes", json!({"format": "json", "delimiter": "|"})).is_ok());
+}
+
+#[test]
+#[cfg(not(target_arch = "wasm32"))]
+fn export_csv_writes_the_style_asked_for() {
+    #[allow(clippy::disallowed_methods)] // native-only test: a unique temp dir name
+    let nonce = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+    let dir = std::env::temp_dir().join(format!("gridcraft-csv-style-{}-{nonce}", std::process::id()));
+    std::fs::create_dir(&dir).unwrap();
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["x", 2.25]]})).unwrap();
+    let path = dir.join("semi.csv");
+    s.execute("file.exportCsv", json!({"path": path, "delimiter": ";", "decimal": ","})).unwrap();
+    assert_eq!(std::fs::read_to_string(&path).unwrap(), "x;2,25\r\n");
+    std::fs::remove_dir_all(dir).unwrap();
+}
+
 /// A workbook whose B1 is `=[1]Sheet1!A1`, linked to `link` (an external relationship target).
 fn linked_workbook(link: &str) -> Vec<u8> {
     use std::io::{Cursor, Write};

crates/ui-egui/src/backstage.rs

@@ -128,10 +128,34 @@ pub struct Backstage {
     recent: RecentFiles,
 }
 
-/// Save As file types: (extension, label). The first is the workbook itself; the others are
-/// exports that leave the workbook's own file and unsaved state alone.
-pub const SAVE_TYPES: [(&str, &str); 4] =
-    [("xlsx", "Excel Workbook (*.xlsx)"), ("csv", "CSV UTF-8 (Comma delimited) (*.csv)"), ("html", "Web Page (*.html)"), ("pdf", "PDF (*.pdf)")];
+/// Save As file types: (type, label). The first is the workbook itself; the others are exports
+/// that leave the workbook's own file and unsaved state alone. A type is a file extension, or
+/// `csv-semicolon` (a `.csv` file), see [`csv_params`].
+pub const SAVE_TYPES: [(&str, &str); 5] = [
+    ("xlsx", "Excel Workbook (*.xlsx)"),
+    ("csv", "CSV UTF-8 (Comma delimited) (*.csv)"),
+    ("csv-semicolon", "CSV UTF-8 (Semicolon delimited) (*.csv)"),
+    ("html", "Web Page (*.html)"),
+    ("pdf", "PDF (*.pdf)"),
+];
+
+/// The file extension a Save As type writes.
+fn type_ext(fmt: &str) -> &str {
+    if fmt == "csv-semicolon" { "csv" } else { fmt }
+}
+
+/// `file.exportCsv` / `file.saveBytes` parameters for a CSV type. The names say what the file
+/// holds, unlike Excel's: in regions whose list separator is `;` Excel's «CSV UTF-8 (Comma
+/// delimited)» writes semicolons. Here the comma CSV holds commas (even for a workbook opened
+/// from a `;` file) and the semicolon CSV is its own type, with decimal commas (`1.234,5`). Both
+/// start with a UTF-8 byte order mark, which Excel needs to read accented letters.
+fn csv_params(fmt: &str) -> Json {
+    if fmt == "csv-semicolon" {
+        json!({"delimiter": ";", "decimal": ",", "bom": true})
+    } else {
+        json!({"delimiter": ",", "decimal": ".", "bom": true})
+    }
+}
 
 impl Backstage {
     pub fn new(page: Page) -> Backstage {
@@ -693,7 +717,7 @@ fn save_as(app: &mut SheetApp, ui: &mut Ui, bs: &mut Backstage, out: &mut Outcom
     ui.add_space(14.0);
     // Desktop: the system Save dialog. Web: the file downloads.
     let web = app.services.pick_save.is_none() && app.services.download.is_some();
-    let label = if web { format!("{} (.{fmt})", lang.tr("Download")) } else { lang.tr("Browse…").to_string() };
+    let label = if web { format!("{} (.{})", lang.tr("Download"), type_ext(fmt)) } else { lang.tr("Browse…").to_string() };
     if square_button(ui, Icon::OpenFolder, &label).clicked() && app.commit_edit(0, 0, false, false) {
         if fmt == "xlsx" {
             let before = app.session.active().map(|d| (d.path.clone(), d.is_dirty()));
@@ -721,6 +745,12 @@ fn export(app: &mut SheetApp, ui: &mut Ui, out: &mut Outcome) {
     section(ui, lang, "Change File Type");
     for (fmt, icon, title, detail) in [
         ("csv", Icon::TextColumns, "CSV (Comma delimited)", "Save the active sheet as comma-separated text."),
+        (
+            "csv-semicolon",
+            Icon::TextColumns,
+            "CSV (Semicolon delimited)",
+            "Save the active sheet as semicolon-separated text with decimal commas (1.234,5), as Excel reads it where the list separator is ;.",
+        ),
         ("html", Icon::Link, "Web Page (.html)", "Save the workbook as a web page."),
     ] {
         if action_row(ui, icon, lang.tr(title), lang.tr(detail)).clicked() && export_as(app, fmt) {
@@ -737,17 +767,26 @@ pub fn export_as(app: &mut SheetApp, fmt: &str) -> bool {
     }
     let id = match fmt {
         "pdf" => "file.exportPdf",
-        "csv" => "file.exportCsv",
+        "csv" | "csv-semicolon" => "file.exportCsv",
         "html" => "file.exportHtml",
         _ => return false,
     };
+    let ext = type_ext(fmt);
+    let with_csv = |mut p: Json| {
+        if id == "file.exportCsv"
+            && let (Some(p), Json::Object(extra)) = (p.as_object_mut(), csv_params(fmt))
+        {
+            p.extend(extra);
+        }
+        p
+    };
     let title = app.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
     let stem = std::path::Path::new(&title).file_stem().and_then(std::ffi::OsStr::to_str).unwrap_or("Book1").to_string();
     if let Some(pick) = &app.services.pick_save {
-        let Some(path) = pick(&format!("{stem}.{fmt}")) else { return false };
+        let Some(path) = pick(&format!("{stem}.{ext}")) else { return false };
         // The picker may suggest a workbook extension; the export writes the chosen format.
-        let path = std::path::Path::new(&path).with_extension(fmt).to_string_lossy().into_owned();
-        return match app.run(id, json!({"path": path})) {
+        let path = std::path::Path::new(&path).with_extension(ext).to_string_lossy().into_owned();
+        return match app.run(id, with_csv(json!({"path": path}))) {
             Ok(_) => true,
             Err(e) => {
                 app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
@@ -770,10 +809,10 @@ pub fn export_as(app: &mut SheetApp, fmt: &str) -> bool {
         };
     }
     app.store_view_state();
-    match app.session.run("file.saveBytes", json!({"format": fmt})) {
+    match app.session.run("file.saveBytes", with_csv(json!({"format": ext}))) {
         Ok(r) => {
             let bytes = r.get("base64").and_then(Json::as_str).and_then(gridcraft_engine::io::base64_decode);
-            let name = r.get("name").and_then(Json::as_str).map_or_else(|| format!("{stem}.{fmt}"), str::to_string);
+            let name = r.get("name").and_then(Json::as_str).map_or_else(|| format!("{stem}.{ext}"), str::to_string);
             match (bytes, &app.services.download) {
                 (Some(b), Some(dl)) => {
                     dl(&name, &b);