Skip to main content

sheetkit_xml/
worksheet.rs

1//! Worksheet XML schema structures.
2//!
3//! Represents `xl/worksheets/sheet*.xml` in the OOXML package.
4
5use std::fmt;
6
7use serde::de::Deserializer;
8use serde::ser::Serializer;
9use serde::{Deserialize, Serialize};
10
11pub use crate::cell_ref::CompactCellRef;
12use crate::namespaces;
13
14/// Worksheet root element.
15#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
16#[serde(rename = "worksheet")]
17pub struct WorksheetXml {
18    #[serde(rename = "@xmlns", default = "crate::default_spreadsheet_ml_ns")]
19    pub xmlns: String,
20
21    #[serde(rename = "@xmlns:r", default = "crate::default_relationships_ns")]
22    pub xmlns_r: String,
23
24    #[serde(rename = "sheetPr", skip_serializing_if = "Option::is_none")]
25    pub sheet_pr: Option<SheetPr>,
26
27    #[serde(rename = "dimension", skip_serializing_if = "Option::is_none")]
28    pub dimension: Option<Dimension>,
29
30    #[serde(rename = "sheetViews", skip_serializing_if = "Option::is_none")]
31    pub sheet_views: Option<SheetViews>,
32
33    #[serde(rename = "sheetFormatPr", skip_serializing_if = "Option::is_none")]
34    pub sheet_format_pr: Option<SheetFormatPr>,
35
36    #[serde(rename = "cols", skip_serializing_if = "Option::is_none")]
37    pub cols: Option<Cols>,
38
39    #[serde(rename = "sheetData")]
40    pub sheet_data: SheetData,
41
42    #[serde(rename = "sheetProtection", skip_serializing_if = "Option::is_none")]
43    pub sheet_protection: Option<SheetProtection>,
44
45    #[serde(rename = "autoFilter", skip_serializing_if = "Option::is_none")]
46    pub auto_filter: Option<AutoFilter>,
47
48    #[serde(rename = "mergeCells", skip_serializing_if = "Option::is_none")]
49    pub merge_cells: Option<MergeCells>,
50
51    #[serde(
52        rename = "conditionalFormatting",
53        default,
54        skip_serializing_if = "Vec::is_empty"
55    )]
56    pub conditional_formatting: Vec<ConditionalFormatting>,
57
58    #[serde(rename = "dataValidations", skip_serializing_if = "Option::is_none")]
59    pub data_validations: Option<DataValidations>,
60
61    #[serde(rename = "hyperlinks", skip_serializing_if = "Option::is_none")]
62    pub hyperlinks: Option<Hyperlinks>,
63
64    #[serde(rename = "printOptions", skip_serializing_if = "Option::is_none")]
65    pub print_options: Option<PrintOptions>,
66
67    #[serde(rename = "pageMargins", skip_serializing_if = "Option::is_none")]
68    pub page_margins: Option<PageMargins>,
69
70    #[serde(rename = "pageSetup", skip_serializing_if = "Option::is_none")]
71    pub page_setup: Option<PageSetup>,
72
73    #[serde(rename = "headerFooter", skip_serializing_if = "Option::is_none")]
74    pub header_footer: Option<HeaderFooter>,
75
76    #[serde(rename = "rowBreaks", skip_serializing_if = "Option::is_none")]
77    pub row_breaks: Option<RowBreaks>,
78
79    #[serde(rename = "colBreaks", skip_serializing_if = "Option::is_none")]
80    pub col_breaks: Option<RowBreaks>,
81
82    #[serde(rename = "drawing", skip_serializing_if = "Option::is_none")]
83    pub drawing: Option<DrawingRef>,
84
85    #[serde(rename = "legacyDrawing", skip_serializing_if = "Option::is_none")]
86    pub legacy_drawing: Option<LegacyDrawingRef>,
87
88    #[serde(rename = "controls", skip_serializing_if = "Option::is_none")]
89    pub controls: Option<crate::control::Controls>,
90
91    #[serde(rename = "tableParts", skip_serializing_if = "Option::is_none")]
92    pub table_parts: Option<TableParts>,
93}
94
95/// Sheet dimension reference.
96#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
97pub struct Dimension {
98    #[serde(rename = "@ref")]
99    pub reference: String,
100}
101
102/// Sheet views container.
103#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
104pub struct SheetViews {
105    #[serde(rename = "sheetView")]
106    pub sheet_views: Vec<SheetView>,
107}
108
109/// Individual sheet view.
110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
111pub struct SheetView {
112    #[serde(rename = "@tabSelected", skip_serializing_if = "Option::is_none")]
113    pub tab_selected: Option<bool>,
114
115    #[serde(rename = "@showGridLines", skip_serializing_if = "Option::is_none")]
116    pub show_grid_lines: Option<bool>,
117
118    #[serde(rename = "@showFormulas", skip_serializing_if = "Option::is_none")]
119    pub show_formulas: Option<bool>,
120
121    #[serde(rename = "@showRowColHeaders", skip_serializing_if = "Option::is_none")]
122    pub show_row_col_headers: Option<bool>,
123
124    #[serde(rename = "@zoomScale", skip_serializing_if = "Option::is_none")]
125    pub zoom_scale: Option<u32>,
126
127    #[serde(rename = "@view", skip_serializing_if = "Option::is_none")]
128    pub view: Option<String>,
129
130    #[serde(rename = "@topLeftCell", skip_serializing_if = "Option::is_none")]
131    pub top_left_cell: Option<String>,
132
133    #[serde(rename = "@workbookViewId")]
134    pub workbook_view_id: u32,
135
136    #[serde(rename = "pane", skip_serializing_if = "Option::is_none")]
137    pub pane: Option<Pane>,
138
139    #[serde(rename = "selection", default)]
140    pub selection: Vec<Selection>,
141}
142
143/// Pane definition for split or frozen panes.
144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
145pub struct Pane {
146    #[serde(rename = "@xSplit", skip_serializing_if = "Option::is_none")]
147    pub x_split: Option<u32>,
148
149    #[serde(rename = "@ySplit", skip_serializing_if = "Option::is_none")]
150    pub y_split: Option<u32>,
151
152    #[serde(rename = "@topLeftCell", skip_serializing_if = "Option::is_none")]
153    pub top_left_cell: Option<String>,
154
155    #[serde(rename = "@activePane", skip_serializing_if = "Option::is_none")]
156    pub active_pane: Option<String>,
157
158    #[serde(rename = "@state", skip_serializing_if = "Option::is_none")]
159    pub state: Option<String>,
160}
161
162/// Cell selection.
163#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
164pub struct Selection {
165    #[serde(rename = "@pane", skip_serializing_if = "Option::is_none")]
166    pub pane: Option<String>,
167
168    #[serde(rename = "@activeCell", skip_serializing_if = "Option::is_none")]
169    pub active_cell: Option<String>,
170
171    #[serde(rename = "@sqref", skip_serializing_if = "Option::is_none")]
172    pub sqref: Option<String>,
173}
174
175/// Sheet properties.
176#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
177pub struct SheetPr {
178    #[serde(rename = "@codeName", skip_serializing_if = "Option::is_none")]
179    pub code_name: Option<String>,
180
181    #[serde(rename = "@filterMode", skip_serializing_if = "Option::is_none")]
182    pub filter_mode: Option<bool>,
183
184    #[serde(rename = "tabColor", skip_serializing_if = "Option::is_none")]
185    pub tab_color: Option<TabColor>,
186
187    #[serde(rename = "outlinePr", skip_serializing_if = "Option::is_none")]
188    pub outline_pr: Option<OutlinePr>,
189}
190
191/// Tab color specification.
192#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
193pub struct TabColor {
194    #[serde(rename = "@rgb", skip_serializing_if = "Option::is_none")]
195    pub rgb: Option<String>,
196
197    #[serde(rename = "@theme", skip_serializing_if = "Option::is_none")]
198    pub theme: Option<u32>,
199
200    #[serde(rename = "@indexed", skip_serializing_if = "Option::is_none")]
201    pub indexed: Option<u32>,
202}
203
204/// Outline properties for grouping.
205#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
206pub struct OutlinePr {
207    #[serde(rename = "@summaryBelow", skip_serializing_if = "Option::is_none")]
208    pub summary_below: Option<bool>,
209
210    #[serde(rename = "@summaryRight", skip_serializing_if = "Option::is_none")]
211    pub summary_right: Option<bool>,
212}
213
214/// Sheet format properties.
215#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
216pub struct SheetFormatPr {
217    #[serde(rename = "@defaultRowHeight")]
218    pub default_row_height: f64,
219
220    #[serde(rename = "@defaultColWidth", skip_serializing_if = "Option::is_none")]
221    pub default_col_width: Option<f64>,
222
223    #[serde(rename = "@customHeight", skip_serializing_if = "Option::is_none")]
224    pub custom_height: Option<bool>,
225
226    #[serde(rename = "@outlineLevelRow", skip_serializing_if = "Option::is_none")]
227    pub outline_level_row: Option<u8>,
228
229    #[serde(rename = "@outlineLevelCol", skip_serializing_if = "Option::is_none")]
230    pub outline_level_col: Option<u8>,
231}
232
233/// Sheet protection settings.
234#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
235pub struct SheetProtection {
236    #[serde(rename = "@password", skip_serializing_if = "Option::is_none")]
237    pub password: Option<String>,
238
239    #[serde(rename = "@sheet", skip_serializing_if = "Option::is_none")]
240    pub sheet: Option<bool>,
241
242    #[serde(rename = "@objects", skip_serializing_if = "Option::is_none")]
243    pub objects: Option<bool>,
244
245    #[serde(rename = "@scenarios", skip_serializing_if = "Option::is_none")]
246    pub scenarios: Option<bool>,
247
248    #[serde(rename = "@selectLockedCells", skip_serializing_if = "Option::is_none")]
249    pub select_locked_cells: Option<bool>,
250
251    #[serde(
252        rename = "@selectUnlockedCells",
253        skip_serializing_if = "Option::is_none"
254    )]
255    pub select_unlocked_cells: Option<bool>,
256
257    #[serde(rename = "@formatCells", skip_serializing_if = "Option::is_none")]
258    pub format_cells: Option<bool>,
259
260    #[serde(rename = "@formatColumns", skip_serializing_if = "Option::is_none")]
261    pub format_columns: Option<bool>,
262
263    #[serde(rename = "@formatRows", skip_serializing_if = "Option::is_none")]
264    pub format_rows: Option<bool>,
265
266    #[serde(rename = "@insertColumns", skip_serializing_if = "Option::is_none")]
267    pub insert_columns: Option<bool>,
268
269    #[serde(rename = "@insertRows", skip_serializing_if = "Option::is_none")]
270    pub insert_rows: Option<bool>,
271
272    #[serde(rename = "@insertHyperlinks", skip_serializing_if = "Option::is_none")]
273    pub insert_hyperlinks: Option<bool>,
274
275    #[serde(rename = "@deleteColumns", skip_serializing_if = "Option::is_none")]
276    pub delete_columns: Option<bool>,
277
278    #[serde(rename = "@deleteRows", skip_serializing_if = "Option::is_none")]
279    pub delete_rows: Option<bool>,
280
281    #[serde(rename = "@sort", skip_serializing_if = "Option::is_none")]
282    pub sort: Option<bool>,
283
284    #[serde(rename = "@autoFilter", skip_serializing_if = "Option::is_none")]
285    pub auto_filter: Option<bool>,
286
287    #[serde(rename = "@pivotTables", skip_serializing_if = "Option::is_none")]
288    pub pivot_tables: Option<bool>,
289}
290
291/// Columns container.
292#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
293pub struct Cols {
294    #[serde(rename = "col")]
295    pub cols: Vec<Col>,
296}
297
298/// Individual column definition.
299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
300pub struct Col {
301    #[serde(rename = "@min")]
302    pub min: u32,
303
304    #[serde(rename = "@max")]
305    pub max: u32,
306
307    #[serde(rename = "@width", skip_serializing_if = "Option::is_none")]
308    pub width: Option<f64>,
309
310    #[serde(rename = "@style", skip_serializing_if = "Option::is_none")]
311    pub style: Option<u32>,
312
313    #[serde(rename = "@hidden", skip_serializing_if = "Option::is_none")]
314    pub hidden: Option<bool>,
315
316    #[serde(rename = "@customWidth", skip_serializing_if = "Option::is_none")]
317    pub custom_width: Option<bool>,
318
319    #[serde(rename = "@outlineLevel", skip_serializing_if = "Option::is_none")]
320    pub outline_level: Option<u8>,
321}
322
323/// Sheet data container holding all rows.
324#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
325pub struct SheetData {
326    #[serde(rename = "row", default)]
327    pub rows: Vec<Row>,
328}
329
330/// A single row of cells.
331#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
332pub struct Row {
333    /// 1-based row number.
334    #[serde(rename = "@r")]
335    pub r: u32,
336
337    #[serde(skip)]
338    pub spans: Option<String>,
339
340    #[serde(rename = "@s", skip_serializing_if = "Option::is_none")]
341    pub s: Option<u32>,
342
343    #[serde(rename = "@customFormat", skip_serializing_if = "Option::is_none")]
344    pub custom_format: Option<bool>,
345
346    #[serde(rename = "@ht", skip_serializing_if = "Option::is_none")]
347    pub ht: Option<f64>,
348
349    #[serde(rename = "@hidden", skip_serializing_if = "Option::is_none")]
350    pub hidden: Option<bool>,
351
352    #[serde(rename = "@customHeight", skip_serializing_if = "Option::is_none")]
353    pub custom_height: Option<bool>,
354
355    #[serde(rename = "@outlineLevel", skip_serializing_if = "Option::is_none")]
356    pub outline_level: Option<u8>,
357
358    #[serde(rename = "c", default)]
359    pub cells: Vec<Cell>,
360}
361
362/// A single cell.
363#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
364pub struct Cell {
365    /// Cell reference (e.g., "A1").
366    #[serde(rename = "@r")]
367    pub r: CompactCellRef,
368
369    /// Cached 1-based column number parsed from `r`. Populated at load time
370    /// or at creation time to avoid repeated string parsing.
371    #[serde(skip)]
372    pub col: u32,
373
374    /// Style index.
375    #[serde(rename = "@s", skip_serializing_if = "Option::is_none")]
376    pub s: Option<u32>,
377
378    /// Cell data type.
379    #[serde(rename = "@t", default, skip_serializing_if = "CellTypeTag::is_none")]
380    pub t: CellTypeTag,
381
382    /// Cell formula. Declared before the value because CT_Cell is the
383    /// sequence (f, v, is) and serde serializes in field order.
384    #[serde(rename = "f", skip_serializing_if = "Option::is_none")]
385    pub f: Option<Box<CellFormula>>,
386
387    /// Cached cell value.
388    #[serde(rename = "v", skip_serializing_if = "Option::is_none")]
389    pub v: Option<String>,
390
391    /// Inline string.
392    #[serde(rename = "is", skip_serializing_if = "Option::is_none")]
393    pub is: Option<Box<InlineString>>,
394}
395
396/// Cell data type tag, replacing `Option<String>` for zero-allocation matching.
397#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
398pub enum CellTypeTag {
399    /// No type attribute (typically means Number).
400    #[default]
401    None,
402    /// Shared string ("s").
403    SharedString,
404    /// Explicit number ("n").
405    Number,
406    /// Boolean ("b").
407    Boolean,
408    /// Error ("e").
409    Error,
410    /// Inline string ("inlineStr").
411    InlineString,
412    /// Formula string result ("str").
413    FormulaString,
414    /// Date ("d").
415    Date,
416}
417
418impl CellTypeTag {
419    /// Returns `true` when the tag is `None`, used for `skip_serializing_if`.
420    pub fn is_none(&self) -> bool {
421        matches!(self, CellTypeTag::None)
422    }
423
424    /// Returns the XML string representation, or `None` for the default variant.
425    pub fn as_str(&self) -> Option<&'static str> {
426        match self {
427            CellTypeTag::None => Option::None,
428            CellTypeTag::SharedString => Some("s"),
429            CellTypeTag::Number => Some("n"),
430            CellTypeTag::Boolean => Some("b"),
431            CellTypeTag::Error => Some("e"),
432            CellTypeTag::InlineString => Some("inlineStr"),
433            CellTypeTag::FormulaString => Some("str"),
434            CellTypeTag::Date => Some("d"),
435        }
436    }
437}
438
439impl Serialize for CellTypeTag {
440    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
441        match self.as_str() {
442            Some(s) => serializer.serialize_str(s),
443            Option::None => serializer.serialize_none(),
444        }
445    }
446}
447
448impl<'de> Deserialize<'de> for CellTypeTag {
449    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
450        struct CellTypeTagVisitor;
451
452        impl serde::de::Visitor<'_> for CellTypeTagVisitor {
453            type Value = CellTypeTag;
454
455            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
456                formatter.write_str("a cell type string (e.g. \"s\", \"n\", \"b\")")
457            }
458
459            fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<CellTypeTag, E> {
460                Ok(match v {
461                    "s" => CellTypeTag::SharedString,
462                    "n" => CellTypeTag::Number,
463                    "b" => CellTypeTag::Boolean,
464                    "e" => CellTypeTag::Error,
465                    "inlineStr" => CellTypeTag::InlineString,
466                    "str" => CellTypeTag::FormulaString,
467                    "d" => CellTypeTag::Date,
468                    _ => CellTypeTag::None,
469                })
470            }
471
472            fn visit_string<E: serde::de::Error>(self, v: String) -> Result<CellTypeTag, E> {
473                self.visit_str(&v)
474            }
475        }
476
477        deserializer.deserialize_str(CellTypeTagVisitor)
478    }
479}
480
481/// Cell formula.
482#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
483pub struct CellFormula {
484    #[serde(rename = "@t", skip_serializing_if = "Option::is_none")]
485    pub t: Option<String>,
486
487    #[serde(rename = "@ref", skip_serializing_if = "Option::is_none")]
488    pub reference: Option<String>,
489
490    #[serde(rename = "@si", skip_serializing_if = "Option::is_none")]
491    pub si: Option<u32>,
492
493    #[serde(rename = "$value", skip_serializing_if = "Option::is_none")]
494    pub value: Option<String>,
495}
496
497/// Inline string within a cell.
498#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
499pub struct InlineString {
500    #[serde(rename = "t", skip_serializing_if = "Option::is_none")]
501    pub t: Option<String>,
502
503    /// Rich text runs. Their formatting is preserved in XML but callers can
504    /// concatenate the nested text for the visible cell value.
505    #[serde(rename = "r", default)]
506    pub r: Vec<crate::shared_strings::R>,
507
508    /// Phonetic annotations associated with inline text.
509    #[serde(rename = "rPh", default)]
510    pub r_ph: Vec<PhoneticRun>,
511}
512
513/// A phonetic annotation (`rPh`) attached to inline rich text.
514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
515pub struct PhoneticRun {
516    #[serde(rename = "@sb", skip_serializing_if = "Option::is_none")]
517    pub sb: Option<u32>,
518
519    #[serde(rename = "@eb", skip_serializing_if = "Option::is_none")]
520    pub eb: Option<u32>,
521
522    #[serde(rename = "$value", default)]
523    pub value: String,
524}
525
526/// Auto filter.
527#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
528pub struct AutoFilter {
529    #[serde(rename = "@ref")]
530    pub reference: String,
531}
532
533/// Data validations container.
534#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
535pub struct DataValidations {
536    #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
537    pub count: Option<u32>,
538
539    #[serde(
540        rename = "@disablePrompts",
541        skip_serializing_if = "Option::is_none",
542        default
543    )]
544    pub disable_prompts: Option<bool>,
545
546    #[serde(rename = "@xWindow", skip_serializing_if = "Option::is_none", default)]
547    pub x_window: Option<u32>,
548
549    #[serde(rename = "@yWindow", skip_serializing_if = "Option::is_none", default)]
550    pub y_window: Option<u32>,
551
552    #[serde(rename = "dataValidation", default)]
553    pub data_validations: Vec<DataValidation>,
554}
555
556/// Individual data validation rule.
557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
558pub struct DataValidation {
559    #[serde(rename = "@type", skip_serializing_if = "Option::is_none")]
560    pub validation_type: Option<String>,
561
562    #[serde(rename = "@operator", skip_serializing_if = "Option::is_none")]
563    pub operator: Option<String>,
564
565    #[serde(rename = "@allowBlank", skip_serializing_if = "Option::is_none")]
566    pub allow_blank: Option<bool>,
567
568    #[serde(
569        rename = "@showDropDown",
570        skip_serializing_if = "Option::is_none",
571        default
572    )]
573    pub show_drop_down: Option<bool>,
574
575    #[serde(rename = "@showInputMessage", skip_serializing_if = "Option::is_none")]
576    pub show_input_message: Option<bool>,
577
578    #[serde(rename = "@showErrorMessage", skip_serializing_if = "Option::is_none")]
579    pub show_error_message: Option<bool>,
580
581    #[serde(rename = "@errorStyle", skip_serializing_if = "Option::is_none")]
582    pub error_style: Option<String>,
583
584    #[serde(rename = "@imeMode", skip_serializing_if = "Option::is_none", default)]
585    pub ime_mode: Option<String>,
586
587    #[serde(rename = "@errorTitle", skip_serializing_if = "Option::is_none")]
588    pub error_title: Option<String>,
589
590    #[serde(rename = "@error", skip_serializing_if = "Option::is_none")]
591    pub error: Option<String>,
592
593    #[serde(rename = "@promptTitle", skip_serializing_if = "Option::is_none")]
594    pub prompt_title: Option<String>,
595
596    #[serde(rename = "@prompt", skip_serializing_if = "Option::is_none")]
597    pub prompt: Option<String>,
598
599    #[serde(rename = "@sqref")]
600    pub sqref: String,
601
602    #[serde(rename = "formula1", skip_serializing_if = "Option::is_none")]
603    pub formula1: Option<String>,
604
605    #[serde(rename = "formula2", skip_serializing_if = "Option::is_none")]
606    pub formula2: Option<String>,
607}
608
609/// Merge cells container.
610///
611/// `PartialEq` is implemented manually to exclude `cached_coords`, which is a
612/// transient performance cache. Two values with the same `count` and
613/// `merge_cells` are semantically equal regardless of cache state.
614#[derive(Debug, Clone, Serialize, Deserialize)]
615pub struct MergeCells {
616    #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
617    pub count: Option<u32>,
618
619    #[serde(rename = "mergeCell", default)]
620    pub merge_cells: Vec<MergeCell>,
621
622    /// Cached parsed coordinates `(min_col, min_row, max_col, max_row)` for each
623    /// merge region, kept in parallel with `merge_cells`. Populated lazily on
624    /// first overlap check and maintained during add/remove. Not serialized.
625    #[serde(skip)]
626    pub cached_coords: Vec<(u32, u32, u32, u32)>,
627}
628
629impl PartialEq for MergeCells {
630    fn eq(&self, other: &Self) -> bool {
631        self.count == other.count && self.merge_cells == other.merge_cells
632    }
633}
634
635/// Individual merge cell reference.
636#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
637pub struct MergeCell {
638    #[serde(rename = "@ref")]
639    pub reference: String,
640}
641
642/// Hyperlinks container.
643#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
644pub struct Hyperlinks {
645    #[serde(rename = "hyperlink", default)]
646    pub hyperlinks: Vec<Hyperlink>,
647}
648
649/// Individual hyperlink.
650#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
651pub struct Hyperlink {
652    #[serde(rename = "@ref")]
653    pub reference: String,
654
655    #[serde(
656        rename = "@r:id",
657        alias = "@id",
658        skip_serializing_if = "Option::is_none"
659    )]
660    pub r_id: Option<String>,
661
662    #[serde(rename = "@location", skip_serializing_if = "Option::is_none")]
663    pub location: Option<String>,
664
665    #[serde(rename = "@display", skip_serializing_if = "Option::is_none")]
666    pub display: Option<String>,
667
668    #[serde(rename = "@tooltip", skip_serializing_if = "Option::is_none")]
669    pub tooltip: Option<String>,
670}
671
672/// Page margins.
673#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
674pub struct PageMargins {
675    #[serde(rename = "@left")]
676    pub left: f64,
677
678    #[serde(rename = "@right")]
679    pub right: f64,
680
681    #[serde(rename = "@top")]
682    pub top: f64,
683
684    #[serde(rename = "@bottom")]
685    pub bottom: f64,
686
687    #[serde(rename = "@header")]
688    pub header: f64,
689
690    #[serde(rename = "@footer")]
691    pub footer: f64,
692}
693
694/// Page setup.
695#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
696pub struct PageSetup {
697    #[serde(rename = "@paperSize", skip_serializing_if = "Option::is_none")]
698    pub paper_size: Option<u32>,
699
700    #[serde(rename = "@orientation", skip_serializing_if = "Option::is_none")]
701    pub orientation: Option<String>,
702
703    #[serde(rename = "@scale", skip_serializing_if = "Option::is_none")]
704    pub scale: Option<u32>,
705
706    #[serde(rename = "@fitToWidth", skip_serializing_if = "Option::is_none")]
707    pub fit_to_width: Option<u32>,
708
709    #[serde(rename = "@fitToHeight", skip_serializing_if = "Option::is_none")]
710    pub fit_to_height: Option<u32>,
711
712    #[serde(rename = "@firstPageNumber", skip_serializing_if = "Option::is_none")]
713    pub first_page_number: Option<u32>,
714
715    #[serde(rename = "@horizontalDpi", skip_serializing_if = "Option::is_none")]
716    pub horizontal_dpi: Option<u32>,
717
718    #[serde(rename = "@verticalDpi", skip_serializing_if = "Option::is_none")]
719    pub vertical_dpi: Option<u32>,
720
721    #[serde(
722        rename = "@r:id",
723        alias = "@id",
724        skip_serializing_if = "Option::is_none"
725    )]
726    pub r_id: Option<String>,
727}
728
729/// Header and footer for printing.
730#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
731pub struct HeaderFooter {
732    #[serde(rename = "oddHeader", skip_serializing_if = "Option::is_none")]
733    pub odd_header: Option<String>,
734
735    #[serde(rename = "oddFooter", skip_serializing_if = "Option::is_none")]
736    pub odd_footer: Option<String>,
737}
738
739/// Print options.
740#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
741pub struct PrintOptions {
742    #[serde(rename = "@gridLines", skip_serializing_if = "Option::is_none")]
743    pub grid_lines: Option<bool>,
744
745    #[serde(rename = "@headings", skip_serializing_if = "Option::is_none")]
746    pub headings: Option<bool>,
747
748    #[serde(
749        rename = "@horizontalCentered",
750        skip_serializing_if = "Option::is_none"
751    )]
752    pub horizontal_centered: Option<bool>,
753
754    #[serde(rename = "@verticalCentered", skip_serializing_if = "Option::is_none")]
755    pub vertical_centered: Option<bool>,
756}
757
758/// Row page breaks container.
759#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
760pub struct RowBreaks {
761    #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
762    pub count: Option<u32>,
763
764    #[serde(rename = "@manualBreakCount", skip_serializing_if = "Option::is_none")]
765    pub manual_break_count: Option<u32>,
766
767    #[serde(rename = "brk", default)]
768    pub brk: Vec<Break>,
769}
770
771/// Individual page break entry.
772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
773pub struct Break {
774    #[serde(rename = "@id")]
775    pub id: u32,
776
777    #[serde(rename = "@max", skip_serializing_if = "Option::is_none")]
778    pub max: Option<u32>,
779
780    #[serde(rename = "@man", skip_serializing_if = "Option::is_none")]
781    pub man: Option<bool>,
782}
783
784/// Drawing reference.
785#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
786pub struct DrawingRef {
787    #[serde(rename = "@r:id", alias = "@id")]
788    pub r_id: String,
789}
790
791/// Legacy drawing reference (VML).
792#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
793pub struct LegacyDrawingRef {
794    #[serde(rename = "@r:id", alias = "@id")]
795    pub r_id: String,
796}
797
798/// Table parts container.
799#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
800pub struct TableParts {
801    #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
802    pub count: Option<u32>,
803
804    #[serde(rename = "tablePart", default)]
805    pub table_parts: Vec<TablePart>,
806}
807
808/// Individual table part reference.
809#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
810pub struct TablePart {
811    #[serde(rename = "@r:id", alias = "@id")]
812    pub r_id: String,
813}
814
815/// Conditional formatting container.
816#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
817pub struct ConditionalFormatting {
818    #[serde(rename = "@sqref")]
819    pub sqref: String,
820
821    #[serde(rename = "cfRule", default)]
822    pub cf_rules: Vec<CfRule>,
823}
824
825/// Conditional formatting rule.
826#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
827pub struct CfRule {
828    #[serde(rename = "@type")]
829    pub rule_type: String,
830
831    #[serde(rename = "@dxfId", skip_serializing_if = "Option::is_none")]
832    pub dxf_id: Option<u32>,
833
834    #[serde(rename = "@priority")]
835    pub priority: u32,
836
837    #[serde(rename = "@operator", skip_serializing_if = "Option::is_none")]
838    pub operator: Option<String>,
839
840    #[serde(rename = "@text", skip_serializing_if = "Option::is_none")]
841    pub text: Option<String>,
842
843    #[serde(rename = "@stopIfTrue", skip_serializing_if = "Option::is_none")]
844    pub stop_if_true: Option<bool>,
845
846    #[serde(rename = "@aboveAverage", skip_serializing_if = "Option::is_none")]
847    pub above_average: Option<bool>,
848
849    #[serde(rename = "@equalAverage", skip_serializing_if = "Option::is_none")]
850    pub equal_average: Option<bool>,
851
852    #[serde(rename = "@percent", skip_serializing_if = "Option::is_none")]
853    pub percent: Option<bool>,
854
855    #[serde(rename = "@rank", skip_serializing_if = "Option::is_none")]
856    pub rank: Option<u32>,
857
858    #[serde(rename = "@bottom", skip_serializing_if = "Option::is_none")]
859    pub bottom: Option<bool>,
860
861    #[serde(rename = "formula", default, skip_serializing_if = "Vec::is_empty")]
862    pub formulas: Vec<String>,
863
864    #[serde(rename = "colorScale", skip_serializing_if = "Option::is_none")]
865    pub color_scale: Option<CfColorScale>,
866
867    #[serde(rename = "dataBar", skip_serializing_if = "Option::is_none")]
868    pub data_bar: Option<CfDataBar>,
869
870    #[serde(rename = "iconSet", skip_serializing_if = "Option::is_none")]
871    pub icon_set: Option<CfIconSet>,
872}
873
874/// Color scale definition for conditional formatting.
875#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
876pub struct CfColorScale {
877    #[serde(rename = "cfvo", default)]
878    pub cfvos: Vec<CfVo>,
879
880    #[serde(rename = "color", default)]
881    pub colors: Vec<CfColor>,
882}
883
884/// Data bar definition for conditional formatting.
885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
886pub struct CfDataBar {
887    #[serde(rename = "@showValue", skip_serializing_if = "Option::is_none")]
888    pub show_value: Option<bool>,
889
890    #[serde(rename = "cfvo", default)]
891    pub cfvos: Vec<CfVo>,
892
893    #[serde(rename = "color", skip_serializing_if = "Option::is_none")]
894    pub color: Option<CfColor>,
895}
896
897/// Icon set definition for conditional formatting.
898#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
899pub struct CfIconSet {
900    #[serde(rename = "@iconSet", skip_serializing_if = "Option::is_none")]
901    pub icon_set: Option<String>,
902
903    #[serde(rename = "cfvo", default)]
904    pub cfvos: Vec<CfVo>,
905}
906
907/// Conditional formatting value object.
908#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
909pub struct CfVo {
910    #[serde(rename = "@type")]
911    pub value_type: String,
912
913    #[serde(rename = "@val", skip_serializing_if = "Option::is_none")]
914    pub val: Option<String>,
915}
916
917/// Color reference for conditional formatting.
918#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
919pub struct CfColor {
920    #[serde(rename = "@rgb", skip_serializing_if = "Option::is_none")]
921    pub rgb: Option<String>,
922
923    #[serde(rename = "@theme", skip_serializing_if = "Option::is_none")]
924    pub theme: Option<u32>,
925
926    #[serde(rename = "@tint", skip_serializing_if = "Option::is_none")]
927    pub tint: Option<f64>,
928}
929
930impl Default for WorksheetXml {
931    fn default() -> Self {
932        Self {
933            xmlns: namespaces::SPREADSHEET_ML.to_string(),
934            xmlns_r: namespaces::RELATIONSHIPS.to_string(),
935            sheet_pr: None,
936            dimension: None,
937            sheet_views: None,
938            sheet_format_pr: None,
939            cols: None,
940            sheet_data: SheetData { rows: vec![] },
941            sheet_protection: None,
942            auto_filter: None,
943            merge_cells: None,
944            conditional_formatting: vec![],
945            data_validations: None,
946            hyperlinks: None,
947            print_options: None,
948            page_margins: None,
949            page_setup: None,
950            header_footer: None,
951            row_breaks: None,
952            col_breaks: None,
953            drawing: None,
954            legacy_drawing: None,
955            controls: None,
956            table_parts: None,
957        }
958    }
959}
960
961#[cfg(test)]
962mod tests {
963    use super::*;
964
965    #[test]
966    fn test_column_breaks_roundtrip_after_row_breaks() {
967        let xml = r#"<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheetData/><rowBreaks count="1"><brk id="5" max="16383" man="true"/></rowBreaks><colBreaks count="1" manualBreakCount="1"><brk id="3" max="1048575" man="true"/></colBreaks></worksheet>"#;
968
969        let worksheet: WorksheetXml = quick_xml::de::from_str(xml).unwrap();
970        assert_eq!(worksheet.col_breaks.as_ref().unwrap().brk[0].id, 3);
971
972        let serialized = quick_xml::se::to_string(&worksheet).unwrap();
973        assert!(serialized.find("rowBreaks").unwrap() < serialized.find("colBreaks").unwrap());
974        let reparsed: WorksheetXml = quick_xml::de::from_str(&serialized).unwrap();
975        assert_eq!(worksheet, reparsed);
976    }
977
978    #[test]
979    fn test_worksheet_default() {
980        let ws = WorksheetXml::default();
981        assert_eq!(ws.xmlns, namespaces::SPREADSHEET_ML);
982        assert_eq!(ws.xmlns_r, namespaces::RELATIONSHIPS);
983        assert!(ws.sheet_data.rows.is_empty());
984        assert!(ws.dimension.is_none());
985        assert!(ws.sheet_views.is_none());
986        assert!(ws.cols.is_none());
987        assert!(ws.merge_cells.is_none());
988        assert!(ws.page_margins.is_none());
989        assert!(ws.sheet_pr.is_none());
990        assert!(ws.sheet_protection.is_none());
991    }
992
993    #[test]
994    fn test_worksheet_roundtrip() {
995        let ws = WorksheetXml::default();
996        let xml = quick_xml::se::to_string(&ws).unwrap();
997        let parsed: WorksheetXml = quick_xml::de::from_str(&xml).unwrap();
998        assert_eq!(ws.xmlns, parsed.xmlns);
999        assert_eq!(ws.xmlns_r, parsed.xmlns_r);
1000        assert_eq!(ws.sheet_data.rows.len(), parsed.sheet_data.rows.len());
1001    }
1002
1003    #[test]
1004    fn test_worksheet_with_data() {
1005        let ws = WorksheetXml {
1006            sheet_data: SheetData {
1007                rows: vec![Row {
1008                    r: 1,
1009                    spans: Some("1:3".to_string()),
1010                    s: None,
1011                    custom_format: None,
1012                    ht: None,
1013                    hidden: None,
1014                    custom_height: None,
1015                    outline_level: None,
1016                    cells: vec![
1017                        Cell {
1018                            r: CompactCellRef::new("A1").unwrap(),
1019                            col: 1,
1020                            s: None,
1021                            t: CellTypeTag::SharedString,
1022                            v: Some("0".to_string()),
1023                            f: None,
1024                            is: None,
1025                        },
1026                        Cell {
1027                            r: CompactCellRef::new("B1").unwrap(),
1028                            col: 2,
1029                            s: None,
1030                            t: CellTypeTag::None,
1031                            v: Some("42".to_string()),
1032                            f: None,
1033                            is: None,
1034                        },
1035                    ],
1036                }],
1037            },
1038            ..WorksheetXml::default()
1039        };
1040
1041        let xml = quick_xml::se::to_string(&ws).unwrap();
1042        let parsed: WorksheetXml = quick_xml::de::from_str(&xml).unwrap();
1043        assert_eq!(parsed.sheet_data.rows.len(), 1);
1044        assert_eq!(parsed.sheet_data.rows[0].r, 1);
1045        assert_eq!(parsed.sheet_data.rows[0].cells.len(), 2);
1046        assert_eq!(parsed.sheet_data.rows[0].cells[0].r, "A1");
1047        assert_eq!(
1048            parsed.sheet_data.rows[0].cells[0].t,
1049            CellTypeTag::SharedString
1050        );
1051        assert_eq!(parsed.sheet_data.rows[0].cells[0].v, Some("0".to_string()));
1052        assert_eq!(parsed.sheet_data.rows[0].cells[1].r, "B1");
1053        assert_eq!(parsed.sheet_data.rows[0].cells[1].v, Some("42".to_string()));
1054    }
1055
1056    #[test]
1057    fn test_cell_with_formula() {
1058        let cell = Cell {
1059            r: CompactCellRef::new("C1").unwrap(),
1060            col: 3,
1061            s: None,
1062            t: CellTypeTag::None,
1063            v: Some("84".to_string()),
1064            f: Some(Box::new(CellFormula {
1065                t: None,
1066                reference: None,
1067                si: None,
1068                value: Some("A1+B1".to_string()),
1069            })),
1070            is: None,
1071        };
1072        let xml = quick_xml::se::to_string(&cell).unwrap();
1073        assert!(xml.contains("A1+B1"));
1074        // CT_Cell is a sequence (f, v, is); Excel repairs files that put v first.
1075        let f_at = xml.find("<f>").unwrap();
1076        let v_at = xml.find("<v>").unwrap();
1077        assert!(f_at < v_at, "formula must precede cached value: {xml}");
1078        assert!(xml.contains("</f><v>84</v>"), "{xml}");
1079        let parsed: Cell = quick_xml::de::from_str(&xml).unwrap();
1080        assert!(parsed.f.is_some());
1081        assert_eq!(parsed.f.unwrap().value, Some("A1+B1".to_string()));
1082        assert_eq!(parsed.v, Some("84".to_string()));
1083    }
1084
1085    #[test]
1086    fn test_cell_with_inline_string() {
1087        let cell = Cell {
1088            r: CompactCellRef::new("A1").unwrap(),
1089            col: 1,
1090            s: None,
1091            t: CellTypeTag::InlineString,
1092            v: None,
1093            f: None,
1094            is: Some(Box::new(InlineString {
1095                t: Some("Hello World".to_string()),
1096                r: vec![],
1097                r_ph: vec![],
1098            })),
1099        };
1100        let xml = quick_xml::se::to_string(&cell).unwrap();
1101        assert!(xml.contains("Hello World"));
1102        let parsed: Cell = quick_xml::de::from_str(&xml).unwrap();
1103        assert_eq!(parsed.t, CellTypeTag::InlineString);
1104        assert!(parsed.is.is_some());
1105        assert_eq!(parsed.is.unwrap().t, Some("Hello World".to_string()));
1106    }
1107
1108    #[test]
1109    fn test_inline_string_rich_runs_exclude_phonetic_annotations() {
1110        let xml = r#"<c r="A1" t="inlineStr"><is><r><t>Bold</t></r><r><t xml:space="preserve"> Text</t></r><rPh sb="0" eb="4">phonetic</rPh></is></c>"#;
1111        let cell: Cell = quick_xml::de::from_str(xml).unwrap();
1112        let inline = cell.is.unwrap();
1113
1114        assert_eq!(inline.r.len(), 2);
1115        assert_eq!(inline.r[0].t.value, "Bold");
1116        assert_eq!(inline.r[1].t.value, "Text");
1117        assert_eq!(inline.r_ph.len(), 1);
1118        assert_eq!(inline.r_ph[0].value, "phonetic");
1119    }
1120
1121    #[test]
1122    fn test_parse_real_excel_worksheet() {
1123        let xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
1124<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
1125  <dimension ref="A1:B2"/>
1126  <sheetData>
1127    <row r="1" spans="1:2">
1128      <c r="A1" t="s"><v>0</v></c>
1129      <c r="B1" t="s"><v>1</v></c>
1130    </row>
1131    <row r="2" spans="1:2">
1132      <c r="A2"><v>100</v></c>
1133      <c r="B2"><v>200</v></c>
1134    </row>
1135  </sheetData>
1136</worksheet>"#;
1137
1138        let parsed: WorksheetXml = quick_xml::de::from_str(xml).unwrap();
1139        assert_eq!(parsed.dimension.as_ref().unwrap().reference, "A1:B2");
1140        assert_eq!(parsed.sheet_data.rows.len(), 2);
1141        assert_eq!(parsed.sheet_data.rows[0].cells.len(), 2);
1142        assert_eq!(parsed.sheet_data.rows[0].cells[0].r, "A1");
1143        assert_eq!(
1144            parsed.sheet_data.rows[0].cells[0].t,
1145            CellTypeTag::SharedString
1146        );
1147        assert_eq!(parsed.sheet_data.rows[0].cells[0].v, Some("0".to_string()));
1148        assert_eq!(parsed.sheet_data.rows[1].cells[0].r, "A2");
1149        assert_eq!(
1150            parsed.sheet_data.rows[1].cells[0].v,
1151            Some("100".to_string())
1152        );
1153    }
1154
1155    #[test]
1156    fn test_worksheet_with_merge_cells() {
1157        let ws = WorksheetXml {
1158            merge_cells: Some(MergeCells {
1159                count: Some(1),
1160                merge_cells: vec![MergeCell {
1161                    reference: "A1:B2".to_string(),
1162                }],
1163                cached_coords: Vec::new(),
1164            }),
1165            ..WorksheetXml::default()
1166        };
1167        let xml = quick_xml::se::to_string(&ws).unwrap();
1168        assert!(xml.contains("mergeCells"));
1169        assert!(xml.contains("A1:B2"));
1170        let parsed: WorksheetXml = quick_xml::de::from_str(&xml).unwrap();
1171        assert!(parsed.merge_cells.is_some());
1172        assert_eq!(parsed.merge_cells.as_ref().unwrap().merge_cells.len(), 1);
1173    }
1174
1175    #[test]
1176    fn test_empty_sheet_data_serialization() {
1177        let sd = SheetData { rows: vec![] };
1178        let xml = quick_xml::se::to_string(&sd).unwrap();
1179        // Empty SheetData should still be serializable
1180        let parsed: SheetData = quick_xml::de::from_str(&xml).unwrap();
1181        assert!(parsed.rows.is_empty());
1182    }
1183
1184    #[test]
1185    fn test_row_optional_fields_not_serialized() {
1186        let row = Row {
1187            r: 1,
1188            spans: None,
1189            s: None,
1190            custom_format: None,
1191            ht: None,
1192            hidden: None,
1193            custom_height: None,
1194            outline_level: None,
1195            cells: vec![],
1196        };
1197        let xml = quick_xml::se::to_string(&row).unwrap();
1198        assert!(!xml.contains("spans"));
1199        assert!(!xml.contains("ht"));
1200        assert!(!xml.contains("hidden"));
1201    }
1202
1203    #[test]
1204    fn test_cell_type_tag_as_str() {
1205        assert_eq!(CellTypeTag::Boolean.as_str(), Some("b"));
1206        assert_eq!(CellTypeTag::Date.as_str(), Some("d"));
1207        assert_eq!(CellTypeTag::Error.as_str(), Some("e"));
1208        assert_eq!(CellTypeTag::InlineString.as_str(), Some("inlineStr"));
1209        assert_eq!(CellTypeTag::Number.as_str(), Some("n"));
1210        assert_eq!(CellTypeTag::SharedString.as_str(), Some("s"));
1211        assert_eq!(CellTypeTag::FormulaString.as_str(), Some("str"));
1212        assert_eq!(CellTypeTag::None.as_str(), Option::None);
1213    }
1214
1215    #[test]
1216    fn test_cell_type_tag_default_is_none() {
1217        assert_eq!(CellTypeTag::default(), CellTypeTag::None);
1218        assert!(CellTypeTag::None.is_none());
1219        assert!(!CellTypeTag::SharedString.is_none());
1220    }
1221
1222    #[test]
1223    fn test_cell_type_tag_serde_round_trip() {
1224        let variants = [
1225            (CellTypeTag::SharedString, "s"),
1226            (CellTypeTag::Number, "n"),
1227            (CellTypeTag::Boolean, "b"),
1228            (CellTypeTag::Error, "e"),
1229            (CellTypeTag::InlineString, "inlineStr"),
1230            (CellTypeTag::FormulaString, "str"),
1231            (CellTypeTag::Date, "d"),
1232        ];
1233        for (tag, expected_str) in &variants {
1234            let cell = Cell {
1235                r: CompactCellRef::new("A1").unwrap(),
1236                col: 1,
1237                s: None,
1238                t: *tag,
1239                v: Some("0".to_string()),
1240                f: None,
1241                is: None,
1242            };
1243            let xml = quick_xml::se::to_string(&cell).unwrap();
1244            assert!(
1245                xml.contains(&format!("t=\"{expected_str}\"")),
1246                "expected t=\"{expected_str}\" in: {xml}"
1247            );
1248            let parsed: Cell = quick_xml::de::from_str(&xml).unwrap();
1249            assert_eq!(parsed.t, *tag);
1250        }
1251
1252        let cell_none = Cell {
1253            r: CompactCellRef::new("A1").unwrap(),
1254            col: 1,
1255            s: None,
1256            t: CellTypeTag::None,
1257            v: Some("42".to_string()),
1258            f: None,
1259            is: None,
1260        };
1261        let xml = quick_xml::se::to_string(&cell_none).unwrap();
1262        assert!(
1263            !xml.contains("t="),
1264            "None variant should not emit t attribute: {xml}"
1265        );
1266        let parsed: Cell = quick_xml::de::from_str(&xml).unwrap();
1267        assert_eq!(parsed.t, CellTypeTag::None);
1268    }
1269
1270    #[test]
1271    fn test_worksheet_with_cols() {
1272        let ws = WorksheetXml {
1273            cols: Some(Cols {
1274                cols: vec![Col {
1275                    min: 1,
1276                    max: 1,
1277                    width: Some(15.0),
1278                    style: None,
1279                    hidden: None,
1280                    custom_width: Some(true),
1281                    outline_level: None,
1282                }],
1283            }),
1284            ..WorksheetXml::default()
1285        };
1286        let xml = quick_xml::se::to_string(&ws).unwrap();
1287        let parsed: WorksheetXml = quick_xml::de::from_str(&xml).unwrap();
1288        assert!(parsed.cols.is_some());
1289        let cols = parsed.cols.unwrap();
1290        assert_eq!(cols.cols.len(), 1);
1291        assert_eq!(cols.cols[0].min, 1);
1292        assert_eq!(cols.cols[0].width, Some(15.0));
1293        assert_eq!(cols.cols[0].custom_width, Some(true));
1294    }
1295
1296    #[test]
1297    fn test_sheet_protection_roundtrip() {
1298        let prot = SheetProtection {
1299            password: Some("ABCD".to_string()),
1300            sheet: Some(true),
1301            objects: Some(true),
1302            scenarios: Some(true),
1303            format_cells: Some(false),
1304            ..SheetProtection::default()
1305        };
1306        let xml = quick_xml::se::to_string(&prot).unwrap();
1307        let parsed: SheetProtection = quick_xml::de::from_str(&xml).unwrap();
1308        assert_eq!(parsed.password, Some("ABCD".to_string()));
1309        assert_eq!(parsed.sheet, Some(true));
1310        assert_eq!(parsed.objects, Some(true));
1311        assert_eq!(parsed.scenarios, Some(true));
1312        assert_eq!(parsed.format_cells, Some(false));
1313        assert!(parsed.sort.is_none());
1314    }
1315
1316    #[test]
1317    fn test_sheet_pr_roundtrip() {
1318        let pr = SheetPr {
1319            code_name: Some("Sheet1".to_string()),
1320            tab_color: Some(TabColor {
1321                rgb: Some("FF0000".to_string()),
1322                theme: None,
1323                indexed: None,
1324            }),
1325            ..SheetPr::default()
1326        };
1327        let xml = quick_xml::se::to_string(&pr).unwrap();
1328        let parsed: SheetPr = quick_xml::de::from_str(&xml).unwrap();
1329        assert_eq!(parsed.code_name, Some("Sheet1".to_string()));
1330        assert!(parsed.tab_color.is_some());
1331        assert_eq!(parsed.tab_color.unwrap().rgb, Some("FF0000".to_string()));
1332    }
1333
1334    #[test]
1335    fn test_sheet_format_pr_extended_fields() {
1336        let fmt = SheetFormatPr {
1337            default_row_height: 15.0,
1338            default_col_width: Some(10.0),
1339            custom_height: Some(true),
1340            outline_level_row: Some(2),
1341            outline_level_col: Some(1),
1342        };
1343        let xml = quick_xml::se::to_string(&fmt).unwrap();
1344        let parsed: SheetFormatPr = quick_xml::de::from_str(&xml).unwrap();
1345        assert_eq!(parsed.default_row_height, 15.0);
1346        assert_eq!(parsed.default_col_width, Some(10.0));
1347        assert_eq!(parsed.custom_height, Some(true));
1348        assert_eq!(parsed.outline_level_row, Some(2));
1349        assert_eq!(parsed.outline_level_col, Some(1));
1350    }
1351
1352    #[test]
1353    fn test_compact_cell_ref_basic() {
1354        let r = CompactCellRef::new("A1").unwrap();
1355        assert_eq!(r.as_str(), "A1");
1356    }
1357
1358    #[test]
1359    fn test_compact_cell_ref_max_length() {
1360        let r = CompactCellRef::new("XFD1048576").unwrap();
1361        assert_eq!(r.as_str(), "XFD1048576");
1362    }
1363
1364    #[test]
1365    fn test_compact_cell_ref_various_lengths() {
1366        for s in &["A1", "B5", "Z99", "AA100", "XFD1048576"] {
1367            let r = CompactCellRef::new(s).unwrap();
1368            assert_eq!(r.as_str(), *s);
1369        }
1370    }
1371
1372    #[test]
1373    fn test_compact_cell_ref_display() {
1374        let r = CompactCellRef::new("C3").unwrap();
1375        assert_eq!(format!("{r}"), "C3");
1376    }
1377
1378    #[test]
1379    fn test_compact_cell_ref_debug() {
1380        let r = CompactCellRef::new("C3").unwrap();
1381        let dbg = format!("{r:?}");
1382        assert!(dbg.contains("CompactCellRef"));
1383        assert!(dbg.contains("C3"));
1384    }
1385
1386    #[test]
1387    fn test_compact_cell_ref_from_str() {
1388        let r = CompactCellRef::try_from("D4").unwrap();
1389        assert_eq!(r.as_str(), "D4");
1390    }
1391
1392    #[test]
1393    fn test_compact_cell_ref_from_string() {
1394        let r = CompactCellRef::try_from(String::from("E5")).unwrap();
1395        assert_eq!(r.as_str(), "E5");
1396    }
1397
1398    #[test]
1399    fn test_compact_cell_ref_as_ref_str() {
1400        let r = CompactCellRef::new("F6").unwrap();
1401        let s: &str = r.as_ref();
1402        assert_eq!(s, "F6");
1403    }
1404
1405    #[test]
1406    fn test_compact_cell_ref_partial_eq_str() {
1407        let r = CompactCellRef::new("G7").unwrap();
1408        assert_eq!(r, "G7");
1409        assert!(r == "G7");
1410        assert!(r != "H8");
1411    }
1412
1413    #[test]
1414    fn test_compact_cell_ref_copy() {
1415        let r1 = CompactCellRef::new("A1").unwrap();
1416        let r2 = r1;
1417        assert_eq!(r1.as_str(), "A1");
1418        assert_eq!(r2.as_str(), "A1");
1419    }
1420
1421    #[test]
1422    fn test_compact_cell_ref_serde_roundtrip() {
1423        let cell = Cell {
1424            r: CompactCellRef::new("XFD1048576").unwrap(),
1425            col: 16384,
1426            s: None,
1427            t: CellTypeTag::None,
1428            v: Some("42".to_string()),
1429            f: None,
1430            is: None,
1431        };
1432        let xml = quick_xml::se::to_string(&cell).unwrap();
1433        assert!(xml.contains("XFD1048576"));
1434        let parsed: Cell = quick_xml::de::from_str(&xml).unwrap();
1435        assert_eq!(parsed.r, "XFD1048576");
1436        assert_eq!(parsed.v, Some("42".to_string()));
1437    }
1438
1439    #[test]
1440    fn test_compact_cell_ref_rejects_overflow() {
1441        assert!(CompactCellRef::new("ABCDEFGHIJK").is_err());
1442    }
1443
1444    #[test]
1445    fn test_compact_cell_ref_from_coordinates_a1() {
1446        let r = CompactCellRef::from_coordinates(1, 1).unwrap();
1447        assert_eq!(r.as_str(), "A1");
1448    }
1449
1450    #[test]
1451    fn test_compact_cell_ref_from_coordinates_z26() {
1452        let r = CompactCellRef::from_coordinates(26, 26).unwrap();
1453        assert_eq!(r.as_str(), "Z26");
1454    }
1455
1456    #[test]
1457    fn test_compact_cell_ref_from_coordinates_aa1() {
1458        let r = CompactCellRef::from_coordinates(27, 1).unwrap();
1459        assert_eq!(r.as_str(), "AA1");
1460    }
1461
1462    #[test]
1463    fn test_compact_cell_ref_from_coordinates_max() {
1464        let r = CompactCellRef::from_coordinates(16384, 1048576).unwrap();
1465        assert_eq!(r.as_str(), "XFD1048576");
1466    }
1467
1468    #[test]
1469    fn test_compact_cell_ref_from_coordinates_zz1() {
1470        let r = CompactCellRef::from_coordinates(702, 1).unwrap();
1471        assert_eq!(r.as_str(), "ZZ1");
1472    }
1473
1474    #[test]
1475    fn test_compact_cell_ref_from_coordinates_roundtrip() {
1476        fn col_to_name(mut col: u32) -> String {
1477            let mut result = String::new();
1478            while col > 0 {
1479                col -= 1;
1480                result.insert(0, (b'A' + (col % 26) as u8) as char);
1481                col /= 26;
1482            }
1483            result
1484        }
1485        for c in [1, 2, 26, 27, 52, 100, 256, 702, 703, 16384] {
1486            let r = CompactCellRef::from_coordinates(c, 1).unwrap();
1487            let expected = format!("{}1", col_to_name(c));
1488            assert_eq!(r.as_str(), expected, "mismatch for col={c}");
1489        }
1490    }
1491}