Skip to main content

sheetkit_core/workbook/
sheet_ops.rs

1use super::*;
2use crate::cell_ref_shift::StructuralShift;
3
4fn validate_anchor_shift<F>(col: u32, row: u32, shift_cell: F) -> Result<()>
5where
6    F: Fn(u32, u32) -> (u32, u32),
7{
8    let col = col.checked_add(1).ok_or(Error::InvalidColumnNumber(col))?;
9    let row = row.checked_add(1).ok_or(Error::InvalidRowNumber(row))?;
10    let (col, row) = shift_cell(col, row);
11    if !(1..=crate::utils::constants::MAX_COLUMNS).contains(&col) {
12        return Err(Error::InvalidColumnNumber(col));
13    }
14    if !(1..=crate::utils::constants::MAX_ROWS).contains(&row) {
15        return Err(Error::InvalidRowNumber(row));
16    }
17    Ok(())
18}
19
20/// Shift formula references owned by `owner_sheet_idx` for a structural edit
21/// of `target_sheet_idx`. Removed cells become `#REF!` and ranges shrink.
22fn shift_references_for_owner(
23    text: &str,
24    owner_sheet_idx: usize,
25    target_sheet_idx: usize,
26    target_sheet_name_lowercase: &str,
27    edit: StructuralShift,
28) -> Result<String> {
29    crate::cell_ref_shift::shift_references_structural(
30        text,
31        owner_sheet_idx == target_sheet_idx,
32        |sheet_name| crate::sheet::sheet_names_equal(sheet_name, target_sheet_name_lowercase),
33        edit,
34    )
35}
36
37/// Shift positional references (selections, panes, hyperlink targets) that
38/// must keep pointing at a surviving cell after a structural edit.
39fn shift_point_references_for_owner(
40    text: &str,
41    owner_sheet_idx: usize,
42    target_sheet_idx: usize,
43    target_sheet_name_lowercase: &str,
44    edit: StructuralShift,
45) -> Result<String> {
46    crate::cell_ref_shift::shift_cell_references_with_abs_and_scope(
47        text,
48        owner_sheet_idx == target_sheet_idx,
49        |sheet_name| crate::sheet::sheet_names_equal(sheet_name, target_sheet_name_lowercase),
50        |col, row, _, _| edit.shift_point(col, row),
51    )
52}
53
54fn shift_duplicated_row_formula(
55    formula: &str,
56    target_sheet_name_lowercase: &str,
57    target_row: u32,
58) -> Result<String> {
59    crate::cell_ref_shift::shift_duplicated_row_references(
60        formula,
61        |sheet_name| crate::sheet::sheet_names_equal(sheet_name, target_sheet_name_lowercase),
62        target_row,
63    )
64}
65
66/// Shift a single-cell anchor such as a comment reference. Returns `None`
67/// when the cell was removed; unparseable references are kept unchanged.
68fn shift_cell_anchor(reference: &str, edit: StructuralShift) -> Result<Option<String>> {
69    let Ok((col, row)) = crate::utils::cell_ref::cell_name_to_coordinates(reference) else {
70        return Ok(Some(reference.to_string()));
71    };
72    match edit.shift_cell(col, row) {
73        None => Ok(None),
74        Some((col, row)) => crate::utils::cell_ref::coordinates_to_cell_name(col, row).map(Some),
75    }
76}
77
78/// Formula state detached from a duplicated row while references shift.
79#[derive(Debug, Default)]
80struct DuplicatedFormula {
81    text: Option<String>,
82    array_ref: Option<String>,
83}
84
85fn offset_coordinate(value: u32, delta: i64) -> u32 {
86    u32::try_from(i64::from(value) + delta).unwrap_or(0)
87}
88
89/// Expand a shared-formula child at `cell_ref` from its master formula.
90fn expand_shared_formula(ws: &WorksheetXml, si: u32, cell_ref: &str) -> Result<Option<String>> {
91    let master = ws
92        .sheet_data
93        .rows
94        .iter()
95        .flat_map(|row| row.cells.iter())
96        .find_map(|cell| {
97            let formula = cell.f.as_ref()?;
98            (formula.t.as_deref() == Some("shared") && formula.si == Some(si)).then_some(())?;
99            formula.value.as_deref().map(|text| (cell.r.as_str(), text))
100        });
101    let Some((master_ref, master_text)) = master else {
102        return Ok(None);
103    };
104    let (master_col, master_row) = crate::utils::cell_ref::cell_name_to_coordinates(master_ref)?;
105    let (col, row) = crate::utils::cell_ref::cell_name_to_coordinates(cell_ref)?;
106    let col_delta = i64::from(col) - i64::from(master_col);
107    let row_delta = i64::from(row) - i64::from(master_row);
108    crate::cell_ref_shift::shift_cell_references_with_abs_and_scope(
109        master_text,
110        true,
111        |_| true,
112        |col, row, abs_col, abs_row| {
113            (
114                if abs_col {
115                    col
116                } else {
117                    offset_coordinate(col, col_delta)
118                },
119                if abs_row {
120                    row
121                } else {
122                    offset_coordinate(row, row_delta)
123                },
124            )
125        },
126    )
127    .map(Some)
128}
129
130/// Resolve the formula text of every cell in `row`, expanding shared-formula
131/// children from their master. Cells without a resolvable formula yield `None`.
132fn duplicated_row_formula_sources(ws: &WorksheetXml, row: u32) -> Result<Vec<Option<String>>> {
133    let Some(source) = ws
134        .sheet_data
135        .rows
136        .iter()
137        .find(|candidate| candidate.r == row)
138    else {
139        return Ok(Vec::new());
140    };
141    let mut texts = Vec::with_capacity(source.cells.len());
142    for cell in &source.cells {
143        let Some(formula) = &cell.f else {
144            texts.push(None);
145            continue;
146        };
147        if let Some(text) = &formula.value {
148            texts.push(Some(text.clone()));
149            continue;
150        }
151        texts.push(match (formula.t.as_deref(), formula.si) {
152            (Some("shared"), Some(si)) => expand_shared_formula(ws, si, cell.r.as_str())?,
153            _ => None,
154        });
155    }
156    Ok(texts)
157}
158
159/// Shift page breaks on the edited axis. A break is attached to the row or
160/// column that follows it and is dropped when that row or column is removed.
161fn shift_page_breaks(
162    breaks: &mut Option<sheetkit_xml::worksheet::RowBreaks>,
163    edit: StructuralShift,
164    max_index: u32,
165) {
166    let Some(container) = breaks.as_mut() else {
167        return;
168    };
169    container.brk.retain_mut(|brk| {
170        let Some(following) = brk.id.checked_add(1) else {
171            return true;
172        };
173        match edit.shift_index(following) {
174            Some(shifted) if shifted <= max_index => {
175                brk.id = shifted - 1;
176                true
177            }
178            Some(_) | None => false,
179        }
180    });
181    if container.brk.is_empty() {
182        *breaks = None;
183        return;
184    }
185    let total = container.brk.len() as u32;
186    let manual = container
187        .brk
188        .iter()
189        .filter(|brk| brk.man == Some(true))
190        .count() as u32;
191    if container.count.is_some() {
192        container.count = Some(total);
193    }
194    if container.manual_break_count.is_some() {
195        container.manual_break_count = Some(manual);
196    }
197}
198
199/// Compute a table definition after a structural edit of its owner sheet.
200///
201/// Removing a column inside the table drops the matching table column.
202/// Removing the header row, the totals row, every data row, or the whole
203/// table is rejected because the table part cannot be kept consistent.
204fn shift_table_definition(
205    table: &sheetkit_xml::table::TableXml,
206    edit: StructuralShift,
207) -> Result<sheetkit_xml::table::TableXml> {
208    let mut shifted = table.clone();
209    let reject = |reason: &str| {
210        Error::InvalidArgument(format!(
211            "cannot structurally edit table '{}': {reason}",
212            table.name
213        ))
214    };
215    let reference = crate::cell_ref_shift::shift_sqref_structural(&table.reference, edit)?
216        .ok_or_else(|| reject("the edit removes the whole table"))?;
217    if edit.is_removal() {
218        let (start, end) = table
219            .reference
220            .split_once(':')
221            .unwrap_or((&table.reference, &table.reference));
222        let (first_col, first_row) = crate::utils::cell_ref::cell_name_to_coordinates(start)?;
223        let (last_col, last_row) = crate::utils::cell_ref::cell_name_to_coordinates(end)?;
224        if edit.is_row_axis() {
225            let header_rows = table.header_row_count.unwrap_or(1);
226            let totals_rows = table.totals_row_count.unwrap_or(0);
227            if header_rows > 0 && edit.shift_index(first_row).is_none() {
228                return Err(reject("the edit removes the header row"));
229            }
230            if totals_rows > 0 && edit.shift_index(last_row).is_none() {
231                return Err(reject("the edit removes the totals row"));
232            }
233            let (new_start, new_end) = reference
234                .split_once(':')
235                .unwrap_or((&reference, &reference));
236            let (_, new_first_row) = crate::utils::cell_ref::cell_name_to_coordinates(new_start)?;
237            let (_, new_last_row) = crate::utils::cell_ref::cell_name_to_coordinates(new_end)?;
238            let required = header_rows.saturating_add(totals_rows).saturating_add(1);
239            if new_last_row.saturating_sub(new_first_row).saturating_add(1) < required {
240                return Err(reject("the edit removes every data row"));
241            }
242        } else {
243            for col in (first_col.min(last_col)..=first_col.max(last_col)).rev() {
244                if edit.shift_index(col).is_none() {
245                    let index = (col - first_col.min(last_col)) as usize;
246                    if index < shifted.table_columns.columns.len() {
247                        shifted.table_columns.columns.remove(index);
248                    }
249                }
250            }
251            if shifted.table_columns.columns.is_empty() {
252                return Err(reject("the edit removes every table column"));
253            }
254            shifted.table_columns.count = shifted.table_columns.columns.len() as u32;
255        }
256    }
257    shifted.reference = reference;
258    if let Some(auto_filter) = &table.auto_filter {
259        match crate::cell_ref_shift::shift_sqref_structural(&auto_filter.reference, edit)? {
260            Some(reference) => {
261                if let Some(shifted_filter) = &mut shifted.auto_filter {
262                    shifted_filter.reference = reference;
263                }
264            }
265            None => shifted.auto_filter = None,
266        }
267    }
268    Ok(shifted)
269}
270
271fn next_numbered_part_path(
272    prefix: &str,
273    suffix: &str,
274    existing: &std::collections::HashSet<String>,
275) -> String {
276    let mut number = 1usize;
277    loop {
278        let candidate = format!("{prefix}{number}{suffix}");
279        if !existing.contains(&candidate) {
280            return candidate;
281        }
282        number += 1;
283    }
284}
285
286fn replace_raw_text_once(raw: &[u8], old: &str, new: &str, path: &str) -> Result<Vec<u8>> {
287    let raw =
288        std::str::from_utf8(raw).map_err(|error| Error::XmlParse(format!("{path}: {error}")))?;
289    let count = raw.matches(old).count();
290    if count != 1 {
291        return Err(Error::InvalidArgument(format!(
292            "cannot safely patch retained raw XML for '{path}'"
293        )));
294    }
295    Ok(raw.replacen(old, new, 1).into_bytes())
296}
297
298fn replace_raw_element_texts(
299    raw: &[u8],
300    replacements: impl IntoIterator<Item = (String, String, String)>,
301    path: &str,
302) -> Result<Vec<u8>> {
303    let raw =
304        std::str::from_utf8(raw).map_err(|error| Error::XmlParse(format!("{path}: {error}")))?;
305    let replacements: std::collections::BTreeSet<_> = replacements.into_iter().collect();
306    let mut patched = raw.to_string();
307    let mut tokens = Vec::new();
308    for (index, (tag, old, new)) in replacements.into_iter().enumerate() {
309        if old == new {
310            continue;
311        }
312        let old = quick_xml::escape::escape(&old);
313        let needle = format!("<{tag}>{old}</{tag}>");
314        let token = format!("__sheetkit_element_{index}__");
315        if !patched.contains(&needle) || patched.contains(&token) {
316            return Err(Error::InvalidArgument(format!(
317                "cannot safely patch retained raw XML for '{path}'"
318            )));
319        }
320        patched = patched.replace(&needle, &format!("<{tag}>{token}</{tag}>"));
321        tokens.push((tag, token, new));
322    }
323    for (tag, token, new) in tokens {
324        let new = quick_xml::escape::escape(&new);
325        patched = patched.replace(
326            &format!("<{tag}>{token}</{tag}>"),
327            &format!("<{tag}>{new}</{tag}>"),
328        );
329    }
330    Ok(patched.into_bytes())
331}
332
333fn patch_raw_drawing_coordinates<F>(
334    raw: &[u8],
335    drawing: &WsDr,
336    shift_cell: F,
337    path: &str,
338) -> Result<Vec<u8>>
339where
340    F: Fn(u32, u32) -> (u32, u32) + Copy,
341{
342    let raw =
343        std::str::from_utf8(raw).map_err(|error| Error::XmlParse(format!("{path}: {error}")))?;
344    let mut values = std::collections::BTreeMap::new();
345    for anchor in &drawing.one_cell_anchors {
346        values.insert(
347            ("col", anchor.from.col),
348            shift_cell(anchor.from.col + 1, anchor.from.row + 1).0 - 1,
349        );
350        values.insert(
351            ("row", anchor.from.row),
352            shift_cell(anchor.from.col + 1, anchor.from.row + 1).1 - 1,
353        );
354    }
355    for anchor in &drawing.two_cell_anchors {
356        for marker in [&anchor.from, &anchor.to] {
357            let (col, row) = shift_cell(marker.col + 1, marker.row + 1);
358            values.insert(("col", marker.col), col - 1);
359            values.insert(("row", marker.row), row - 1);
360        }
361    }
362    // DrawingML markers use distinct col/row elements. Patch through temporary
363    // tokens so a 0->1 shift cannot be shifted a second time as 1->2.
364    let mut patched = raw.to_string();
365    for ((tag, old), new) in &values {
366        if old == new {
367            continue;
368        }
369        let needle = format!("<xdr:{tag}>{old}</xdr:{tag}>");
370        if !patched.contains(&needle) {
371            return Err(Error::InvalidArgument(format!(
372                "cannot safely patch retained raw XML for '{path}'"
373            )));
374        }
375        patched = patched.replace(
376            &needle,
377            &format!("<xdr:{tag}>__sheetkit_{tag}_{old}__</xdr:{tag}>"),
378        );
379    }
380    for ((tag, old), new) in values {
381        if old != new {
382            patched = patched.replace(
383                &format!("<xdr:{tag}>__sheetkit_{tag}_{old}__</xdr:{tag}>"),
384                &format!("<xdr:{tag}>{new}</xdr:{tag}>"),
385            );
386        }
387    }
388    Ok(patched.into_bytes())
389}
390
391fn validate_drawing_relationship_ids(drawing: &WsDr, relationships: &Relationships) -> Result<()> {
392    let mut required = Vec::new();
393    for anchor in &drawing.two_cell_anchors {
394        if let Some(frame) = &anchor.graphic_frame {
395            required.push((
396                frame.graphic.graphic_data.chart.r_id.as_str(),
397                rel_types::CHART,
398            ));
399        }
400        if let Some(picture) = &anchor.pic {
401            required.push((picture.blip_fill.blip.r_embed.as_str(), rel_types::IMAGE));
402        }
403    }
404    for anchor in &drawing.one_cell_anchors {
405        if let Some(picture) = &anchor.pic {
406            required.push((picture.blip_fill.blip.r_embed.as_str(), rel_types::IMAGE));
407        }
408    }
409    for (r_id, rel_type) in required {
410        if !relationships
411            .relationships
412            .iter()
413            .any(|relationship| relationship.id == r_id && relationship.rel_type == rel_type)
414        {
415            return Err(Error::InvalidArgument(format!(
416                "drawing relationship '{r_id}' is missing or has the wrong type"
417            )));
418        }
419    }
420    Ok(())
421}
422
423fn validate_worksheet_relationship_ids(
424    worksheet: &WorksheetXml,
425    relationships: &Relationships,
426) -> Result<()> {
427    let relationship_matches = |r_id: &str, rel_type: &str| {
428        relationships
429            .relationships
430            .iter()
431            .any(|relationship| relationship.id == r_id && relationship.rel_type == rel_type)
432    };
433    if let Some(drawing) = &worksheet.drawing {
434        if !relationship_matches(&drawing.r_id, rel_types::DRAWING) {
435            return Err(Error::InvalidArgument(format!(
436                "worksheet drawing relationship '{}' is missing or has the wrong type",
437                drawing.r_id
438            )));
439        }
440    }
441    if let Some(legacy_drawing) = &worksheet.legacy_drawing {
442        if !relationship_matches(&legacy_drawing.r_id, rel_types::VML_DRAWING) {
443            return Err(Error::InvalidArgument(format!(
444                "worksheet legacy drawing relationship '{}' is missing or has the wrong type",
445                legacy_drawing.r_id
446            )));
447        }
448    }
449    if let Some(page_setup) = &worksheet.page_setup {
450        if let Some(r_id) = &page_setup.r_id {
451            if !relationship_matches(r_id, rel_types::PRINTER_SETTINGS) {
452                return Err(Error::InvalidArgument(format!(
453                    "worksheet page setup relationship '{r_id}' is missing or has the wrong type"
454                )));
455            }
456        }
457    }
458    if let Some(hyperlinks) = &worksheet.hyperlinks {
459        for hyperlink in &hyperlinks.hyperlinks {
460            if let Some(r_id) = &hyperlink.r_id {
461                if !relationship_matches(r_id, rel_types::HYPERLINK) {
462                    return Err(Error::InvalidArgument(format!(
463                        "worksheet hyperlink relationship '{r_id}' is missing or has the wrong type"
464                    )));
465                }
466            }
467        }
468    }
469    if let Some(table_parts) = &worksheet.table_parts {
470        for table_part in &table_parts.table_parts {
471            if !relationship_matches(&table_part.r_id, rel_types::TABLE) {
472                return Err(Error::InvalidArgument(format!(
473                    "worksheet table relationship '{}' is missing or has the wrong type",
474                    table_part.r_id
475                )));
476            }
477        }
478    }
479    Ok(())
480}
481
482fn clone_threaded_comments_with_new_ids(
483    source: &sheetkit_xml::threaded_comment::ThreadedComments,
484    occupied_ids: &mut std::collections::HashSet<String>,
485) -> sheetkit_xml::threaded_comment::ThreadedComments {
486    let mut cloned = source.clone();
487    let mut remapped = std::collections::HashMap::new();
488    for comment in &mut cloned.comments {
489        let new_id = loop {
490            let candidate = format!("{{{}}}", uuid::Uuid::new_v4().to_string().to_uppercase());
491            if occupied_ids.insert(candidate.clone()) {
492                break candidate;
493            }
494        };
495        remapped.insert(comment.id.clone(), new_id.clone());
496        comment.id = new_id;
497    }
498    for comment in &mut cloned.comments {
499        if let Some(parent_id) = &mut comment.parent_id {
500            if let Some(new_parent_id) = remapped.get(parent_id) {
501                *parent_id = new_parent_id.clone();
502            }
503        }
504    }
505    cloned
506}
507
508fn visit_series_references<F>(
509    series: &mut sheetkit_xml::chart::Series,
510    visitor: &mut F,
511) -> Result<()>
512where
513    F: FnMut(&mut String) -> Result<()>,
514{
515    if let Some(text) = &mut series.tx {
516        if let Some(reference) = &mut text.str_ref {
517            visitor(&mut reference.f)?;
518        }
519    }
520    if let Some(category) = &mut series.cat {
521        if let Some(reference) = &mut category.str_ref {
522            visitor(&mut reference.f)?;
523        }
524        if let Some(reference) = &mut category.num_ref {
525            visitor(&mut reference.f)?;
526        }
527    }
528    if let Some(value) = &mut series.val {
529        if let Some(reference) = &mut value.num_ref {
530            visitor(&mut reference.f)?;
531        }
532    }
533    Ok(())
534}
535
536fn visit_scatter_references<F>(
537    series: &mut sheetkit_xml::chart::ScatterSeries,
538    visitor: &mut F,
539) -> Result<()>
540where
541    F: FnMut(&mut String) -> Result<()>,
542{
543    if let Some(text) = &mut series.tx {
544        if let Some(reference) = &mut text.str_ref {
545            visitor(&mut reference.f)?;
546        }
547    }
548    if let Some(category) = &mut series.x_val {
549        if let Some(reference) = &mut category.str_ref {
550            visitor(&mut reference.f)?;
551        }
552        if let Some(reference) = &mut category.num_ref {
553            visitor(&mut reference.f)?;
554        }
555    }
556    if let Some(value) = &mut series.y_val {
557        if let Some(reference) = &mut value.num_ref {
558            visitor(&mut reference.f)?;
559        }
560    }
561    Ok(())
562}
563
564fn visit_bubble_references<F>(
565    series: &mut sheetkit_xml::chart::BubbleSeries,
566    visitor: &mut F,
567) -> Result<()>
568where
569    F: FnMut(&mut String) -> Result<()>,
570{
571    if let Some(text) = &mut series.tx {
572        if let Some(reference) = &mut text.str_ref {
573            visitor(&mut reference.f)?;
574        }
575    }
576    if let Some(category) = &mut series.x_val {
577        if let Some(reference) = &mut category.str_ref {
578            visitor(&mut reference.f)?;
579        }
580        if let Some(reference) = &mut category.num_ref {
581            visitor(&mut reference.f)?;
582        }
583    }
584    for value in [&mut series.y_val, &mut series.bubble_size]
585        .into_iter()
586        .flatten()
587    {
588        if let Some(reference) = &mut value.num_ref {
589            visitor(&mut reference.f)?;
590        }
591    }
592    Ok(())
593}
594
595fn visit_chart_references<F>(chart: &mut ChartSpace, mut visitor: F) -> Result<()>
596where
597    F: FnMut(&mut String) -> Result<()>,
598{
599    macro_rules! visit_series_chart {
600        ($chart:expr) => {
601            if let Some(chart) = &mut $chart {
602                for series in &mut chart.series {
603                    visit_series_references(series, &mut visitor)?;
604                }
605            }
606        };
607    }
608    let plot_area = &mut chart.chart.plot_area;
609    visit_series_chart!(plot_area.bar_chart);
610    visit_series_chart!(plot_area.bar_3d_chart);
611    visit_series_chart!(plot_area.line_chart);
612    visit_series_chart!(plot_area.line_3d_chart);
613    visit_series_chart!(plot_area.pie_chart);
614    visit_series_chart!(plot_area.pie_3d_chart);
615    visit_series_chart!(plot_area.doughnut_chart);
616    visit_series_chart!(plot_area.area_chart);
617    visit_series_chart!(plot_area.area_3d_chart);
618    visit_series_chart!(plot_area.radar_chart);
619    visit_series_chart!(plot_area.stock_chart);
620    visit_series_chart!(plot_area.surface_chart);
621    visit_series_chart!(plot_area.surface_3d_chart);
622    visit_series_chart!(plot_area.of_pie_chart);
623    if let Some(chart) = &mut plot_area.scatter_chart {
624        for series in &mut chart.series {
625            visit_scatter_references(series, &mut visitor)?;
626        }
627    }
628    if let Some(chart) = &mut plot_area.bubble_chart {
629        for series in &mut chart.series {
630            visit_bubble_references(series, &mut visitor)?;
631        }
632    }
633    Ok(())
634}
635
636impl Workbook {
637    fn append_empty_sheet_state(&mut self) {
638        if self.sheet_comments.len() < self.worksheets.len() {
639            self.sheet_comments.push(None);
640        }
641        if self.sheet_sparklines.len() < self.worksheets.len() {
642            self.sheet_sparklines.push(vec![]);
643            self.sheet_sparklines_hydrated.push(true);
644        }
645        if self.sheet_vml.len() < self.worksheets.len() {
646            self.sheet_vml.push(None);
647        }
648        if self.raw_sheet_xml.len() < self.worksheets.len() {
649            self.raw_sheet_xml.push(None);
650        }
651        if self.raw_sheet_extensions.len() < self.worksheets.len() {
652            self.raw_sheet_extensions.push(None);
653        }
654        if self.sheet_dirty.len() < self.worksheets.len() {
655            self.sheet_dirty.push(true);
656        }
657        if self.sheet_included.len() < self.worksheets.len() {
658            self.sheet_included.push(true);
659        }
660        if self.sheet_materialized.len() < self.worksheets.len() {
661            self.sheet_materialized.push(true);
662        }
663        if self.sheet_package_backed.len() < self.worksheets.len() {
664            self.sheet_package_backed.push(false);
665        }
666        if self.sheet_threaded_comments.len() < self.worksheets.len() {
667            self.sheet_threaded_comments.push(None);
668        }
669        if self.sheet_form_controls.len() < self.worksheets.len() {
670            self.sheet_form_controls.push(vec![]);
671        }
672        if self.sheet_controls_dirty.len() < self.worksheets.len() {
673            self.sheet_controls_dirty.push(false);
674        }
675    }
676
677    /// Return the names of all sheets in workbook order.
678    pub fn sheet_names(&self) -> Vec<&str> {
679        self.worksheets
680            .iter()
681            .map(|(name, _)| name.as_str())
682            .collect()
683    }
684
685    /// Create a new empty sheet with the given name. Returns the 0-based sheet index.
686    pub fn new_sheet(&mut self, name: &str) -> Result<usize> {
687        let occupied_paths = self.occupied_part_paths();
688        let idx = crate::sheet::add_sheet_with_occupied_paths(
689            &mut self.workbook_xml,
690            &mut self.workbook_rels,
691            &mut self.content_types,
692            &mut self.worksheets,
693            name,
694            WorksheetXml::default(),
695            occupied_paths,
696        )?;
697        self.append_empty_sheet_state();
698        self.rebuild_sheet_index();
699        Ok(idx)
700    }
701
702    /// Delete a sheet by name.
703    pub fn delete_sheet(&mut self, name: &str) -> Result<()> {
704        let idx = self.sheet_index(name)?;
705        self.assert_parallel_vecs_in_sync();
706        if self.worksheets.len() <= 1 {
707            return Err(Error::InvalidSheetName(
708                "cannot delete the last sheet in a workbook".into(),
709            ));
710        }
711        if self.worksheet_rels.get(&idx).is_some_and(|rels| {
712            rels.relationships.iter().any(|relationship| {
713                relationship.rel_type == rel_types::PIVOT_TABLE
714                    || relationship.rel_type == rel_types::SLICER
715                    || relationship.rel_type == rel_types::SLICER_CACHE
716            })
717        }) {
718            return Err(Error::InvalidArgument(
719                "cannot delete a sheet with pivot or slicer relationships safely".into(),
720            ));
721        }
722        self.ensure_drawing_relationships_hydratable(idx)?;
723        self.hydrate_lifecycle_parts_for_delete(idx)?;
724        let deleted_drawing_idx = self.ensure_owned_drawing_parsed(idx)?;
725        let deleted_sheet_path = self.sheet_part_path(idx);
726        let deleted_direct_targets: Vec<String> = self
727            .worksheet_rels
728            .get(&idx)
729            .into_iter()
730            .flat_map(|rels| &rels.relationships)
731            .filter(|relationship| relationship.target_mode.as_deref() != Some("External"))
732            .map(|relationship| {
733                crate::workbook_paths::resolve_relationship_target(
734                    &deleted_sheet_path,
735                    &relationship.target,
736                )
737            })
738            .collect();
739
740        crate::sheet::delete_sheet(
741            &mut self.workbook_xml,
742            &mut self.workbook_rels,
743            &mut self.content_types,
744            &mut self.worksheets,
745            name,
746        )?;
747
748        if let Some(defined_names) = &mut self.workbook_xml.defined_names {
749            defined_names
750                .defined_names
751                .retain(|defined_name| defined_name.local_sheet_id != Some(idx as u32));
752            for defined_name in &mut defined_names.defined_names {
753                if let Some(local_sheet_id) = &mut defined_name.local_sheet_id {
754                    if *local_sheet_id > idx as u32 {
755                        *local_sheet_id -= 1;
756                    }
757                }
758            }
759        }
760        if let Some(book_views) = &mut self.workbook_xml.book_views {
761            let last_sheet_idx = self.worksheets.len().saturating_sub(1) as u32;
762            for view in &mut book_views.workbook_views {
763                if let Some(active_tab) = &mut view.active_tab {
764                    if *active_tab > idx as u32 {
765                        *active_tab -= 1;
766                    }
767                    *active_tab = (*active_tab).min(last_sheet_idx);
768                }
769            }
770        }
771
772        // Remove all per-sheet parallel data at once. After delete_sheet
773        // above, worksheets has already been shortened by 1 so these
774        // vectors must follow.
775        self.sheet_comments.remove(idx);
776        self.sheet_sparklines.remove(idx);
777        self.sheet_sparklines_hydrated.remove(idx);
778        self.sheet_vml.remove(idx);
779        self.raw_sheet_xml.remove(idx);
780        self.raw_sheet_extensions.remove(idx);
781        self.sheet_dirty.remove(idx);
782        self.sheet_included.remove(idx);
783        self.sheet_materialized.remove(idx);
784        self.sheet_package_backed.remove(idx);
785        self.sheet_threaded_comments.remove(idx);
786        self.sheet_form_controls.remove(idx);
787        self.sheet_controls_dirty.remove(idx);
788
789        // Remove tables belonging to the deleted sheet and re-index remaining.
790        self.tables.retain(|(_, _, si)| *si != idx);
791        for (_, _, si) in &mut self.tables {
792            if *si > idx {
793                *si -= 1;
794            }
795        }
796
797        // Remove and reindex streamed sheet data.
798        self.streamed_sheets.remove(&idx);
799        self.streamed_sheets = self
800            .streamed_sheets
801            .drain()
802            .map(|(i, data)| if i > idx { (i - 1, data) } else { (i, data) })
803            .collect();
804
805        self.reindex_sheet_maps_after_delete(idx);
806        if let Some(drawing_idx) = deleted_drawing_idx {
807            self.remove_unreferenced_drawing(drawing_idx);
808        }
809        self.remove_unreferenced_unknown_targets(&deleted_direct_targets);
810        self.rebuild_sheet_index();
811        Ok(())
812    }
813
814    fn remove_unreferenced_unknown_targets(&mut self, deleted_targets: &[String]) {
815        for target in deleted_targets {
816            let still_referenced =
817                self.worksheet_rels.iter().any(|(sheet_idx, rels)| {
818                    let sheet_path = self.sheet_part_path(*sheet_idx);
819                    rels.relationships.iter().any(|relationship| {
820                        relationship.target_mode.as_deref() != Some("External")
821                            && crate::workbook_paths::resolve_relationship_target(
822                                &sheet_path,
823                                &relationship.target,
824                            ) == *target
825                    })
826                }) || self.workbook_rels.relationships.iter().any(|relationship| {
827                    relationship.target_mode.as_deref() != Some("External")
828                        && crate::workbook_paths::resolve_relationship_target(
829                            "xl/workbook.xml",
830                            &relationship.target,
831                        ) == *target
832                }) || self.package_rels.relationships.iter().any(|relationship| {
833                    relationship.target_mode.as_deref() != Some("External")
834                        && crate::workbook_paths::resolve_relationship_target(
835                            "",
836                            &relationship.target,
837                        ) == *target
838                }) || self.drawing_rels.iter().any(|(drawing_idx, rels)| {
839                    let drawing_path = &self.drawings[*drawing_idx].0;
840                    rels.relationships.iter().any(|relationship| {
841                        relationship.target_mode.as_deref() != Some("External")
842                            && crate::workbook_paths::resolve_relationship_target(
843                                drawing_path,
844                                &relationship.target,
845                            ) == *target
846                    })
847                });
848            if still_referenced {
849                continue;
850            }
851            self.unknown_parts.retain(|(path, _)| path != target);
852            self.content_types
853                .overrides
854                .retain(|entry| entry.part_name != format!("/{target}"));
855        }
856    }
857
858    fn hydrate_lifecycle_parts_for_delete(&mut self, deleted_sheet_idx: usize) -> Result<()> {
859        use crate::workbook::aux::AuxCategory;
860
861        let parse_entries = |category, validate: &dyn Fn(&str) -> bool| -> Result<()> {
862            if let Some(entries) = self.deferred_parts.entries(category) {
863                for (path, bytes) in entries {
864                    let xml = std::str::from_utf8(bytes)
865                        .map_err(|error| Error::XmlParse(format!("{path}: {error}")))?;
866                    if !validate(xml) {
867                        return Err(Error::XmlDeserialize(format!(
868                            "cannot hydrate lifecycle part '{path}'"
869                        )));
870                    }
871                }
872            }
873            Ok(())
874        };
875        parse_entries(AuxCategory::Comments, &|xml| {
876            quick_xml::de::from_str::<Comments>(xml).is_ok()
877        })?;
878        parse_entries(AuxCategory::Tables, &|xml| {
879            sheetkit_xml::table::parse_table_xml(xml).is_ok()
880        })?;
881        parse_entries(AuxCategory::ThreadedComments, &|xml| {
882            quick_xml::de::from_str::<sheetkit_xml::threaded_comment::ThreadedComments>(xml).is_ok()
883        })?;
884        parse_entries(AuxCategory::PersonList, &|xml| {
885            quick_xml::de::from_str::<sheetkit_xml::threaded_comment::PersonList>(xml).is_ok()
886        })?;
887        let owned_drawing = self.owned_drawing_path(deleted_sheet_idx);
888        if let Some(drawing_path) = owned_drawing.as_deref() {
889            let drawing_rels_path = relationship_part_path(drawing_path);
890            for (path, bytes) in self
891                .deferred_parts
892                .entries(AuxCategory::Drawings)
893                .into_iter()
894                .flatten()
895                .filter(|(path, _)| path == drawing_path)
896            {
897                let xml = std::str::from_utf8(bytes)
898                    .map_err(|error| Error::XmlParse(format!("{path}: {error}")))?;
899                quick_xml::de::from_str::<WsDr>(xml).map_err(|error| {
900                    Error::XmlDeserialize(format!(
901                        "cannot hydrate lifecycle part '{path}': {error}"
902                    ))
903                })?;
904            }
905            for (path, bytes) in self
906                .deferred_parts
907                .entries(AuxCategory::DrawingRels)
908                .into_iter()
909                .flatten()
910                .filter(|(path, _)| path == &drawing_rels_path)
911            {
912                let xml = std::str::from_utf8(bytes)
913                    .map_err(|error| Error::XmlParse(format!("{path}: {error}")))?;
914                quick_xml::de::from_str::<Relationships>(xml).map_err(|error| {
915                    Error::XmlDeserialize(format!(
916                        "cannot hydrate lifecycle part '{path}': {error}"
917                    ))
918                })?;
919            }
920        }
921
922        let comment_entries = self.deferred_parts.take(AuxCategory::Comments);
923        for (path, bytes) in comment_entries {
924            let xml = std::str::from_utf8(&bytes)
925                .map_err(|error| Error::XmlParse(format!("{path}: {error}")))?;
926            let comments: Comments = quick_xml::de::from_str(xml)
927                .map_err(|error| Error::XmlDeserialize(format!("{path}: {error}")))?;
928            if let Some(sheet_idx) = self.find_sheet_for_owned_rel_path(rel_types::COMMENTS, &path)
929            {
930                self.sheet_comments[sheet_idx] = Some(comments);
931            }
932        }
933        let vml_entries = self.deferred_parts.take(AuxCategory::Vml);
934        for (path, bytes) in vml_entries {
935            if let Some(sheet_idx) =
936                self.find_sheet_for_owned_rel_path(rel_types::VML_DRAWING, &path)
937            {
938                self.sheet_vml[sheet_idx] = Some(bytes);
939            }
940        }
941        if !self.deferred_parts.is_empty() {
942            self.deferred_parts.mark_dirty(AuxCategory::Comments);
943            self.deferred_parts.mark_dirty(AuxCategory::Vml);
944        }
945        self.hydrate_tables();
946        self.hydrate_threaded_comments();
947        self.hydrate_drawings();
948        Ok(())
949    }
950
951    fn find_sheet_for_owned_rel_path(&self, rel_type: &str, part_path: &str) -> Option<usize> {
952        self.worksheet_rels.iter().find_map(|(sheet_idx, rels)| {
953            rels.relationships
954                .iter()
955                .any(|relationship| {
956                    relationship.rel_type == rel_type
957                        && crate::workbook_paths::resolve_relationship_target(
958                            &self.sheet_part_path(*sheet_idx),
959                            &relationship.target,
960                        ) == part_path
961                })
962                .then_some(*sheet_idx)
963        })
964    }
965
966    /// Materialize only the deferred closure owned by a sheet being copied.
967    ///
968    /// This deliberately does not use the broad lazy loaders: a workbook can
969    /// contain unrelated malformed or opaque deferred parts which must remain
970    /// byte-for-byte pass-through when copying a different sheet.
971    fn hydrate_owned_parts_for_copy(&mut self, sheet_idx: usize) -> Result<()> {
972        use crate::workbook::aux::AuxCategory;
973
974        let sheet_path = self.sheet_part_path(sheet_idx);
975        let rels = self
976            .worksheet_rels
977            .get(&sheet_idx)
978            .cloned()
979            .unwrap_or_else(crate::workbook_paths::default_relationships);
980        let target = |kind: &str| {
981            rels.relationships
982                .iter()
983                .filter(move |rel| rel.rel_type == kind)
984                .map(|rel| resolve_relationship_target(&sheet_path, &rel.target))
985                .collect::<Vec<_>>()
986        };
987
988        // Validate every fallible parse before changing any workbook state.
989        let comments = target(rel_types::COMMENTS);
990        let vml = target(rel_types::VML_DRAWING);
991        let tables = target(rel_types::TABLE);
992        let threaded = target(sheetkit_xml::threaded_comment::REL_TYPE_THREADED_COMMENT);
993        let drawings = target(rel_types::DRAWING);
994        for (paths, category, parse) in [
995            (&comments, AuxCategory::Comments, 0u8),
996            (&tables, AuxCategory::Tables, 1),
997            (&threaded, AuxCategory::ThreadedComments, 2),
998            (&drawings, AuxCategory::Drawings, 3),
999        ] {
1000            for path in paths {
1001                let Some(bytes) = self.deferred_parts.get_path(category, path) else {
1002                    continue;
1003                };
1004                let xml = std::str::from_utf8(bytes)
1005                    .map_err(|error| Error::XmlParse(format!("{path}: {error}")))?;
1006                let valid =
1007                    match parse {
1008                        0 => quick_xml::de::from_str::<Comments>(xml).is_ok(),
1009                        1 => sheetkit_xml::table::parse_table_xml(xml).is_ok(),
1010                        2 => quick_xml::de::from_str::<
1011                            sheetkit_xml::threaded_comment::ThreadedComments,
1012                        >(xml)
1013                        .is_ok(),
1014                        _ => quick_xml::de::from_str::<WsDr>(xml).is_ok(),
1015                    };
1016                if !valid {
1017                    return Err(Error::XmlDeserialize(format!(
1018                        "cannot hydrate copied sheet part '{path}'"
1019                    )));
1020                }
1021            }
1022        }
1023        let mut drawing_rels = Vec::new();
1024        for drawing in &drawings {
1025            let path = relationship_part_path(drawing);
1026            if let Some(bytes) = self
1027                .deferred_parts
1028                .get_path(AuxCategory::DrawingRels, &path)
1029            {
1030                let xml = std::str::from_utf8(bytes)
1031                    .map_err(|error| Error::XmlParse(format!("{path}: {error}")))?;
1032                let parsed = quick_xml::de::from_str::<Relationships>(xml)
1033                    .map_err(|error| Error::XmlDeserialize(format!("{path}: {error}")))?;
1034                drawing_rels.push((drawing.clone(), path, parsed));
1035            }
1036        }
1037
1038        for path in comments {
1039            if let Some(bytes) = self
1040                .deferred_parts
1041                .remove_path(AuxCategory::Comments, &path)
1042            {
1043                let xml = std::str::from_utf8(&bytes)
1044                    .map_err(|error| Error::XmlParse(error.to_string()))?;
1045                self.sheet_comments[sheet_idx] = Some(
1046                    quick_xml::de::from_str(xml)
1047                        .map_err(|error| Error::XmlDeserialize(error.to_string()))?,
1048                );
1049            }
1050        }
1051        for path in tables {
1052            if let Some(bytes) = self.deferred_parts.remove_path(AuxCategory::Tables, &path) {
1053                let xml = std::str::from_utf8(&bytes)
1054                    .map_err(|error| Error::XmlParse(error.to_string()))?;
1055                self.tables.push((
1056                    path,
1057                    sheetkit_xml::table::parse_table_xml(xml)
1058                        .map_err(|error| Error::XmlDeserialize(error.to_string()))?,
1059                    sheet_idx,
1060                ));
1061            }
1062        }
1063        for path in threaded {
1064            if let Some(bytes) = self
1065                .deferred_parts
1066                .remove_path(AuxCategory::ThreadedComments, &path)
1067            {
1068                let xml = std::str::from_utf8(&bytes)
1069                    .map_err(|error| Error::XmlParse(error.to_string()))?;
1070                self.sheet_threaded_comments[sheet_idx] = Some(
1071                    quick_xml::de::from_str(xml)
1072                        .map_err(|error| Error::XmlDeserialize(error.to_string()))?,
1073                );
1074            }
1075        }
1076        for path in vml {
1077            if let Some(bytes) = self.deferred_parts.remove_path(AuxCategory::Vml, &path) {
1078                let controls =
1079                    crate::control::parse_form_control_configs(&String::from_utf8_lossy(&bytes));
1080                self.sheet_vml[sheet_idx] = Some(bytes);
1081                if self.sheet_form_controls[sheet_idx].is_empty() && !controls.is_empty() {
1082                    self.sheet_form_controls[sheet_idx] = controls;
1083                }
1084            }
1085        }
1086        for drawing_path in drawings {
1087            if let Some(bytes) = self
1088                .deferred_parts
1089                .remove_path(AuxCategory::Drawings, &drawing_path)
1090            {
1091                let xml = std::str::from_utf8(&bytes)
1092                    .map_err(|error| Error::XmlParse(error.to_string()))?;
1093                let drawing = quick_xml::de::from_str(xml)
1094                    .map_err(|error| Error::XmlDeserialize(error.to_string()))?;
1095                self.remember_raw_graph_part(drawing_path.clone(), bytes);
1096                let idx = self.drawings.len();
1097                self.drawings.push((drawing_path.clone(), drawing));
1098                self.worksheet_drawings.insert(sheet_idx, idx);
1099            }
1100        }
1101        for (drawing_path, rels_path, rels) in drawing_rels {
1102            if self
1103                .deferred_parts
1104                .remove_path(AuxCategory::DrawingRels, &rels_path)
1105                .is_some()
1106            {
1107                if let Some(idx) = self
1108                    .drawings
1109                    .iter()
1110                    .position(|(path, _)| path == &drawing_path)
1111                {
1112                    self.drawing_rels.insert(idx, rels.clone());
1113                    for relationship in &rels.relationships {
1114                        let path = resolve_relationship_target(&drawing_path, &relationship.target);
1115                        if relationship.rel_type == rel_types::IMAGE {
1116                            if let Some(bytes) =
1117                                self.deferred_parts.remove_path(AuxCategory::Images, &path)
1118                            {
1119                                self.images.push((path, bytes));
1120                            }
1121                        } else if relationship.rel_type == rel_types::CHART {
1122                            if let Some(bytes) =
1123                                self.deferred_parts.remove_path(AuxCategory::Charts, &path)
1124                            {
1125                                self.remember_raw_graph_part(path.clone(), bytes.clone());
1126                                match quick_xml::de::from_reader::<_, ChartSpace>(bytes.as_slice())
1127                                {
1128                                    Ok(chart) => self.charts.push((path, chart)),
1129                                    Err(_) => self.raw_charts.push((path, bytes)),
1130                                }
1131                            }
1132                        }
1133                    }
1134                }
1135            }
1136        }
1137        Ok(())
1138    }
1139
1140    fn remove_unreferenced_drawing(&mut self, drawing_idx: usize) {
1141        if self
1142            .worksheet_drawings
1143            .values()
1144            .any(|existing_idx| *existing_idx == drawing_idx)
1145        {
1146            return;
1147        }
1148        let Some((drawing_path, _)) = self.drawings.get(drawing_idx) else {
1149            return;
1150        };
1151        let drawing_path = drawing_path.clone();
1152        let removed_chart_paths: Vec<String> = self
1153            .drawing_rels
1154            .get(&drawing_idx)
1155            .into_iter()
1156            .flat_map(|rels| &rels.relationships)
1157            .filter(|relationship| relationship.rel_type == rel_types::CHART)
1158            .map(|relationship| {
1159                crate::workbook_paths::resolve_relationship_target(
1160                    &drawing_path,
1161                    &relationship.target,
1162                )
1163            })
1164            .collect();
1165        let removed_image_paths: Vec<String> = self
1166            .drawing_rels
1167            .get(&drawing_idx)
1168            .into_iter()
1169            .flat_map(|rels| &rels.relationships)
1170            .filter(|relationship| relationship.rel_type == rel_types::IMAGE)
1171            .map(|relationship| {
1172                crate::workbook_paths::resolve_relationship_target(
1173                    &drawing_path,
1174                    &relationship.target,
1175                )
1176            })
1177            .collect();
1178
1179        self.drawings.remove(drawing_idx);
1180        self.drawing_rels.remove(&drawing_idx);
1181        self.remove_graph_part(&drawing_path);
1182        self.remove_graph_part(&relationship_part_path(&drawing_path));
1183        self.drawing_rels = self
1184            .drawing_rels
1185            .drain()
1186            .map(|(idx, rels)| {
1187                if idx > drawing_idx {
1188                    (idx - 1, rels)
1189                } else {
1190                    (idx, rels)
1191                }
1192            })
1193            .collect();
1194        for existing_idx in self.worksheet_drawings.values_mut() {
1195            if *existing_idx > drawing_idx {
1196                *existing_idx -= 1;
1197            }
1198        }
1199        self.content_types
1200            .overrides
1201            .retain(|entry| entry.part_name != format!("/{drawing_path}"));
1202
1203        for chart_path in removed_chart_paths {
1204            let still_referenced = self.drawing_rels.iter().any(|(idx, rels)| {
1205                let owner_path = &self.drawings[*idx].0;
1206                rels.relationships.iter().any(|relationship| {
1207                    relationship.rel_type == rel_types::CHART
1208                        && crate::workbook_paths::resolve_relationship_target(
1209                            owner_path,
1210                            &relationship.target,
1211                        ) == chart_path
1212                })
1213            });
1214            if !still_referenced {
1215                self.charts.retain(|(path, _)| path != &chart_path);
1216                self.raw_charts.retain(|(path, _)| path != &chart_path);
1217                self.remove_graph_part(&chart_path);
1218                self.content_types
1219                    .overrides
1220                    .retain(|entry| entry.part_name != format!("/{chart_path}"));
1221            }
1222        }
1223        for image_path in removed_image_paths {
1224            let still_referenced = self.drawing_rels.iter().any(|(idx, rels)| {
1225                let owner_path = &self.drawings[*idx].0;
1226                rels.relationships.iter().any(|relationship| {
1227                    relationship.rel_type == rel_types::IMAGE
1228                        && crate::workbook_paths::resolve_relationship_target(
1229                            owner_path,
1230                            &relationship.target,
1231                        ) == image_path
1232                })
1233            });
1234            if !still_referenced {
1235                self.images.retain(|(path, _)| path != &image_path);
1236            }
1237        }
1238    }
1239
1240    /// Debug assertion that all per-sheet parallel vectors have the same
1241    /// length as `worksheets`. Catching desync early prevents silent data
1242    /// corruption from mismatched indices.
1243    fn assert_parallel_vecs_in_sync(&self) {
1244        let n = self.worksheets.len();
1245        debug_assert_eq!(self.sheet_comments.len(), n, "sheet_comments desync");
1246        debug_assert_eq!(self.sheet_sparklines.len(), n, "sheet_sparklines desync");
1247        debug_assert_eq!(
1248            self.sheet_sparklines_hydrated.len(),
1249            n,
1250            "sheet_sparklines_hydrated desync"
1251        );
1252        debug_assert_eq!(self.sheet_vml.len(), n, "sheet_vml desync");
1253        debug_assert_eq!(self.raw_sheet_xml.len(), n, "raw_sheet_xml desync");
1254        debug_assert_eq!(
1255            self.raw_sheet_extensions.len(),
1256            n,
1257            "raw_sheet_extensions desync"
1258        );
1259        debug_assert_eq!(self.sheet_dirty.len(), n, "sheet_dirty desync");
1260        debug_assert_eq!(self.sheet_included.len(), n, "sheet_included desync");
1261        debug_assert_eq!(
1262            self.sheet_materialized.len(),
1263            n,
1264            "sheet_materialized desync"
1265        );
1266        debug_assert_eq!(
1267            self.sheet_package_backed.len(),
1268            n,
1269            "sheet_package_backed desync"
1270        );
1271        debug_assert_eq!(
1272            self.sheet_threaded_comments.len(),
1273            n,
1274            "sheet_threaded_comments desync"
1275        );
1276        debug_assert_eq!(
1277            self.sheet_form_controls.len(),
1278            n,
1279            "sheet_form_controls desync"
1280        );
1281        debug_assert_eq!(
1282            self.sheet_controls_dirty.len(),
1283            n,
1284            "sheet_controls_dirty desync"
1285        );
1286    }
1287
1288    /// Rename a sheet.
1289    pub fn set_sheet_name(&mut self, old_name: &str, new_name: &str) -> Result<()> {
1290        crate::sheet::rename_sheet(
1291            &mut self.workbook_xml,
1292            &mut self.worksheets,
1293            old_name,
1294            new_name,
1295        )?;
1296        self.rebuild_sheet_index();
1297        Ok(())
1298    }
1299
1300    /// Copy a sheet, returning the 0-based index of the new copy.
1301    pub fn copy_sheet(&mut self, source: &str, target: &str) -> Result<usize> {
1302        let src_idx = self.sheet_index(source)?;
1303        crate::sheet::validate_sheet_name(target)?;
1304        if self.worksheets.iter().any(|(name, _)| name == target) {
1305            return Err(Error::SheetAlreadyExists {
1306                name: target.to_string(),
1307            });
1308        }
1309        // Resolve only this sheet's owned deferred closure. This keeps lazy
1310        // siblings untouched while making the normal copy validation below
1311        // operate on complete source state.
1312        self.hydrate_owned_parts_for_copy(src_idx)?;
1313        self.hydrate_sparklines_for_sheet(src_idx);
1314        self.ensure_hydrated(src_idx)?;
1315
1316        let cloned_streamed = self
1317            .streamed_sheets
1318            .get(&src_idx)
1319            .map(crate::stream::StreamedSheetData::try_clone)
1320            .transpose()?;
1321        let cloned_worksheet = if let Some(worksheet) = self.worksheets[src_idx].1.get() {
1322            worksheet.clone()
1323        } else if let Some(raw) = self.raw_sheet_xml[src_idx].as_ref() {
1324            let xml =
1325                std::str::from_utf8(raw).map_err(|error| Error::XmlParse(error.to_string()))?;
1326            quick_xml::de::from_str(xml)
1327                .map_err(|error| Error::XmlDeserialize(error.to_string()))?
1328        } else {
1329            WorksheetXml::default()
1330        };
1331
1332        let source_rels = self
1333            .worksheet_rels
1334            .get(&src_idx)
1335            .cloned()
1336            .unwrap_or_else(crate::workbook_paths::default_relationships);
1337        validate_worksheet_relationship_ids(&cloned_worksheet, &source_rels)?;
1338        let has_rel_type = |rel_type: &str| {
1339            source_rels
1340                .relationships
1341                .iter()
1342                .any(|relationship| relationship.rel_type == rel_type)
1343        };
1344        let source_has_drawing = has_rel_type(rel_types::DRAWING);
1345        let source_has_comments = has_rel_type(rel_types::COMMENTS);
1346        let source_has_vml = has_rel_type(rel_types::VML_DRAWING);
1347        let source_has_controls = has_rel_type(rel_types::CONTROL_PROPERTIES);
1348        let source_has_tables = has_rel_type(rel_types::TABLE);
1349        let source_has_threaded =
1350            has_rel_type(sheetkit_xml::threaded_comment::REL_TYPE_THREADED_COMMENT);
1351        let occupied_aux_paths = self.occupied_part_paths();
1352        for relationship in &source_rels.relationships {
1353            let supported = relationship.rel_type == rel_types::HYPERLINK
1354                || relationship.rel_type == rel_types::DRAWING
1355                || relationship.rel_type == rel_types::COMMENTS
1356                || relationship.rel_type == rel_types::VML_DRAWING
1357                || relationship.rel_type == rel_types::CONTROL_PROPERTIES
1358                || relationship.rel_type == rel_types::TABLE
1359                || relationship.rel_type
1360                    == sheetkit_xml::threaded_comment::REL_TYPE_THREADED_COMMENT;
1361            if !supported {
1362                return Err(Error::InvalidArgument(format!(
1363                    "cannot copy unsupported worksheet relationship type '{}'",
1364                    relationship.rel_type
1365                )));
1366            }
1367            if relationship.rel_type == rel_types::HYPERLINK
1368                && relationship.target_mode.as_deref() != Some("External")
1369            {
1370                return Err(Error::InvalidArgument(
1371                    "worksheet hyperlink relationships must be external".into(),
1372                ));
1373            }
1374        }
1375
1376        let source_sheet_path = self.sheet_part_path(src_idx);
1377        let managed_rel_count = |rel_type: &str| {
1378            source_rels
1379                .relationships
1380                .iter()
1381                .filter(|relationship| relationship.rel_type == rel_type)
1382                .count()
1383        };
1384        let content_type_matches = |path: &str, content_type: &str| {
1385            self.content_types.overrides.iter().any(|entry| {
1386                entry.part_name.trim_start_matches('/') == path
1387                    && entry.content_type == content_type
1388            })
1389        };
1390        if source_has_comments {
1391            let relationship = source_rels
1392                .relationships
1393                .iter()
1394                .find(|relationship| relationship.rel_type == rel_types::COMMENTS)
1395                .unwrap();
1396            let path = crate::workbook_paths::resolve_relationship_target(
1397                &source_sheet_path,
1398                &relationship.target,
1399            );
1400            if managed_rel_count(rel_types::COMMENTS) != 1
1401                || self.sheet_comments[src_idx].is_none()
1402                || !content_type_matches(&path, mime_types::COMMENTS)
1403            {
1404                return Err(Error::InvalidArgument(
1405                    "worksheet comments relationship is unresolved".into(),
1406                ));
1407            }
1408        }
1409        if source_has_vml {
1410            let relationship = source_rels
1411                .relationships
1412                .iter()
1413                .find(|relationship| relationship.rel_type == rel_types::VML_DRAWING)
1414                .unwrap();
1415            let path = crate::workbook_paths::resolve_relationship_target(
1416                &source_sheet_path,
1417                &relationship.target,
1418            );
1419            let has_managed_vml = self.sheet_vml[src_idx].is_some()
1420                || !self.sheet_form_controls[src_idx].is_empty()
1421                || self.sheet_comments[src_idx].is_some();
1422            if managed_rel_count(rel_types::VML_DRAWING) != 1
1423                || !has_managed_vml
1424                || !occupied_aux_paths.contains(&path)
1425            {
1426                return Err(Error::InvalidArgument(
1427                    "worksheet VML relationship is unresolved".into(),
1428                ));
1429            }
1430        }
1431        if source_has_controls {
1432            let control_relationships: Vec<&Relationship> = source_rels
1433                .relationships
1434                .iter()
1435                .filter(|relationship| relationship.rel_type == rel_types::CONTROL_PROPERTIES)
1436                .collect();
1437            let all_resolved = control_relationships.iter().all(|relationship| {
1438                let path = crate::workbook_paths::resolve_relationship_target(
1439                    &source_sheet_path,
1440                    &relationship.target,
1441                );
1442                self.unknown_parts
1443                    .iter()
1444                    .any(|(unknown_path, _)| unknown_path == &path)
1445                    && content_type_matches(&path, mime_types::CONTROL_PROPERTIES)
1446            });
1447            if !all_resolved
1448                || control_relationships.len() != self.sheet_form_controls[src_idx].len()
1449            {
1450                return Err(Error::InvalidArgument(
1451                    "worksheet form-control relationships are unresolved".into(),
1452                ));
1453            }
1454        }
1455        if source_has_tables {
1456            let table_relationships: Vec<&Relationship> = source_rels
1457                .relationships
1458                .iter()
1459                .filter(|relationship| relationship.rel_type == rel_types::TABLE)
1460                .collect();
1461            let source_tables: Vec<&str> = self
1462                .tables
1463                .iter()
1464                .filter(|(_, _, sheet_idx)| *sheet_idx == src_idx)
1465                .map(|(path, _, _)| path.as_str())
1466                .collect();
1467            let all_resolved = table_relationships.iter().all(|relationship| {
1468                let path = crate::workbook_paths::resolve_relationship_target(
1469                    &source_sheet_path,
1470                    &relationship.target,
1471                );
1472                source_tables.contains(&path.as_str())
1473                    && content_type_matches(&path, mime_types::TABLE)
1474            });
1475            if !all_resolved || table_relationships.len() != source_tables.len() {
1476                return Err(Error::InvalidArgument(
1477                    "worksheet table relationship is unresolved".into(),
1478                ));
1479            }
1480        }
1481        if source_has_threaded {
1482            let relationship = source_rels
1483                .relationships
1484                .iter()
1485                .find(|relationship| {
1486                    relationship.rel_type
1487                        == sheetkit_xml::threaded_comment::REL_TYPE_THREADED_COMMENT
1488                })
1489                .unwrap();
1490            let path = crate::workbook_paths::resolve_relationship_target(
1491                &source_sheet_path,
1492                &relationship.target,
1493            );
1494            if managed_rel_count(sheetkit_xml::threaded_comment::REL_TYPE_THREADED_COMMENT) != 1
1495                || self.sheet_threaded_comments[src_idx].is_none()
1496                || !content_type_matches(
1497                    &path,
1498                    sheetkit_xml::threaded_comment::THREADED_COMMENTS_CONTENT_TYPE,
1499                )
1500            {
1501                return Err(Error::InvalidArgument(
1502                    "worksheet threaded-comment relationship is unresolved".into(),
1503                ));
1504            }
1505        }
1506        if source_has_drawing {
1507            let drawing_relationships: Vec<&Relationship> = source_rels
1508                .relationships
1509                .iter()
1510                .filter(|relationship| relationship.rel_type == rel_types::DRAWING)
1511                .collect();
1512            let mapped_drawing_path = self
1513                .worksheet_drawings
1514                .get(&src_idx)
1515                .and_then(|drawing_idx| self.drawings.get(*drawing_idx))
1516                .map(|(path, _)| path.as_str());
1517            let resolved_path = drawing_relationships.first().map(|relationship| {
1518                crate::workbook_paths::resolve_relationship_target(
1519                    &source_sheet_path,
1520                    &relationship.target,
1521                )
1522            });
1523            if drawing_relationships.len() != 1
1524                || resolved_path.as_deref() != mapped_drawing_path
1525                || !resolved_path
1526                    .as_deref()
1527                    .is_some_and(|path| content_type_matches(path, mime_types::DRAWING))
1528            {
1529                return Err(Error::InvalidArgument(
1530                    "worksheet drawing relationship is unresolved".into(),
1531                ));
1532            }
1533        }
1534
1535        let mut cloned_drawing = None;
1536        if source_has_drawing {
1537            let drawing_idx = *self.worksheet_drawings.get(&src_idx).ok_or_else(|| {
1538                Error::InvalidArgument("worksheet drawing relationship is unresolved".into())
1539            })?;
1540            let (source_drawing_path, source_drawing) =
1541                self.drawings.get(drawing_idx).ok_or_else(|| {
1542                    Error::InvalidArgument("worksheet drawing part is missing".into())
1543                })?;
1544            let new_drawing_path =
1545                next_numbered_part_path("xl/drawings/drawing", ".xml", &occupied_aux_paths);
1546            let mut new_drawing_rels =
1547                self.drawing_rels
1548                    .get(&drawing_idx)
1549                    .cloned()
1550                    .ok_or_else(|| {
1551                        Error::InvalidArgument("worksheet drawing relationships are missing".into())
1552                    })?;
1553            validate_drawing_relationship_ids(source_drawing, &new_drawing_rels)?;
1554            let mut cloned_charts = Vec::new();
1555            let mut cloned_images = Vec::new();
1556            let mut reserved_chart_paths = occupied_aux_paths.clone();
1557            let mut reserved_image_paths = occupied_aux_paths.clone();
1558            for relationship in &mut new_drawing_rels.relationships {
1559                if relationship.rel_type == rel_types::IMAGE {
1560                    let source_image_path = crate::workbook_paths::resolve_relationship_target(
1561                        source_drawing_path,
1562                        &relationship.target,
1563                    );
1564                    let (_, image_bytes) = self
1565                        .images
1566                        .iter()
1567                        .find(|(path, _)| *path == source_image_path)
1568                        .ok_or_else(|| {
1569                            Error::InvalidArgument(format!(
1570                                "drawing image target '{source_image_path}' is missing"
1571                            ))
1572                        })?;
1573                    let extension = source_image_path
1574                        .rsplit_once('.')
1575                        .map(|(_, extension)| extension)
1576                        .ok_or_else(|| {
1577                            Error::InvalidArgument(format!(
1578                                "drawing image target '{source_image_path}' has no extension"
1579                            ))
1580                        })?;
1581                    let new_image_path = next_numbered_part_path(
1582                        "xl/media/image",
1583                        &format!(".{extension}"),
1584                        &reserved_image_paths,
1585                    );
1586                    reserved_image_paths.insert(new_image_path.clone());
1587                    cloned_images.push((new_image_path.clone(), image_bytes.clone()));
1588                    relationship.target = crate::workbook_paths::relative_relationship_target(
1589                        &new_drawing_path,
1590                        &new_image_path,
1591                    );
1592                    continue;
1593                }
1594                if relationship.rel_type != rel_types::CHART {
1595                    return Err(Error::InvalidArgument(format!(
1596                        "cannot copy unsupported drawing relationship type '{}'",
1597                        relationship.rel_type
1598                    )));
1599                }
1600                let source_chart_path = crate::workbook_paths::resolve_relationship_target(
1601                    source_drawing_path,
1602                    &relationship.target,
1603                );
1604                let new_chart_path =
1605                    next_numbered_part_path("xl/charts/chart", ".xml", &reserved_chart_paths);
1606                if let Some((_, chart)) = self
1607                    .charts
1608                    .iter()
1609                    .find(|(path, _)| *path == source_chart_path)
1610                {
1611                    cloned_charts.push((new_chart_path.clone(), Some(chart.clone()), None));
1612                } else if let Some((_, raw)) = self
1613                    .raw_charts
1614                    .iter()
1615                    .find(|(path, _)| *path == source_chart_path)
1616                {
1617                    cloned_charts.push((new_chart_path.clone(), None, Some(raw.clone())));
1618                } else {
1619                    return Err(Error::InvalidArgument(format!(
1620                        "drawing chart target '{source_chart_path}' is missing"
1621                    )));
1622                }
1623                reserved_chart_paths.insert(new_chart_path.clone());
1624                relationship.target = crate::workbook_paths::relative_relationship_target(
1625                    &new_drawing_path,
1626                    &new_chart_path,
1627                );
1628            }
1629            cloned_drawing = Some((
1630                new_drawing_path,
1631                source_drawing.clone(),
1632                new_drawing_rels,
1633                cloned_charts,
1634                cloned_images,
1635            ));
1636        }
1637
1638        let max_table_id = self
1639            .tables
1640            .iter()
1641            .map(|(_, table, _)| table.id)
1642            .max()
1643            .unwrap_or(0);
1644        let mut reserved_table_paths = occupied_aux_paths.clone();
1645        let mut cloned_tables = Vec::new();
1646        let mut taken_table_names = self.taken_table_names();
1647        for (offset, (_, source_table, _)) in self
1648            .tables
1649            .iter()
1650            .filter(|(_, _, sheet_idx)| *sheet_idx == src_idx)
1651            .enumerate()
1652        {
1653            let new_path =
1654                next_numbered_part_path("xl/tables/table", ".xml", &reserved_table_paths);
1655            reserved_table_paths.insert(new_path.clone());
1656            let mut table = source_table.clone();
1657            let id_increment = u32::try_from(offset)
1658                .ok()
1659                .and_then(|offset| offset.checked_add(1))
1660                .ok_or_else(|| Error::InvalidArgument("table ID allocation overflow".into()))?;
1661            table.id = max_table_id
1662                .checked_add(id_increment)
1663                .ok_or_else(|| Error::InvalidArgument("table ID allocation overflow".into()))?;
1664            let base_name = format!("{}_Copy", table.name);
1665            let mut name = base_name.clone();
1666            let mut suffix = 2usize;
1667            while taken_table_names.contains(&name.to_lowercase()) {
1668                name = format!("{base_name}{suffix}");
1669                suffix += 1;
1670            }
1671            crate::table::validate_table_name("table name", &name)?;
1672            taken_table_names.insert(name.to_lowercase());
1673            table.name = name.clone();
1674            table.display_name = name;
1675            cloned_tables.push((new_path, table));
1676        }
1677
1678        let idx = crate::sheet::add_sheet_with_occupied_paths(
1679            &mut self.workbook_xml,
1680            &mut self.workbook_rels,
1681            &mut self.content_types,
1682            &mut self.worksheets,
1683            target,
1684            cloned_worksheet,
1685            occupied_aux_paths,
1686        )?;
1687        self.sheet_comments
1688            .push(self.sheet_comments[src_idx].clone());
1689        self.sheet_sparklines
1690            .push(self.sheet_sparklines[src_idx].clone());
1691        self.sheet_sparklines_hydrated.push(true);
1692        self.sheet_vml.push(
1693            self.sheet_vml[src_idx]
1694                .as_deref()
1695                .and_then(crate::control::strip_form_control_shapes_from_vml),
1696        );
1697        self.raw_sheet_xml.push(None);
1698        self.raw_sheet_extensions
1699            .push(self.raw_sheet_extensions[src_idx].clone());
1700        self.sheet_dirty.push(true);
1701        self.sheet_included.push(true);
1702        self.sheet_materialized.push(true);
1703        self.sheet_package_backed.push(false);
1704        let mut occupied_thread_ids: std::collections::HashSet<String> = self
1705            .sheet_threaded_comments
1706            .iter()
1707            .flatten()
1708            .flat_map(|threaded| threaded.comments.iter().map(|comment| comment.id.clone()))
1709            .collect();
1710        self.sheet_threaded_comments
1711            .push(
1712                self.sheet_threaded_comments[src_idx]
1713                    .as_ref()
1714                    .map(|threaded| {
1715                        clone_threaded_comments_with_new_ids(threaded, &mut occupied_thread_ids)
1716                    }),
1717            );
1718        self.sheet_form_controls
1719            .push(self.sheet_form_controls[src_idx].clone());
1720        self.sheet_controls_dirty.push(true);
1721        if let Some(cloned) = cloned_streamed {
1722            self.streamed_sheets.insert(idx, cloned);
1723        }
1724
1725        let mut copied_rels = source_rels;
1726        copied_rels.relationships.retain(|relationship| {
1727            relationship.rel_type == rel_types::HYPERLINK
1728                || relationship.rel_type == rel_types::DRAWING
1729        });
1730        if let Some((drawing_path, drawing, drawing_rels, cloned_charts, cloned_images)) =
1731            cloned_drawing
1732        {
1733            let drawing_idx = self.drawings.len();
1734            for relationship in &mut copied_rels.relationships {
1735                if relationship.rel_type == rel_types::DRAWING {
1736                    relationship.target = crate::workbook_paths::relative_relationship_target(
1737                        &self.sheet_part_path(idx),
1738                        &drawing_path,
1739                    );
1740                }
1741            }
1742            self.drawings.push((drawing_path.clone(), drawing));
1743            self.mark_graph_part_dirty(&drawing_path);
1744            self.worksheet_drawings.insert(idx, drawing_idx);
1745            self.drawing_rels.insert(drawing_idx, drawing_rels);
1746            self.mark_drawing_relationships_dirty(drawing_idx);
1747            self.content_types.overrides.push(ContentTypeOverride {
1748                part_name: format!("/{drawing_path}"),
1749                content_type: mime_types::DRAWING.to_string(),
1750            });
1751            for (path, typed, raw) in cloned_charts {
1752                self.content_types.overrides.push(ContentTypeOverride {
1753                    part_name: format!("/{path}"),
1754                    content_type: mime_types::CHART.to_string(),
1755                });
1756                if let Some(chart) = typed {
1757                    self.mark_graph_part_dirty(&path);
1758                    self.charts.push((path, chart));
1759                } else if let Some(bytes) = raw {
1760                    self.mark_graph_part_dirty(&path);
1761                    self.raw_charts.push((path, bytes));
1762                }
1763            }
1764            self.images.extend(cloned_images);
1765        }
1766        if !copied_rels.relationships.is_empty() {
1767            self.worksheet_rels.insert(idx, copied_rels);
1768        }
1769        for (path, table) in cloned_tables {
1770            self.tables.push((path, table, idx));
1771        }
1772        self.rebuild_sheet_index();
1773        Ok(idx)
1774    }
1775
1776    /// Get a sheet's 0-based index by name. Returns `None` if not found.
1777    pub fn get_sheet_index(&self, name: &str) -> Option<usize> {
1778        crate::sheet::find_sheet_index(&self.worksheets, name)
1779    }
1780
1781    /// Get the name of the active sheet.
1782    pub fn get_active_sheet(&self) -> &str {
1783        let idx = crate::sheet::active_sheet_index(&self.workbook_xml);
1784        self.worksheets
1785            .get(idx)
1786            .map(|(n, _)| n.as_str())
1787            .or_else(|| self.worksheets.first().map(|(n, _)| n.as_str()))
1788            .unwrap_or("")
1789    }
1790
1791    /// Set the active sheet by name.
1792    pub fn set_active_sheet(&mut self, name: &str) -> Result<()> {
1793        let idx = crate::sheet::find_sheet_index(&self.worksheets, name).ok_or_else(|| {
1794            Error::SheetNotFound {
1795                name: name.to_string(),
1796            }
1797        })?;
1798        crate::sheet::set_active_sheet_index(&mut self.workbook_xml, idx as u32);
1799        Ok(())
1800    }
1801
1802    /// Create a [`StreamWriter`](crate::stream::StreamWriter) for a new sheet.
1803    ///
1804    /// The sheet will be added to the workbook when the StreamWriter is applied
1805    /// via [`apply_stream_writer`](Self::apply_stream_writer).
1806    pub fn new_stream_writer(&self, sheet_name: &str) -> Result<crate::stream::StreamWriter> {
1807        self.new_stream_writer_with_limits(sheet_name, crate::save::StreamLimits::default())
1808    }
1809
1810    /// Create a [`StreamWriter`](crate::stream::StreamWriter) with explicit
1811    /// finite row, cell, XML, and output limits.
1812    pub fn new_stream_writer_with_limits(
1813        &self,
1814        sheet_name: &str,
1815        limits: crate::save::StreamLimits,
1816    ) -> Result<crate::stream::StreamWriter> {
1817        crate::sheet::validate_sheet_name(sheet_name)?;
1818        if self.worksheets.iter().any(|(n, _)| n == sheet_name) {
1819            return Err(Error::SheetAlreadyExists {
1820                name: sheet_name.to_string(),
1821            });
1822        }
1823        crate::stream::StreamWriter::try_new_with_limits(sheet_name, limits)
1824    }
1825
1826    /// Apply a completed [`StreamWriter`](crate::stream::StreamWriter) to the
1827    /// workbook, adding it as a new sheet.
1828    ///
1829    /// The streamed row data stays on disk (in a temp file) and is written
1830    /// directly to the ZIP archive during save, keeping memory usage constant
1831    /// regardless of the number of rows.
1832    ///
1833    /// **Note:** Cell values in streamed sheets cannot be read back via
1834    /// [`get_cell_value`](Self::get_cell_value) before saving. Save the
1835    /// workbook and reopen it to read the data.
1836    ///
1837    /// Returns the 0-based index of the new sheet.
1838    pub fn apply_stream_writer(&mut self, writer: crate::stream::StreamWriter) -> Result<usize> {
1839        let (sheet_name, streamed_data) = writer.into_streamed_data()?;
1840
1841        // Add an empty WorksheetXml placeholder for sheet management
1842        // (sheet names, indices, metadata). The actual data lives in the
1843        // temp file and is streamed to the ZIP during save.
1844        let occupied_paths = self.occupied_part_paths();
1845        let idx = crate::sheet::add_sheet_with_occupied_paths(
1846            &mut self.workbook_xml,
1847            &mut self.workbook_rels,
1848            &mut self.content_types,
1849            &mut self.worksheets,
1850            &sheet_name,
1851            WorksheetXml::default(),
1852            occupied_paths,
1853        )?;
1854        self.append_empty_sheet_state();
1855
1856        // Store the streamed data for use during save.
1857        self.streamed_sheets.insert(idx, streamed_data);
1858
1859        self.rebuild_sheet_index();
1860        Ok(idx)
1861    }
1862
1863    /// Insert `count` empty rows starting at `start_row` in the named sheet.
1864    pub fn insert_rows(&mut self, sheet: &str, start_row: u32, count: u32) -> Result<()> {
1865        let sheet_idx = self.sheet_index(sheet)?;
1866        if count == 0 {
1867            return Ok(());
1868        }
1869        self.preflight_structural_target(sheet_idx, |ws| {
1870            crate::row::insert_rows(ws, start_row, count)
1871        })?;
1872        let edit = StructuralShift::InsertRows {
1873            start: start_row,
1874            count,
1875        };
1876        self.prepare_reference_shift(sheet_idx, edit)?;
1877        {
1878            let ws = self.worksheet_mut_by_index(sheet_idx)?;
1879            crate::row::insert_rows(ws, start_row, count)?;
1880        }
1881        self.apply_reference_shift_for_sheet(sheet_idx, edit)
1882    }
1883
1884    /// Remove a single row from the named sheet, shifting rows below it up.
1885    ///
1886    /// Formula references to the removed row become `#REF!`, ranges that end
1887    /// or start in it shrink, and sqref-based entries (merges, validations,
1888    /// conditional formats, hyperlinks, comments, page breaks) that lie only in
1889    /// the removed row are dropped.
1890    pub fn remove_row(&mut self, sheet: &str, row: u32) -> Result<()> {
1891        let sheet_idx = self.sheet_index(sheet)?;
1892        self.preflight_structural_target(sheet_idx, |ws| crate::row::remove_row(ws, row))?;
1893        let edit = StructuralShift::RemoveRows {
1894            start: row,
1895            count: 1,
1896        };
1897        self.prepare_reference_shift(sheet_idx, edit)?;
1898        {
1899            let ws = self.worksheet_mut_by_index(sheet_idx)?;
1900            crate::row::remove_row(ws, row)?;
1901        }
1902        self.apply_reference_shift_for_sheet(sheet_idx, edit)
1903    }
1904
1905    /// Duplicate a row, inserting the copy directly below.
1906    pub fn duplicate_row(&mut self, sheet: &str, row: u32) -> Result<()> {
1907        let sheet_idx = self.sheet_index(sheet)?;
1908        let target_row = row.checked_add(1).ok_or(Error::InvalidRowNumber(row))?;
1909        self.preflight_structural_target(sheet_idx, |ws| crate::row::duplicate_row(ws, row))?;
1910        self.preflight_duplicate_formula_copy(sheet_idx, row)?;
1911        let edit = StructuralShift::InsertRows {
1912            start: target_row,
1913            count: 1,
1914        };
1915        self.prepare_reference_shift(sheet_idx, edit)?;
1916        {
1917            let ws = self.worksheet_mut_by_index(sheet_idx)?;
1918            crate::row::duplicate_row(ws, row)?;
1919        }
1920        let duplicated_formulas = self.take_duplicated_row_formulas(sheet_idx, target_row)?;
1921        self.apply_reference_shift_for_sheet(sheet_idx, edit)?;
1922        self.restore_duplicated_row_formulas(sheet_idx, target_row, duplicated_formulas)
1923    }
1924
1925    /// Set the height of a row in points.
1926    pub fn set_row_height(&mut self, sheet: &str, row: u32, height: f64) -> Result<()> {
1927        let ws = self.worksheet_mut(sheet)?;
1928        crate::row::set_row_height(ws, row, height)
1929    }
1930
1931    /// Get the height of a row.
1932    pub fn get_row_height(&self, sheet: &str, row: u32) -> Result<Option<f64>> {
1933        let ws = self.worksheet_ref(sheet)?;
1934        Ok(crate::row::get_row_height(ws, row))
1935    }
1936
1937    /// Set the visibility of a row.
1938    pub fn set_row_visible(&mut self, sheet: &str, row: u32, visible: bool) -> Result<()> {
1939        let ws = self.worksheet_mut(sheet)?;
1940        crate::row::set_row_visible(ws, row, visible)
1941    }
1942
1943    /// Get the visibility of a row. Returns true if visible (not hidden).
1944    pub fn get_row_visible(&self, sheet: &str, row: u32) -> Result<bool> {
1945        let ws = self.worksheet_ref(sheet)?;
1946        Ok(crate::row::get_row_visible(ws, row))
1947    }
1948
1949    /// Set the outline level of a row.
1950    pub fn set_row_outline_level(&mut self, sheet: &str, row: u32, level: u8) -> Result<()> {
1951        let ws = self.worksheet_mut(sheet)?;
1952        crate::row::set_row_outline_level(ws, row, level)
1953    }
1954
1955    /// Get the outline level of a row. Returns 0 if not set.
1956    pub fn get_row_outline_level(&self, sheet: &str, row: u32) -> Result<u8> {
1957        let ws = self.worksheet_ref(sheet)?;
1958        Ok(crate::row::get_row_outline_level(ws, row))
1959    }
1960
1961    /// Set the style for an entire row.
1962    ///
1963    /// The `style_id` must be a valid index in cellXfs (returned by `add_style`).
1964    pub fn set_row_style(&mut self, sheet: &str, row: u32, style_id: u32) -> Result<()> {
1965        if style_id as usize >= self.stylesheet.cell_xfs.xfs.len() {
1966            return Err(Error::StyleNotFound { id: style_id });
1967        }
1968        let ws = self.worksheet_mut(sheet)?;
1969        crate::row::set_row_style(ws, row, style_id)
1970    }
1971
1972    /// Get the style ID for a row. Returns 0 (default) if not set.
1973    pub fn get_row_style(&self, sheet: &str, row: u32) -> Result<u32> {
1974        let ws = self.worksheet_ref(sheet)?;
1975        Ok(crate::row::get_row_style(ws, row))
1976    }
1977
1978    /// Get all rows with their data from a sheet.
1979    ///
1980    /// Returns a Vec of `(row_number, Vec<(column_number, CellValue)>)` tuples.
1981    /// Column numbers are 1-based (A=1, B=2, ...). Only rows that contain at
1982    /// least one cell are included (sparse).
1983    #[allow(clippy::type_complexity)]
1984    pub fn get_rows(&self, sheet: &str) -> Result<Vec<(u32, Vec<(u32, CellValue)>)>> {
1985        self.get_rows_with_limits(sheet, crate::traversal::TraversalLimits::default())
1986    }
1987
1988    /// Gets sparse rows with explicit finite materialization limits.
1989    #[allow(clippy::type_complexity)]
1990    pub fn get_rows_with_limits(
1991        &self,
1992        sheet: &str,
1993        limits: crate::traversal::TraversalLimits,
1994    ) -> Result<Vec<(u32, Vec<(u32, CellValue)>)>> {
1995        let ws = self.worksheet_ref(sheet)?;
1996        let style_is_date = self.computed_style_is_date();
1997        crate::row::get_rows_with_limits(ws, &self.sst_runtime, &style_is_date, limits)
1998    }
1999
2000    /// Get all columns with their data from a sheet.
2001    ///
2002    /// Returns a Vec of `(column_name, Vec<(row_number, CellValue)>)` tuples.
2003    /// Only columns that have data are included (sparse).
2004    #[allow(clippy::type_complexity)]
2005    pub fn get_cols(&self, sheet: &str) -> Result<Vec<(String, Vec<(u32, CellValue)>)>> {
2006        self.get_cols_with_limits(sheet, crate::traversal::TraversalLimits::default())
2007    }
2008
2009    /// Gets sparse columns with explicit finite materialization limits.
2010    #[allow(clippy::type_complexity)]
2011    pub fn get_cols_with_limits(
2012        &self,
2013        sheet: &str,
2014        limits: crate::traversal::TraversalLimits,
2015    ) -> Result<Vec<(String, Vec<(u32, CellValue)>)>> {
2016        let ws = self.worksheet_ref(sheet)?;
2017        let style_is_date = self.computed_style_is_date();
2018        crate::col::get_cols_with_limits(ws, &self.sst_runtime, &style_is_date, limits)
2019    }
2020
2021    /// Set the width of a column.
2022    pub fn set_col_width(&mut self, sheet: &str, col: &str, width: f64) -> Result<()> {
2023        let ws = self.worksheet_mut(sheet)?;
2024        crate::col::set_col_width(ws, col, width)
2025    }
2026
2027    /// Get the width of a column.
2028    pub fn get_col_width(&self, sheet: &str, col: &str) -> Result<Option<f64>> {
2029        let ws = self.worksheet_ref(sheet)?;
2030        Ok(crate::col::get_col_width(ws, col))
2031    }
2032
2033    /// Set the visibility of a column.
2034    pub fn set_col_visible(&mut self, sheet: &str, col: &str, visible: bool) -> Result<()> {
2035        let ws = self.worksheet_mut(sheet)?;
2036        crate::col::set_col_visible(ws, col, visible)
2037    }
2038
2039    /// Get the visibility of a column. Returns true if visible (not hidden).
2040    pub fn get_col_visible(&self, sheet: &str, col: &str) -> Result<bool> {
2041        let ws = self.worksheet_ref(sheet)?;
2042        crate::col::get_col_visible(ws, col)
2043    }
2044
2045    /// Set the outline level of a column.
2046    pub fn set_col_outline_level(&mut self, sheet: &str, col: &str, level: u8) -> Result<()> {
2047        let ws = self.worksheet_mut(sheet)?;
2048        crate::col::set_col_outline_level(ws, col, level)
2049    }
2050
2051    /// Get the outline level of a column. Returns 0 if not set.
2052    pub fn get_col_outline_level(&self, sheet: &str, col: &str) -> Result<u8> {
2053        let ws = self.worksheet_ref(sheet)?;
2054        crate::col::get_col_outline_level(ws, col)
2055    }
2056
2057    /// Set the style for an entire column.
2058    ///
2059    /// The `style_id` must be a valid index in cellXfs (returned by `add_style`).
2060    pub fn set_col_style(&mut self, sheet: &str, col: &str, style_id: u32) -> Result<()> {
2061        if style_id as usize >= self.stylesheet.cell_xfs.xfs.len() {
2062            return Err(Error::StyleNotFound { id: style_id });
2063        }
2064        let ws = self.worksheet_mut(sheet)?;
2065        crate::col::set_col_style(ws, col, style_id)
2066    }
2067
2068    /// Get the style ID for a column. Returns 0 (default) if not set.
2069    pub fn get_col_style(&self, sheet: &str, col: &str) -> Result<u32> {
2070        let ws = self.worksheet_ref(sheet)?;
2071        crate::col::get_col_style(ws, col)
2072    }
2073
2074    /// Insert `count` columns starting at `col` in the named sheet.
2075    pub fn insert_cols(&mut self, sheet: &str, col: &str, count: u32) -> Result<()> {
2076        let sheet_idx = self.sheet_index(sheet)?;
2077        let start_col = column_name_to_number(col)?;
2078        if count == 0 {
2079            return Ok(());
2080        }
2081        self.preflight_structural_target(sheet_idx, |ws| crate::col::insert_cols(ws, col, count))?;
2082        let edit = StructuralShift::InsertCols {
2083            start: start_col,
2084            count,
2085        };
2086        self.prepare_reference_shift(sheet_idx, edit)?;
2087        {
2088            let ws = self.worksheet_mut_by_index(sheet_idx)?;
2089            crate::col::insert_cols(ws, col, count)?;
2090        }
2091        self.apply_reference_shift_for_sheet(sheet_idx, edit)
2092    }
2093
2094    /// Remove a single column from the named sheet.
2095    ///
2096    /// References are updated like [`Workbook::remove_row`] on the column axis.
2097    pub fn remove_col(&mut self, sheet: &str, col: &str) -> Result<()> {
2098        let sheet_idx = self.sheet_index(sheet)?;
2099        let col_num = column_name_to_number(col)?;
2100        self.preflight_structural_target(sheet_idx, |ws| crate::col::remove_col(ws, col))?;
2101        let edit = StructuralShift::RemoveCols {
2102            start: col_num,
2103            count: 1,
2104        };
2105        self.prepare_reference_shift(sheet_idx, edit)?;
2106        {
2107            let ws = self.worksheet_mut_by_index(sheet_idx)?;
2108            crate::col::remove_col(ws, col)?;
2109        }
2110        self.apply_reference_shift_for_sheet(sheet_idx, edit)
2111    }
2112
2113    /// Reindex per-sheet maps after deleting a sheet.
2114    pub(crate) fn reindex_sheet_maps_after_delete(&mut self, removed_idx: usize) {
2115        self.worksheet_rels = self
2116            .worksheet_rels
2117            .iter()
2118            .filter_map(|(idx, rels)| {
2119                if *idx == removed_idx {
2120                    None
2121                } else if *idx > removed_idx {
2122                    Some((idx - 1, rels.clone()))
2123                } else {
2124                    Some((*idx, rels.clone()))
2125                }
2126            })
2127            .collect();
2128
2129        self.worksheet_drawings = self
2130            .worksheet_drawings
2131            .iter()
2132            .filter_map(|(idx, drawing_idx)| {
2133                if *idx == removed_idx {
2134                    None
2135                } else if *idx > removed_idx {
2136                    Some((idx - 1, *drawing_idx))
2137                } else {
2138                    Some((*idx, *drawing_idx))
2139                }
2140            })
2141            .collect();
2142    }
2143
2144    /// Prepare every reference-bearing worksheet part before a structural edit.
2145    ///
2146    /// A row-limited or streamed workbook cannot safely update references
2147    /// outside the materialized window, so reject it before any mutation.
2148    fn prepare_reference_shift(
2149        &mut self,
2150        target_sheet_idx: usize,
2151        edit: StructuralShift,
2152    ) -> Result<()> {
2153        if self.sheet_rows_limit.is_some() {
2154            return Err(Error::InvalidArgument(
2155                "cannot structurally edit a workbook opened with sheet_rows".into(),
2156            ));
2157        }
2158        if !self.streamed_sheets.is_empty() {
2159            return Err(Error::InvalidArgument(
2160                "cannot structurally edit a workbook containing streamed sheets".into(),
2161            ));
2162        }
2163        if !self.raw_charts.is_empty() {
2164            return Err(Error::InvalidArgument(
2165                "cannot structurally edit a workbook with raw charts".into(),
2166            ));
2167        }
2168        self.ensure_drawing_relationships_hydratable(target_sheet_idx)?;
2169        for sheet_idx in 0..self.worksheets.len() {
2170            self.hydrate_sparklines_for_sheet(sheet_idx);
2171        }
2172
2173        // Validate deferred XML without consuming passthrough bytes. A failed
2174        // edit must not turn an untouched lazy workbook into a dirty one.
2175        self.validate_deferred_drawing_and_chart_parts(target_sheet_idx, edit)?;
2176        self.validate_reference_shift(target_sheet_idx, edit)?;
2177        self.validate_deferred_comment_parts(target_sheet_idx)?;
2178        for idx in 0..self.worksheets.len() {
2179            self.ensure_hydrated(idx)?;
2180        }
2181        self.hydrate_drawings();
2182        self.hydrate_tables();
2183        self.validate_typed_chart_ownership()?;
2184        self.validate_retained_raw_graph_patches(target_sheet_idx, edit)?;
2185        self.validate_comment_shift(target_sheet_idx, edit)?;
2186        self.hydrate_comments_for_structural_edit(target_sheet_idx)?;
2187        self.hydrate_threaded_comments();
2188        Ok(())
2189    }
2190
2191    /// Lowercased names already used by tables (name and display name),
2192    /// including deferred table parts, and by defined names. These share one
2193    /// case-insensitive namespace.
2194    fn taken_table_names(&self) -> std::collections::HashSet<String> {
2195        let mut taken = std::collections::HashSet::new();
2196        for (_, table, _) in &self.tables {
2197            taken.insert(table.name.to_lowercase());
2198            taken.insert(table.display_name.to_lowercase());
2199        }
2200        if let Some(entries) = self
2201            .deferred_parts
2202            .entries(crate::workbook::aux::AuxCategory::Tables)
2203        {
2204            for (_, bytes) in entries {
2205                if let Ok(table) =
2206                    sheetkit_xml::table::parse_table_xml(&String::from_utf8_lossy(bytes))
2207                {
2208                    taken.insert(table.name.to_lowercase());
2209                    taken.insert(table.display_name.to_lowercase());
2210                }
2211            }
2212        }
2213        for defined in crate::defined_names::get_all_defined_names(&self.workbook_xml) {
2214            taken.insert(defined.name.to_lowercase());
2215        }
2216        taken
2217    }
2218
2219    /// Resolve the deferred comment, VML, and threaded-comment part paths
2220    /// owned by a sheet.
2221    fn owned_comment_part_paths(
2222        &self,
2223        sheet_idx: usize,
2224    ) -> (Vec<String>, Vec<String>, Vec<String>) {
2225        let sheet_path = self.sheet_part_path(sheet_idx);
2226        let targets = |kind: &str| -> Vec<String> {
2227            self.worksheet_rels
2228                .get(&sheet_idx)
2229                .into_iter()
2230                .flat_map(|rels| rels.relationships.iter())
2231                .filter(|rel| rel.rel_type == kind)
2232                .map(|rel| resolve_relationship_target(&sheet_path, &rel.target))
2233                .collect()
2234        };
2235        (
2236            targets(rel_types::COMMENTS),
2237            targets(rel_types::VML_DRAWING),
2238            targets(sheetkit_xml::threaded_comment::REL_TYPE_THREADED_COMMENT),
2239        )
2240    }
2241
2242    /// Reject a structural edit when a deferred comment part of the target
2243    /// sheet cannot be parsed, so its anchors cannot silently go stale.
2244    fn validate_deferred_comment_parts(&self, sheet_idx: usize) -> Result<()> {
2245        use crate::workbook::aux::AuxCategory;
2246
2247        let (comments, _, threaded) = self.owned_comment_part_paths(sheet_idx);
2248        for path in &comments {
2249            if let Some(bytes) = self.deferred_parts.get_path(AuxCategory::Comments, path) {
2250                quick_xml::de::from_str::<Comments>(&String::from_utf8_lossy(bytes))
2251                    .map_err(|error| Error::XmlDeserialize(format!("{path}: {error}")))?;
2252            }
2253        }
2254        for path in &threaded {
2255            if let Some(bytes) = self
2256                .deferred_parts
2257                .get_path(AuxCategory::ThreadedComments, path)
2258            {
2259                quick_xml::de::from_str::<sheetkit_xml::threaded_comment::ThreadedComments>(
2260                    &String::from_utf8_lossy(bytes),
2261                )
2262                .map_err(|error| Error::XmlDeserialize(format!("{path}: {error}")))?;
2263            }
2264        }
2265        Ok(())
2266    }
2267
2268    /// Move the target sheet's deferred comments and VML into memory so the
2269    /// structural edit can shift their anchors.
2270    fn hydrate_comments_for_structural_edit(&mut self, sheet_idx: usize) -> Result<()> {
2271        use crate::workbook::aux::AuxCategory;
2272
2273        let (comments, vml, _) = self.owned_comment_part_paths(sheet_idx);
2274        let mut hydrated = false;
2275        for path in comments {
2276            if let Some(bytes) = self
2277                .deferred_parts
2278                .remove_path(AuxCategory::Comments, &path)
2279            {
2280                let parsed: Comments = quick_xml::de::from_str(&String::from_utf8_lossy(&bytes))
2281                    .map_err(|error| Error::XmlDeserialize(format!("{path}: {error}")))?;
2282                if self.sheet_comments[sheet_idx].is_none() {
2283                    self.sheet_comments[sheet_idx] = Some(parsed);
2284                }
2285                hydrated = true;
2286            }
2287        }
2288        for path in vml {
2289            if let Some(bytes) = self.deferred_parts.remove_path(AuxCategory::Vml, &path) {
2290                if self.sheet_vml[sheet_idx].is_none() {
2291                    self.sheet_vml[sheet_idx] = Some(bytes);
2292                }
2293                hydrated = true;
2294            }
2295        }
2296        if hydrated {
2297            self.deferred_parts.mark_dirty(AuxCategory::Comments);
2298            self.deferred_parts.mark_dirty(AuxCategory::Vml);
2299        }
2300        Ok(())
2301    }
2302
2303    /// Reject edits that would push a comment anchor off the grid.
2304    fn validate_comment_shift(&self, sheet_idx: usize, edit: StructuralShift) -> Result<()> {
2305        use crate::workbook::aux::AuxCategory;
2306
2307        let mut anchors: Vec<String> = Vec::new();
2308        if let Some(comments) = self.sheet_comments.get(sheet_idx).and_then(Option::as_ref) {
2309            anchors.extend(
2310                comments
2311                    .comment_list
2312                    .comments
2313                    .iter()
2314                    .map(|c| c.r#ref.clone()),
2315            );
2316        }
2317        if let Some(threaded) = self
2318            .sheet_threaded_comments
2319            .get(sheet_idx)
2320            .and_then(Option::as_ref)
2321        {
2322            anchors.extend(threaded.comments.iter().map(|c| c.cell_ref.clone()));
2323        }
2324        let (comments, _, threaded) = self.owned_comment_part_paths(sheet_idx);
2325        for path in &comments {
2326            if let Some(bytes) = self.deferred_parts.get_path(AuxCategory::Comments, path) {
2327                if let Ok(parsed) =
2328                    quick_xml::de::from_str::<Comments>(&String::from_utf8_lossy(bytes))
2329                {
2330                    anchors.extend(parsed.comment_list.comments.into_iter().map(|c| c.r#ref));
2331                }
2332            }
2333        }
2334        for path in &threaded {
2335            if let Some(bytes) = self
2336                .deferred_parts
2337                .get_path(AuxCategory::ThreadedComments, path)
2338            {
2339                if let Ok(parsed) = quick_xml::de::from_str::<
2340                    sheetkit_xml::threaded_comment::ThreadedComments,
2341                >(&String::from_utf8_lossy(bytes))
2342                {
2343                    anchors.extend(parsed.comments.into_iter().map(|c| c.cell_ref));
2344                }
2345            }
2346        }
2347        for anchor in anchors {
2348            shift_cell_anchor(&anchor, edit)?;
2349        }
2350        Ok(())
2351    }
2352
2353    fn validate_retained_raw_graph_patches(
2354        &self,
2355        target_sheet_idx: usize,
2356        edit: StructuralShift,
2357    ) -> Result<()> {
2358        let target_sheet_name_lowercase = self.worksheets[target_sheet_idx].0.to_lowercase();
2359        for (path, chart) in &self.charts {
2360            let Some(raw) = self.raw_graph_parts.get(path) else {
2361                continue;
2362            };
2363            let owner = self.chart_owner_sheet_idx(path)?;
2364            let mut shifted = chart.clone();
2365            let mut replacements = Vec::new();
2366            visit_chart_references(&mut shifted, |formula| {
2367                let next = shift_references_for_owner(
2368                    formula,
2369                    owner,
2370                    target_sheet_idx,
2371                    &target_sheet_name_lowercase,
2372                    edit,
2373                )?;
2374                if next != *formula {
2375                    replacements.push((formula.clone(), next.clone()));
2376                    *formula = next;
2377                }
2378                Ok(())
2379            })?;
2380            let mut patched = raw.clone();
2381            for (old, new) in replacements {
2382                patched = replace_raw_text_once(&patched, &old, &new, path)?;
2383            }
2384        }
2385        if let Some(&drawing_idx) = self.worksheet_drawings.get(&target_sheet_idx) {
2386            if let Some((path, drawing)) = self.drawings.get(drawing_idx) {
2387                if let Some(raw) = self.raw_graph_parts.get(path) {
2388                    patch_raw_drawing_coordinates(
2389                        raw,
2390                        drawing,
2391                        |col, row| edit.shift_point(col, row),
2392                        path,
2393                    )?;
2394                }
2395            }
2396        }
2397        for (owner_sheet_idx, sparklines) in self.sheet_sparklines.iter().enumerate() {
2398            let Some(raw) = self
2399                .raw_sheet_xml
2400                .get(owner_sheet_idx)
2401                .and_then(Option::as_deref)
2402                .or_else(|| {
2403                    self.raw_sheet_extensions
2404                        .get(owner_sheet_idx)
2405                        .and_then(Option::as_deref)
2406                })
2407            else {
2408                continue;
2409            };
2410            let mut replacements = Vec::new();
2411            for sparkline in sparklines {
2412                let data_range = shift_references_for_owner(
2413                    &sparkline.data_range,
2414                    owner_sheet_idx,
2415                    target_sheet_idx,
2416                    &target_sheet_name_lowercase,
2417                    edit,
2418                )?;
2419                if data_range != sparkline.data_range {
2420                    replacements.push((
2421                        "xm:f".to_string(),
2422                        sparkline.data_range.clone(),
2423                        data_range,
2424                    ));
2425                }
2426                if owner_sheet_idx == target_sheet_idx {
2427                    let location = shift_point_references_for_owner(
2428                        &sparkline.location,
2429                        owner_sheet_idx,
2430                        target_sheet_idx,
2431                        &target_sheet_name_lowercase,
2432                        edit,
2433                    )?;
2434                    if location != sparkline.location {
2435                        replacements.push((
2436                            "xm:sqref".to_string(),
2437                            sparkline.location.clone(),
2438                            location,
2439                        ));
2440                    }
2441                }
2442            }
2443            replace_raw_element_texts(raw, replacements, &self.sheet_part_path(owner_sheet_idx))?;
2444        }
2445        Ok(())
2446    }
2447
2448    fn validate_deferred_drawing_and_chart_parts(
2449        &self,
2450        target_sheet_idx: usize,
2451        edit: StructuralShift,
2452    ) -> Result<()> {
2453        use crate::workbook::aux::AuxCategory;
2454
2455        let shift_cell = |col: u32, row: u32| edit.shift_point(col, row);
2456        let target_sheet_name_lowercase = self.worksheets[target_sheet_idx].0.to_lowercase();
2457        let validate = |text: &str, owner_sheet_idx: usize| {
2458            shift_references_for_owner(
2459                text,
2460                owner_sheet_idx,
2461                target_sheet_idx,
2462                &target_sheet_name_lowercase,
2463                edit,
2464            )
2465            .map(|_| ())
2466        };
2467        if let Some(entries) = self.deferred_parts.entries(AuxCategory::DrawingRels) {
2468            for (_, bytes) in entries {
2469                quick_xml::de::from_str::<Relationships>(&String::from_utf8_lossy(bytes))
2470                    .map_err(|error| Error::XmlDeserialize(error.to_string()))?;
2471            }
2472        }
2473        if let Some(entries) = self.deferred_parts.entries(AuxCategory::Drawings) {
2474            for (path, bytes) in entries {
2475                let drawing = quick_xml::de::from_str::<WsDr>(&String::from_utf8_lossy(bytes))
2476                    .map_err(|error| Error::XmlDeserialize(error.to_string()))?;
2477                let owner = self
2478                    .worksheet_rels
2479                    .iter()
2480                    .find_map(|(sheet_idx, relationships)| {
2481                        relationships
2482                            .relationships
2483                            .iter()
2484                            .any(|relationship| {
2485                                relationship.rel_type == rel_types::DRAWING
2486                                    && resolve_relationship_target(
2487                                        &self.sheet_part_path(*sheet_idx),
2488                                        &relationship.target,
2489                                    ) == *path
2490                            })
2491                            .then_some(*sheet_idx)
2492                    });
2493                if owner == Some(target_sheet_idx) {
2494                    for anchor in &drawing.one_cell_anchors {
2495                        validate_anchor_shift(anchor.from.col, anchor.from.row, shift_cell)?;
2496                    }
2497                    for anchor in &drawing.two_cell_anchors {
2498                        validate_anchor_shift(anchor.from.col, anchor.from.row, shift_cell)?;
2499                        validate_anchor_shift(anchor.to.col, anchor.to.row, shift_cell)?;
2500                    }
2501                }
2502            }
2503        }
2504        if let Some(entries) = self.deferred_parts.entries(AuxCategory::Charts) {
2505            for (path, bytes) in entries {
2506                let owner_sheet_idx = self.deferred_chart_owner_sheet_idx(path)?;
2507                let mut chart =
2508                    quick_xml::de::from_str::<ChartSpace>(&String::from_utf8_lossy(bytes))
2509                        .map_err(|error| Error::XmlDeserialize(error.to_string()))?;
2510                visit_chart_references(&mut chart, |formula| validate(formula, owner_sheet_idx))?;
2511            }
2512        }
2513        Ok(())
2514    }
2515
2516    fn deferred_chart_owner_sheet_idx(&self, chart_path: &str) -> Result<usize> {
2517        self.worksheet_rels
2518            .iter()
2519            .find_map(|(sheet_idx, worksheet_rels)| {
2520                worksheet_rels.relationships.iter().find_map(|relationship| {
2521                    (relationship.rel_type == rel_types::DRAWING).then(|| {
2522                        let drawing_path = resolve_relationship_target(
2523                            &self.sheet_part_path(*sheet_idx),
2524                            &relationship.target,
2525                        );
2526                        let has_drawing = self
2527                            .drawings
2528                            .iter()
2529                            .any(|(path, _)| path == &drawing_path)
2530                            || self
2531                                .deferred_parts
2532                                .get_path(
2533                                    crate::workbook::aux::AuxCategory::Drawings,
2534                                    &drawing_path,
2535                                )
2536                                .is_some();
2537                        if !has_drawing {
2538                            return None;
2539                        }
2540                        let drawing_rels_path = relationship_part_path(&drawing_path);
2541                        let rels = self
2542                            .drawing_rels
2543                            .iter()
2544                            .find_map(|(drawing_idx, rels)| {
2545                                (self.drawings.get(*drawing_idx).is_some_and(|(path, _)| {
2546                                    path == &drawing_path
2547                                }))
2548                                .then_some(rels)
2549                            })
2550                            .cloned()
2551                            .or_else(|| {
2552                                self.deferred_parts
2553                                    .get_path(
2554                                        crate::workbook::aux::AuxCategory::DrawingRels,
2555                                        &drawing_rels_path,
2556                                    )
2557                                    .and_then(|bytes| {
2558                                        quick_xml::de::from_reader::<_, Relationships>(bytes).ok()
2559                                    })
2560                            });
2561                        rels.and_then(|rels| {
2562                            rels.relationships
2563                                .iter()
2564                                .any(|relationship| {
2565                                    relationship.rel_type == rel_types::CHART
2566                                        && resolve_relationship_target(
2567                                            &drawing_path,
2568                                            &relationship.target,
2569                                        ) == chart_path
2570                                })
2571                                .then_some(*sheet_idx)
2572                        })
2573                    })
2574                    .flatten()
2575                })
2576            })
2577            .ok_or_else(|| {
2578                Error::InvalidArgument(format!(
2579                    "cannot structurally edit a workbook with an unresolved chart owner '{chart_path}'"
2580                ))
2581            })
2582    }
2583
2584    fn chart_owner_sheet_idx(&self, chart_path: &str) -> Result<usize> {
2585        self.worksheet_drawings
2586            .iter()
2587            .find_map(|(sheet_idx, drawing_idx)| {
2588                self.drawing_rels
2589                    .get(drawing_idx)
2590                    .and_then(|relationships| {
2591                        relationships.relationships.iter().find_map(|relationship| {
2592                            (relationship.rel_type == rel_types::CHART
2593                                && resolve_relationship_target(
2594                                    &self.drawings[*drawing_idx].0,
2595                                    &relationship.target,
2596                                ) == chart_path)
2597                                .then_some(*sheet_idx)
2598                        })
2599                    })
2600            })
2601            .ok_or_else(|| {
2602                Error::InvalidArgument(format!(
2603                    "cannot structurally edit a workbook with an unresolved chart owner '{chart_path}'"
2604                ))
2605            })
2606    }
2607
2608    fn validate_typed_chart_ownership(&self) -> Result<()> {
2609        for (path, _) in &self.charts {
2610            self.chart_owner_sheet_idx(path)?;
2611        }
2612        Ok(())
2613    }
2614
2615    fn validate_reference_shift(
2616        &self,
2617        target_sheet_idx: usize,
2618        edit: StructuralShift,
2619    ) -> Result<()> {
2620        let shift_cell = |col: u32, row: u32| edit.shift_point(col, row);
2621        let target_sheet_name_lowercase = self.worksheets[target_sheet_idx].0.to_lowercase();
2622        let validate = |text: &str, owner_sheet_idx: usize| {
2623            shift_references_for_owner(
2624                text,
2625                owner_sheet_idx,
2626                target_sheet_idx,
2627                &target_sheet_name_lowercase,
2628                edit,
2629            )
2630            .map(|_| ())
2631        };
2632        let validate_point = |text: &str, owner_sheet_idx: usize| {
2633            shift_point_references_for_owner(
2634                text,
2635                owner_sheet_idx,
2636                target_sheet_idx,
2637                &target_sheet_name_lowercase,
2638                edit,
2639            )
2640            .map(|_| ())
2641        };
2642        let validate_sqref = |text: &str, owner_sheet_idx: usize| {
2643            if owner_sheet_idx == target_sheet_idx {
2644                crate::cell_ref_shift::shift_sqref_structural(text, edit)?;
2645            }
2646            Ok::<(), Error>(())
2647        };
2648
2649        for owner_sheet_idx in 0..self.worksheets.len() {
2650            let ws = self.preflight_worksheet(owner_sheet_idx)?;
2651            for row in &ws.sheet_data.rows {
2652                for cell in &row.cells {
2653                    if let Some(formula) = &cell.f {
2654                        if let Some(expr) = &formula.value {
2655                            validate(expr, owner_sheet_idx)?;
2656                        }
2657                        if let Some(reference) = &formula.reference {
2658                            validate_sqref(reference, owner_sheet_idx)?;
2659                        }
2660                    }
2661                }
2662            }
2663            if let Some(merges) = &ws.merge_cells {
2664                for merge in &merges.merge_cells {
2665                    validate_sqref(&merge.reference, owner_sheet_idx)?;
2666                }
2667            }
2668            if let Some(auto_filter) = &ws.auto_filter {
2669                validate_sqref(&auto_filter.reference, owner_sheet_idx)?;
2670            }
2671            if let Some(validations) = &ws.data_validations {
2672                for validation in &validations.data_validations {
2673                    validate_sqref(&validation.sqref, owner_sheet_idx)?;
2674                    if let Some(formula) = &validation.formula1 {
2675                        validate(formula, owner_sheet_idx)?;
2676                    }
2677                    if let Some(formula) = &validation.formula2 {
2678                        validate(formula, owner_sheet_idx)?;
2679                    }
2680                }
2681            }
2682            for formatting in &ws.conditional_formatting {
2683                validate_sqref(&formatting.sqref, owner_sheet_idx)?;
2684                for rule in &formatting.cf_rules {
2685                    for formula in &rule.formulas {
2686                        validate(formula, owner_sheet_idx)?;
2687                    }
2688                }
2689            }
2690            if let Some(hyperlinks) = &ws.hyperlinks {
2691                for hyperlink in &hyperlinks.hyperlinks {
2692                    validate_sqref(&hyperlink.reference, owner_sheet_idx)?;
2693                    if let Some(location) = &hyperlink.location {
2694                        validate_point(location, owner_sheet_idx)?;
2695                    }
2696                }
2697            }
2698            if let Some(views) = &ws.sheet_views {
2699                for view in &views.sheet_views {
2700                    if let Some(pane) = &view.pane {
2701                        if let Some(top_left) = &pane.top_left_cell {
2702                            validate_point(top_left, owner_sheet_idx)?;
2703                        }
2704                    }
2705                    for selection in &view.selection {
2706                        if let Some(active_cell) = &selection.active_cell {
2707                            validate_point(active_cell, owner_sheet_idx)?;
2708                        }
2709                        if let Some(sqref) = &selection.sqref {
2710                            validate_point(sqref, owner_sheet_idx)?;
2711                        }
2712                    }
2713                }
2714            }
2715        }
2716        if let Some(defined_names) = &self.workbook_xml.defined_names {
2717            for defined_name in &defined_names.defined_names {
2718                crate::cell_ref_shift::shift_references_structural(
2719                    &defined_name.value,
2720                    defined_name.local_sheet_id == Some(target_sheet_idx as u32),
2721                    |name| crate::sheet::sheet_names_equal(name, &target_sheet_name_lowercase),
2722                    edit,
2723                )?;
2724            }
2725        }
2726        for (owner_sheet_idx, sparklines) in self.sheet_sparklines.iter().enumerate() {
2727            for sparkline in sparklines {
2728                validate(&sparkline.data_range, owner_sheet_idx)?;
2729                if owner_sheet_idx == target_sheet_idx {
2730                    validate_point(&sparkline.location, owner_sheet_idx)?;
2731                }
2732            }
2733        }
2734        for (_, table, owner_sheet_idx) in &self.tables {
2735            if *owner_sheet_idx == target_sheet_idx {
2736                shift_table_definition(table, edit)?;
2737            }
2738        }
2739        for (path, chart) in &self.charts {
2740            let owner_sheet_idx = self.chart_owner_sheet_idx(path)?;
2741            let mut chart = chart.clone();
2742            visit_chart_references(&mut chart, |formula| validate(formula, owner_sheet_idx))?;
2743        }
2744        if let Some(&drawing_idx) = self.worksheet_drawings.get(&target_sheet_idx) {
2745            if let Some((_, drawing)) = self.drawings.get(drawing_idx) {
2746                for anchor in &drawing.one_cell_anchors {
2747                    validate_anchor_shift(anchor.from.col, anchor.from.row, shift_cell)?;
2748                }
2749                for anchor in &drawing.two_cell_anchors {
2750                    validate_anchor_shift(anchor.from.col, anchor.from.row, shift_cell)?;
2751                    validate_anchor_shift(anchor.to.col, anchor.to.row, shift_cell)?;
2752                }
2753            }
2754        }
2755        if let Some(entries) = self
2756            .deferred_parts
2757            .entries(crate::workbook::aux::AuxCategory::Tables)
2758        {
2759            for (path, bytes) in entries {
2760                let table = sheetkit_xml::table::parse_table_xml(&String::from_utf8_lossy(bytes))
2761                    .map_err(|error| Error::XmlDeserialize(error.to_string()))?;
2762                let owner_sheet_idx = self
2763                    .worksheet_rels
2764                    .iter()
2765                    .find_map(|(sheet_idx, rels)| {
2766                        rels.relationships.iter().find_map(|rel| {
2767                            (rel.rel_type == rel_types::TABLE
2768                                && resolve_relationship_target(
2769                                    &self.sheet_part_path(*sheet_idx),
2770                                    &rel.target,
2771                                ) == *path)
2772                                .then_some(*sheet_idx)
2773                        })
2774                    })
2775                    .unwrap_or(0);
2776                if owner_sheet_idx != target_sheet_idx {
2777                    continue;
2778                }
2779                shift_table_definition(&table, edit)?;
2780            }
2781        }
2782        Ok(())
2783    }
2784
2785    fn preflight_worksheet(&self, sheet_idx: usize) -> Result<WorksheetXml> {
2786        if !self.sheet_dirty.get(sheet_idx).copied().unwrap_or(true) {
2787            if let Some(bytes) = self.raw_sheet_xml.get(sheet_idx).and_then(Option::as_deref) {
2788                return io::deserialize_worksheet_xml(bytes);
2789            }
2790            if self
2791                .sheet_package_backed
2792                .get(sheet_idx)
2793                .copied()
2794                .unwrap_or(false)
2795                && !self.sheet_included.get(sheet_idx).copied().unwrap_or(true)
2796            {
2797                return self.deserialize_package_sheet(sheet_idx);
2798            }
2799        }
2800        Ok(self.worksheet_ref_by_index(sheet_idx)?.clone())
2801    }
2802
2803    fn preflight_structural_target<F>(&self, sheet_idx: usize, edit: F) -> Result<()>
2804    where
2805        F: FnOnce(&mut WorksheetXml) -> Result<()>,
2806    {
2807        if self.sheet_rows_limit.is_some() {
2808            return Err(Error::InvalidArgument(
2809                "cannot structurally edit a workbook opened with sheet_rows".into(),
2810            ));
2811        }
2812        if !self.streamed_sheets.is_empty() {
2813            return Err(Error::InvalidArgument(
2814                "cannot structurally edit a workbook containing streamed sheets".into(),
2815            ));
2816        }
2817        let mut worksheet = self.preflight_worksheet(sheet_idx)?;
2818        edit(&mut worksheet)
2819    }
2820
2821    fn preflight_duplicate_formula_copy(&self, sheet_idx: usize, row: u32) -> Result<()> {
2822        let worksheet = self.preflight_worksheet(sheet_idx)?;
2823        if !worksheet
2824            .sheet_data
2825            .rows
2826            .iter()
2827            .any(|candidate| candidate.r == row)
2828        {
2829            return Err(Error::InvalidRowNumber(row));
2830        }
2831        let target_row = row.checked_add(1).ok_or(Error::InvalidRowNumber(row))?;
2832        let target_sheet_name_lowercase = self.worksheets[sheet_idx].0.to_lowercase();
2833        for formula in duplicated_row_formula_sources(&worksheet, row)?
2834            .into_iter()
2835            .flatten()
2836        {
2837            shift_duplicated_row_formula(&formula, &target_sheet_name_lowercase, target_row)?;
2838        }
2839        Ok(())
2840    }
2841
2842    /// Detach the formulas of the freshly duplicated row so the structural
2843    /// shift does not touch them. Shared-formula copies become standalone
2844    /// formulas expanded from their master.
2845    fn take_duplicated_row_formulas(
2846        &mut self,
2847        sheet_idx: usize,
2848        row: u32,
2849    ) -> Result<Vec<DuplicatedFormula>> {
2850        let ws = self.worksheet_mut_by_index(sheet_idx)?;
2851        let sources = duplicated_row_formula_sources(ws, row.saturating_sub(1))?;
2852        let Some(duplicated) = ws
2853            .sheet_data
2854            .rows
2855            .iter_mut()
2856            .find(|candidate| candidate.r == row)
2857        else {
2858            return Ok(Vec::new());
2859        };
2860        Ok(duplicated
2861            .cells
2862            .iter_mut()
2863            .zip(sources.into_iter().chain(std::iter::repeat(None)))
2864            .map(|(cell, text)| {
2865                let mut taken = DuplicatedFormula::default();
2866                let (Some(formula), Some(text)) = (cell.f.as_mut(), text) else {
2867                    return taken;
2868                };
2869                formula.value = None;
2870                match formula.t.as_deref() {
2871                    Some("shared") => {
2872                        formula.t = None;
2873                        formula.si = None;
2874                        formula.reference = None;
2875                    }
2876                    Some("array") => taken.array_ref = formula.reference.take(),
2877                    _ => {}
2878                }
2879                taken.text = Some(text);
2880                taken
2881            })
2882            .collect())
2883    }
2884
2885    fn restore_duplicated_row_formulas(
2886        &mut self,
2887        sheet_idx: usize,
2888        row: u32,
2889        formulas: Vec<DuplicatedFormula>,
2890    ) -> Result<()> {
2891        let target_sheet_name_lowercase = self.worksheets[sheet_idx].0.to_lowercase();
2892        let ws = self.worksheet_mut_by_index(sheet_idx)?;
2893        let Some(duplicated) = ws
2894            .sheet_data
2895            .rows
2896            .iter_mut()
2897            .find(|candidate| candidate.r == row)
2898        else {
2899            return Ok(());
2900        };
2901        for (cell, formula) in duplicated.cells.iter_mut().zip(formulas) {
2902            let Some(cell_formula) = &mut cell.f else {
2903                continue;
2904            };
2905            if let Some(text) = formula.text {
2906                cell_formula.value = Some(shift_duplicated_row_formula(
2907                    &text,
2908                    &target_sheet_name_lowercase,
2909                    row,
2910                )?);
2911            }
2912            if let Some(array_ref) = formula.array_ref {
2913                cell_formula.reference = Some(
2914                    crate::cell_ref_shift::shift_cell_references_with_abs_and_scope(
2915                        &array_ref,
2916                        true,
2917                        |_| true,
2918                        |col, referenced_row, _, _| (col, referenced_row.saturating_add(1)),
2919                    )?,
2920                );
2921            }
2922        }
2923        Ok(())
2924    }
2925
2926    /// Apply a structural edit to every reference that addresses the edited
2927    /// sheet: formulas, sqref-based worksheet entries, defined names,
2928    /// sparklines, tables, charts, drawings, comments, and page breaks.
2929    ///
2930    /// Formula references to removed cells become `#REF!`. Sqref-based
2931    /// entries that lie only inside a removed band are dropped and partially
2932    /// covered entries shrink.
2933    pub(crate) fn apply_reference_shift_for_sheet(
2934        &mut self,
2935        sheet_idx: usize,
2936        edit: StructuralShift,
2937    ) -> Result<()> {
2938        let shift_cell = |col: u32, row: u32| edit.shift_point(col, row);
2939        let target_sheet_name_lowercase = self.worksheets[sheet_idx].0.to_lowercase();
2940        let mut removed_hyperlink_rids: Vec<String> = Vec::new();
2941        for owner_sheet_idx in 0..self.worksheets.len() {
2942            let is_target = owner_sheet_idx == sheet_idx;
2943            let changed = {
2944                let ws = self.worksheets[owner_sheet_idx]
2945                    .1
2946                    .get_mut()
2947                    .ok_or_else(|| {
2948                        Error::Internal(
2949                            "worksheet must be hydrated before shifting references".into(),
2950                        )
2951                    })?;
2952                let before = ws.clone();
2953                let shift_formula = |text: &str| {
2954                    shift_references_for_owner(
2955                        text,
2956                        owner_sheet_idx,
2957                        sheet_idx,
2958                        &target_sheet_name_lowercase,
2959                        edit,
2960                    )
2961                };
2962                let shift_position = |text: &str| {
2963                    shift_point_references_for_owner(
2964                        text,
2965                        owner_sheet_idx,
2966                        sheet_idx,
2967                        &target_sheet_name_lowercase,
2968                        edit,
2969                    )
2970                };
2971
2972                for row in &mut ws.sheet_data.rows {
2973                    for cell in &mut row.cells {
2974                        if let Some(formula) = &mut cell.f {
2975                            if let Some(expr) = &mut formula.value {
2976                                *expr = shift_formula(expr)?;
2977                            }
2978                            if !is_target {
2979                                continue;
2980                            }
2981                            if let Some(reference) = &mut formula.reference {
2982                                // A fully removed range means its anchor cell
2983                                // was removed with it.
2984                                if let Some(shifted) =
2985                                    crate::cell_ref_shift::shift_sqref_structural(reference, edit)?
2986                                {
2987                                    *reference = shifted;
2988                                }
2989                            }
2990                        }
2991                    }
2992                }
2993
2994                if is_target {
2995                    let mut drop_merges = false;
2996                    if let Some(merges) = &mut ws.merge_cells {
2997                        let mut kept = Vec::with_capacity(merges.merge_cells.len());
2998                        for mut merge in std::mem::take(&mut merges.merge_cells) {
2999                            let Some(reference) = crate::cell_ref_shift::shift_sqref_structural(
3000                                &merge.reference,
3001                                edit,
3002                            )?
3003                            else {
3004                                continue;
3005                            };
3006                            if edit.is_removal()
3007                                && crate::cell_ref_shift::is_single_cell_reference(&reference)
3008                            {
3009                                continue;
3010                            }
3011                            merge.reference = reference;
3012                            kept.push(merge);
3013                        }
3014                        merges.merge_cells = kept;
3015                        merges.cached_coords.clear();
3016                        if merges.count.is_some() {
3017                            merges.count = Some(merges.merge_cells.len() as u32);
3018                        }
3019                        drop_merges = merges.merge_cells.is_empty();
3020                    }
3021                    if drop_merges {
3022                        ws.merge_cells = None;
3023                    }
3024
3025                    if let Some(auto_filter) = &ws.auto_filter {
3026                        match crate::cell_ref_shift::shift_sqref_structural(
3027                            &auto_filter.reference,
3028                            edit,
3029                        )? {
3030                            Some(reference) => {
3031                                if let Some(auto_filter) = &mut ws.auto_filter {
3032                                    auto_filter.reference = reference;
3033                                }
3034                            }
3035                            None => ws.auto_filter = None,
3036                        }
3037                    }
3038                }
3039
3040                let mut drop_validations = false;
3041                if let Some(validations) = &mut ws.data_validations {
3042                    let mut kept = Vec::with_capacity(validations.data_validations.len());
3043                    for mut validation in std::mem::take(&mut validations.data_validations) {
3044                        if is_target {
3045                            match crate::cell_ref_shift::shift_sqref_structural(
3046                                &validation.sqref,
3047                                edit,
3048                            )? {
3049                                Some(sqref) => validation.sqref = sqref,
3050                                None => continue,
3051                            }
3052                        }
3053                        for formula in [&mut validation.formula1, &mut validation.formula2]
3054                            .into_iter()
3055                            .flatten()
3056                        {
3057                            *formula = shift_formula(formula)?;
3058                        }
3059                        kept.push(validation);
3060                    }
3061                    validations.data_validations = kept;
3062                    if validations.count.is_some() {
3063                        validations.count = Some(validations.data_validations.len() as u32);
3064                    }
3065                    drop_validations = validations.data_validations.is_empty();
3066                }
3067                if drop_validations {
3068                    ws.data_validations = None;
3069                }
3070
3071                let mut kept_formatting = Vec::with_capacity(ws.conditional_formatting.len());
3072                for mut formatting in std::mem::take(&mut ws.conditional_formatting) {
3073                    if is_target {
3074                        match crate::cell_ref_shift::shift_sqref_structural(
3075                            &formatting.sqref,
3076                            edit,
3077                        )? {
3078                            Some(sqref) => formatting.sqref = sqref,
3079                            None => continue,
3080                        }
3081                    }
3082                    for rule in &mut formatting.cf_rules {
3083                        for formula in &mut rule.formulas {
3084                            *formula = shift_formula(formula)?;
3085                        }
3086                    }
3087                    kept_formatting.push(formatting);
3088                }
3089                ws.conditional_formatting = kept_formatting;
3090
3091                let mut drop_hyperlinks = false;
3092                if let Some(hyperlinks) = &mut ws.hyperlinks {
3093                    let mut kept = Vec::with_capacity(hyperlinks.hyperlinks.len());
3094                    for mut hyperlink in std::mem::take(&mut hyperlinks.hyperlinks) {
3095                        if is_target {
3096                            match crate::cell_ref_shift::shift_sqref_structural(
3097                                &hyperlink.reference,
3098                                edit,
3099                            )? {
3100                                Some(reference) => hyperlink.reference = reference,
3101                                None => {
3102                                    removed_hyperlink_rids.extend(hyperlink.r_id.take());
3103                                    continue;
3104                                }
3105                            }
3106                        }
3107                        if let Some(location) = &mut hyperlink.location {
3108                            *location = shift_position(location)?;
3109                        }
3110                        kept.push(hyperlink);
3111                    }
3112                    if is_target {
3113                        removed_hyperlink_rids.retain(|rid| {
3114                            !kept
3115                                .iter()
3116                                .any(|hyperlink| hyperlink.r_id.as_deref() == Some(rid.as_str()))
3117                        });
3118                    }
3119                    hyperlinks.hyperlinks = kept;
3120                    drop_hyperlinks = hyperlinks.hyperlinks.is_empty();
3121                }
3122                if drop_hyperlinks {
3123                    ws.hyperlinks = None;
3124                }
3125
3126                if let Some(views) = &mut ws.sheet_views {
3127                    for view in &mut views.sheet_views {
3128                        if let Some(pane) = &mut view.pane {
3129                            if let Some(top_left) = &mut pane.top_left_cell {
3130                                *top_left = shift_position(top_left)?;
3131                            }
3132                        }
3133                        for selection in &mut view.selection {
3134                            for reference in [&mut selection.active_cell, &mut selection.sqref]
3135                                .into_iter()
3136                                .flatten()
3137                            {
3138                                *reference = shift_position(reference)?;
3139                            }
3140                        }
3141                    }
3142                }
3143
3144                if is_target {
3145                    if edit.is_row_axis() {
3146                        shift_page_breaks(
3147                            &mut ws.row_breaks,
3148                            edit,
3149                            crate::utils::constants::MAX_ROWS,
3150                        );
3151                    } else {
3152                        shift_page_breaks(
3153                            &mut ws.col_breaks,
3154                            edit,
3155                            crate::utils::constants::MAX_COLUMNS,
3156                        );
3157                    }
3158                }
3159
3160                *ws != before
3161            };
3162            if changed {
3163                self.mark_sheet_dirty(owner_sheet_idx);
3164            }
3165        }
3166
3167        if !removed_hyperlink_rids.is_empty() {
3168            if let Some(rels) = self.worksheet_rels.get_mut(&sheet_idx) {
3169                rels.relationships.retain(|relationship| {
3170                    !(relationship.rel_type == rel_types::HYPERLINK
3171                        && removed_hyperlink_rids.contains(&relationship.id))
3172                });
3173            }
3174        }
3175
3176        if let Some(defined_names) = &mut self.workbook_xml.defined_names {
3177            for defined_name in &mut defined_names.defined_names {
3178                let owner = defined_name.local_sheet_id.map(|id| id as usize);
3179                defined_name.value = crate::cell_ref_shift::shift_references_structural(
3180                    &defined_name.value,
3181                    owner == Some(sheet_idx),
3182                    |name| crate::sheet::sheet_names_equal(name, &target_sheet_name_lowercase),
3183                    edit,
3184                )?;
3185            }
3186        }
3187
3188        let mut sparkline_raw_replacements: Vec<(usize, &'static str, String, String)> = Vec::new();
3189        for (owner_sheet_idx, sparklines) in self.sheet_sparklines.iter_mut().enumerate() {
3190            for sparkline in sparklines {
3191                let data_range = shift_references_for_owner(
3192                    &sparkline.data_range,
3193                    owner_sheet_idx,
3194                    sheet_idx,
3195                    &target_sheet_name_lowercase,
3196                    edit,
3197                )?;
3198                if data_range != sparkline.data_range {
3199                    sparkline_raw_replacements.push((
3200                        owner_sheet_idx,
3201                        "xm:f",
3202                        sparkline.data_range.clone(),
3203                        data_range.clone(),
3204                    ));
3205                    sparkline.data_range = data_range;
3206                }
3207                if owner_sheet_idx == sheet_idx {
3208                    let location = shift_point_references_for_owner(
3209                        &sparkline.location,
3210                        owner_sheet_idx,
3211                        sheet_idx,
3212                        &target_sheet_name_lowercase,
3213                        edit,
3214                    )?;
3215                    if location != sparkline.location {
3216                        sparkline_raw_replacements.push((
3217                            owner_sheet_idx,
3218                            "xm:sqref",
3219                            sparkline.location.clone(),
3220                            location.clone(),
3221                        ));
3222                        sparkline.location = location;
3223                    }
3224                }
3225            }
3226        }
3227        let mut replacements_by_owner: std::collections::BTreeMap<
3228            usize,
3229            Vec<(String, String, String)>,
3230        > = std::collections::BTreeMap::new();
3231        for (owner_sheet_idx, tag, old, new) in sparkline_raw_replacements {
3232            replacements_by_owner
3233                .entry(owner_sheet_idx)
3234                .or_default()
3235                .push((tag.to_string(), old, new));
3236        }
3237        for (owner_sheet_idx, replacements) in replacements_by_owner {
3238            let raw_is_full = self
3239                .raw_sheet_xml
3240                .get(owner_sheet_idx)
3241                .is_some_and(Option::is_some);
3242            let Some(raw) = self
3243                .raw_sheet_xml
3244                .get(owner_sheet_idx)
3245                .and_then(Option::as_deref)
3246                .or_else(|| {
3247                    self.raw_sheet_extensions
3248                        .get(owner_sheet_idx)
3249                        .and_then(Option::as_deref)
3250                })
3251            else {
3252                continue;
3253            };
3254            let patched = replace_raw_element_texts(
3255                raw,
3256                replacements,
3257                &self.sheet_part_path(owner_sheet_idx),
3258            )?;
3259            if raw_is_full {
3260                self.raw_sheet_xml[owner_sheet_idx] = Some(patched);
3261            } else {
3262                self.raw_sheet_extensions[owner_sheet_idx] = Some(patched);
3263            }
3264        }
3265
3266        let mut shifted_table = false;
3267        for (_, table, owner_sheet_idx) in &mut self.tables {
3268            if *owner_sheet_idx != sheet_idx {
3269                continue;
3270            }
3271            let shifted = shift_table_definition(table, edit)?;
3272            if shifted != *table {
3273                shifted_table = true;
3274                *table = shifted;
3275            }
3276        }
3277        if shifted_table {
3278            self.deferred_parts
3279                .mark_dirty(crate::workbook::aux::AuxCategory::Tables);
3280        }
3281
3282        let mut dirty_chart_paths = Vec::new();
3283        for chart_idx in 0..self.charts.len() {
3284            let mut changed = false;
3285            let mut replacements = Vec::new();
3286            let owner_sheet_idx = self.chart_owner_sheet_idx(&self.charts[chart_idx].0)?;
3287            {
3288                let chart = &mut self.charts[chart_idx].1;
3289                visit_chart_references(chart, |formula| {
3290                    let shifted = shift_references_for_owner(
3291                        formula,
3292                        owner_sheet_idx,
3293                        sheet_idx,
3294                        &target_sheet_name_lowercase,
3295                        edit,
3296                    )?;
3297                    if shifted != *formula {
3298                        changed = true;
3299                        replacements.push((formula.clone(), shifted.clone()));
3300                        *formula = shifted;
3301                    }
3302                    Ok(())
3303                })?;
3304            }
3305            if changed {
3306                let path = self.charts[chart_idx].0.clone();
3307                if let Some(raw) = self.raw_graph_parts.get(&path) {
3308                    let mut patched = raw.clone();
3309                    for (old, new) in replacements {
3310                        patched = replace_raw_text_once(&patched, &old, &new, &path)?;
3311                    }
3312                    self.raw_graph_parts.insert(path, patched);
3313                } else {
3314                    dirty_chart_paths.push(path);
3315                }
3316            }
3317        }
3318        for path in dirty_chart_paths {
3319            self.mark_graph_part_dirty(&path);
3320        }
3321
3322        // Drawing anchors attached to this sheet.
3323        if let Some(&drawing_idx) = self.worksheet_drawings.get(&sheet_idx) {
3324            let mut changed = false;
3325            let raw_drawing = self.drawings.get(drawing_idx).and_then(|(path, drawing)| {
3326                self.raw_graph_parts
3327                    .get(path)
3328                    .map(|raw| (path.clone(), drawing.clone(), raw.clone()))
3329            });
3330            if let Some((_, drawing)) = self.drawings.get_mut(drawing_idx) {
3331                for anchor in &mut drawing.one_cell_anchors {
3332                    let (new_col, new_row) = shift_cell(anchor.from.col + 1, anchor.from.row + 1);
3333                    changed |= new_col != anchor.from.col + 1 || new_row != anchor.from.row + 1;
3334                    anchor.from.col = new_col - 1;
3335                    anchor.from.row = new_row - 1;
3336                }
3337                for anchor in &mut drawing.two_cell_anchors {
3338                    let (from_col, from_row) = shift_cell(anchor.from.col + 1, anchor.from.row + 1);
3339                    changed |= from_col != anchor.from.col + 1 || from_row != anchor.from.row + 1;
3340                    anchor.from.col = from_col - 1;
3341                    anchor.from.row = from_row - 1;
3342                    let (to_col, to_row) = shift_cell(anchor.to.col + 1, anchor.to.row + 1);
3343                    changed |= to_col != anchor.to.col + 1 || to_row != anchor.to.row + 1;
3344                    anchor.to.col = to_col - 1;
3345                    anchor.to.row = to_row - 1;
3346                }
3347            }
3348            if changed {
3349                if let Some((path, drawing, raw)) = raw_drawing {
3350                    let patched = patch_raw_drawing_coordinates(&raw, &drawing, shift_cell, &path)?;
3351                    self.raw_graph_parts.insert(path, patched);
3352                } else {
3353                    self.mark_drawing_dirty(drawing_idx);
3354                }
3355            }
3356        }
3357
3358        self.shift_comment_anchors(sheet_idx, edit)
3359    }
3360
3361    /// Shift legacy and threaded comment anchors on the edited sheet and drop
3362    /// comments whose cell was removed. Comment VML shapes are regenerated on
3363    /// save from the shifted anchors.
3364    fn shift_comment_anchors(&mut self, sheet_idx: usize, edit: StructuralShift) -> Result<()> {
3365        let mut comments_changed = false;
3366        let mut clear_comments = false;
3367        if let Some(Some(comments)) = self.sheet_comments.get_mut(sheet_idx) {
3368            let mut kept = Vec::with_capacity(comments.comment_list.comments.len());
3369            for mut comment in std::mem::take(&mut comments.comment_list.comments) {
3370                match shift_cell_anchor(&comment.r#ref, edit)? {
3371                    Some(reference) => {
3372                        comments_changed |= reference != comment.r#ref;
3373                        comment.r#ref = reference;
3374                        kept.push(comment);
3375                    }
3376                    None => comments_changed = true,
3377                }
3378            }
3379            comments.comment_list.comments = kept;
3380            clear_comments = comments.comment_list.comments.is_empty();
3381        }
3382        if clear_comments {
3383            self.sheet_comments[sheet_idx] = None;
3384        }
3385        if comments_changed {
3386            self.mark_sheet_dirty(sheet_idx);
3387            while self.sheet_form_controls.len() <= sheet_idx {
3388                self.sheet_form_controls.push(Vec::new());
3389            }
3390            if self.sheet_form_controls[sheet_idx].is_empty() {
3391                if let Some(Some(vml)) = self.sheet_vml.get(sheet_idx) {
3392                    let controls =
3393                        crate::control::parse_form_control_configs(&String::from_utf8_lossy(vml));
3394                    if !controls.is_empty() {
3395                        self.sheet_form_controls[sheet_idx] = controls;
3396                    }
3397                }
3398            }
3399            if sheet_idx < self.sheet_vml.len() {
3400                self.sheet_vml[sheet_idx] = self.sheet_vml[sheet_idx]
3401                    .as_deref()
3402                    .and_then(crate::vml::strip_vml_comment_shapes_from_vml);
3403            }
3404        }
3405
3406        let mut threaded_changed = false;
3407        let mut clear_threaded = false;
3408        if let Some(Some(threaded)) = self.sheet_threaded_comments.get_mut(sheet_idx) {
3409            let mut kept = Vec::with_capacity(threaded.comments.len());
3410            for mut comment in std::mem::take(&mut threaded.comments) {
3411                match shift_cell_anchor(&comment.cell_ref, edit)? {
3412                    Some(reference) => {
3413                        threaded_changed |= reference != comment.cell_ref;
3414                        comment.cell_ref = reference;
3415                        kept.push(comment);
3416                    }
3417                    None => threaded_changed = true,
3418                }
3419            }
3420            threaded.comments = kept;
3421            clear_threaded = threaded.comments.is_empty();
3422        }
3423        if clear_threaded {
3424            self.sheet_threaded_comments[sheet_idx] = None;
3425        }
3426        if threaded_changed {
3427            self.mark_sheet_dirty(sheet_idx);
3428            self.deferred_parts
3429                .mark_dirty(crate::workbook::aux::AuxCategory::ThreadedComments);
3430        }
3431        Ok(())
3432    }
3433
3434    /// Ensure a drawing exists for the given sheet index, creating one if needed.
3435    /// Returns the drawing index.
3436    pub(crate) fn ensure_drawing_for_sheet(&mut self, sheet_idx: usize) -> usize {
3437        if let Some(&idx) = self.worksheet_drawings.get(&sheet_idx) {
3438            return idx;
3439        }
3440
3441        let idx = self.drawings.len();
3442        let drawing_path = self.next_available_part_path("xl/drawings/drawing", ".xml");
3443        self.drawings.push((drawing_path.clone(), WsDr::default()));
3444        self.mark_graph_part_dirty(&drawing_path);
3445        self.worksheet_drawings.insert(sheet_idx, idx);
3446
3447        // Add drawing reference to the worksheet.
3448        let ws_rid = self.next_worksheet_rid(sheet_idx);
3449        // ensure_hydrated can only fail if the sheet was never loaded, which
3450        // should not happen for a sheet we're actively attaching a drawing to.
3451        // Use expect instead of `?` because this method returns `usize`.
3452        self.ensure_hydrated(sheet_idx)
3453            .expect("sheet must be hydrated before attaching a drawing");
3454        self.mark_sheet_dirty(sheet_idx);
3455        self.worksheets[sheet_idx].1.get_mut().unwrap().drawing = Some(DrawingRef {
3456            r_id: ws_rid.clone(),
3457        });
3458
3459        // Add worksheet->drawing relationship.
3460        let drawing_rel_target = crate::workbook_paths::relative_relationship_target(
3461            &self.sheet_part_path(sheet_idx),
3462            &drawing_path,
3463        );
3464        let ws_rels = self
3465            .worksheet_rels
3466            .entry(sheet_idx)
3467            .or_insert_with(|| Relationships {
3468                xmlns: sheetkit_xml::namespaces::PACKAGE_RELATIONSHIPS.to_string(),
3469                relationships: vec![],
3470            });
3471        ws_rels.relationships.push(Relationship {
3472            id: ws_rid,
3473            rel_type: rel_types::DRAWING.to_string(),
3474            target: drawing_rel_target,
3475            target_mode: None,
3476        });
3477
3478        // Add content type for the drawing.
3479        self.content_types.overrides.push(ContentTypeOverride {
3480            part_name: format!("/{drawing_path}"),
3481            content_type: mime_types::DRAWING.to_string(),
3482        });
3483
3484        idx
3485    }
3486
3487    pub(crate) fn occupied_part_paths(&self) -> std::collections::HashSet<String> {
3488        let mut paths: std::collections::HashSet<String> = self
3489            .content_types
3490            .overrides
3491            .iter()
3492            .map(|entry| entry.part_name.trim_start_matches('/').to_string())
3493            .collect();
3494        paths.extend((0..self.worksheets.len()).map(|idx| self.sheet_part_path(idx)));
3495        paths.extend(self.charts.iter().map(|(path, _)| path.clone()));
3496        paths.extend(self.raw_charts.iter().map(|(path, _)| path.clone()));
3497        paths.extend(self.drawings.iter().map(|(path, _)| path.clone()));
3498        paths.extend(self.raw_graph_parts.keys().cloned());
3499        paths.extend(self.images.iter().map(|(path, _)| path.clone()));
3500        paths.extend(self.tables.iter().map(|(path, _, _)| path.clone()));
3501        paths.extend(self.pivot_tables.iter().map(|(path, _)| path.clone()));
3502        paths.extend(self.pivot_cache_defs.iter().map(|(path, _)| path.clone()));
3503        paths.extend(
3504            self.pivot_cache_records
3505                .iter()
3506                .map(|(path, _)| path.clone()),
3507        );
3508        paths.extend(self.slicer_defs.iter().map(|(path, _)| path.clone()));
3509        paths.extend(self.slicer_caches.iter().map(|(path, _)| path.clone()));
3510        paths.extend(self.unknown_parts.iter().map(|(path, _)| path.clone()));
3511        paths.extend(
3512            self.deferred_parts
3513                .remaining_parts()
3514                .map(|(path, _)| path.to_string()),
3515        );
3516        paths
3517    }
3518
3519    pub(crate) fn next_available_part_path(&self, prefix: &str, suffix: &str) -> String {
3520        let occupied = self.occupied_part_paths();
3521        next_numbered_part_path(prefix, suffix, &occupied)
3522    }
3523
3524    /// Generate the next relationship ID for a worksheet's rels.
3525    pub(crate) fn next_worksheet_rid(&self, sheet_idx: usize) -> String {
3526        let existing = self
3527            .worksheet_rels
3528            .get(&sheet_idx)
3529            .map(|r| r.relationships.as_slice())
3530            .unwrap_or(&[]);
3531        crate::sheet::next_rid(existing)
3532    }
3533
3534    /// Generate the next relationship ID for a drawing's rels.
3535    pub(crate) fn next_drawing_rid(&self, drawing_idx: usize) -> String {
3536        let existing = self
3537            .drawing_rels
3538            .get(&drawing_idx)
3539            .map(|r| r.relationships.as_slice())
3540            .unwrap_or(&[]);
3541        crate::sheet::next_rid(existing)
3542    }
3543}
3544
3545#[cfg(test)]
3546#[allow(clippy::approx_constant)]
3547mod tests {
3548    use super::*;
3549    use crate::chart::{ChartSeries, ChartType};
3550    use crate::image::ImageFormat;
3551    use crate::workbook::aux::AuxCategory;
3552    use std::io::Read;
3553    use tempfile::TempDir;
3554
3555    fn zip_part(buffer: &[u8], name: &str) -> Vec<u8> {
3556        let mut archive = zip::ZipArchive::new(std::io::Cursor::new(buffer)).unwrap();
3557        let mut bytes = Vec::new();
3558        archive
3559            .by_name(name)
3560            .unwrap()
3561            .read_to_end(&mut bytes)
3562            .unwrap();
3563        bytes
3564    }
3565
3566    fn zip_entry_count(buffer: &[u8], name: &str) -> usize {
3567        let mut archive = zip::ZipArchive::new(std::io::Cursor::new(buffer)).unwrap();
3568        (0..archive.len())
3569            .filter(|index| archive.by_index(*index).unwrap().name() == name)
3570            .count()
3571    }
3572
3573    fn assert_package_integrity(bytes: &[u8]) {
3574        let mut archive = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
3575        let names: Vec<String> = (0..archive.len())
3576            .map(|index| archive.by_index(index).unwrap().name().to_string())
3577            .collect();
3578        let unique_names: std::collections::HashSet<&str> =
3579            names.iter().map(String::as_str).collect();
3580        assert_eq!(names.len(), unique_names.len(), "duplicate ZIP entry");
3581
3582        let mut content_types_xml = String::new();
3583        archive
3584            .by_name("[Content_Types].xml")
3585            .unwrap()
3586            .read_to_string(&mut content_types_xml)
3587            .unwrap();
3588        let content_types: ContentTypes = quick_xml::de::from_str(&content_types_xml).unwrap();
3589        let mut part_names = std::collections::HashSet::new();
3590        for entry in content_types.overrides {
3591            assert!(part_names.insert(entry.part_name.clone()));
3592            let is_unset_document_property = matches!(
3593                entry.part_name.as_str(),
3594                "/docProps/core.xml" | "/docProps/app.xml" | "/docProps/custom.xml"
3595            ) && !unique_names
3596                .contains(entry.part_name.trim_start_matches('/'));
3597            if is_unset_document_property {
3598                continue;
3599            }
3600            assert!(
3601                unique_names.contains(entry.part_name.trim_start_matches('/')),
3602                "content type target missing: {}",
3603                entry.part_name
3604            );
3605        }
3606
3607        let rel_paths: Vec<String> = names
3608            .iter()
3609            .filter(|name| name.ends_with(".rels"))
3610            .cloned()
3611            .collect();
3612        for rel_path in rel_paths {
3613            let mut xml = String::new();
3614            archive
3615                .by_name(&rel_path)
3616                .unwrap()
3617                .read_to_string(&mut xml)
3618                .unwrap();
3619            let relationships: Relationships = quick_xml::de::from_str(&xml).unwrap();
3620            let owner = if rel_path == "_rels/.rels" {
3621                String::new()
3622            } else {
3623                let (dir, file) = rel_path.rsplit_once("/_rels/").unwrap();
3624                format!("{dir}/{}", file.trim_end_matches(".rels"))
3625            };
3626            for relationship in relationships.relationships {
3627                if relationship.target_mode.as_deref() == Some("External") {
3628                    continue;
3629                }
3630                let target = crate::workbook_paths::resolve_relationship_target(
3631                    &owner,
3632                    &relationship.target,
3633                );
3634                let is_unset_document_property = rel_path == "_rels/.rels"
3635                    && matches!(
3636                        relationship.rel_type.as_str(),
3637                        rel_types::CORE_PROPERTIES
3638                            | rel_types::EXTENDED_PROPERTIES
3639                            | rel_types::CUSTOM_PROPERTIES
3640                    )
3641                    && !unique_names.contains(target.as_str());
3642                if is_unset_document_property {
3643                    continue;
3644                }
3645                assert!(
3646                    unique_names.contains(target.as_str()),
3647                    "relationship target missing: {rel_path} -> {target}"
3648                );
3649            }
3650        }
3651    }
3652
3653    #[test]
3654    fn test_new_sheet_basic() {
3655        let mut wb = Workbook::new();
3656        let idx = wb.new_sheet("Sheet2").unwrap();
3657        assert_eq!(idx, 1);
3658        assert_eq!(wb.sheet_names(), vec!["Sheet1", "Sheet2"]);
3659    }
3660
3661    #[test]
3662    fn test_sparse_worksheet_paths_save_with_package_integrity() {
3663        let mut wb = Workbook::new();
3664        let first_rid = wb.workbook_xml.sheets.sheets[0].r_id.clone();
3665        wb.workbook_rels
3666            .relationships
3667            .iter_mut()
3668            .find(|relationship| relationship.id == first_rid)
3669            .unwrap()
3670            .target = "worksheets/sheet2.xml".to_string();
3671        let worksheet_override = wb
3672            .content_types
3673            .overrides
3674            .iter_mut()
3675            .find(|entry| entry.content_type == mime_types::WORKSHEET)
3676            .unwrap();
3677        worksheet_override.part_name = "/xl/worksheets/sheet2.xml".to_string();
3678
3679        wb.new_sheet("Added").unwrap();
3680        assert_eq!(wb.sheet_part_path(0), "xl/worksheets/sheet2.xml");
3681        assert_eq!(wb.sheet_part_path(1), "xl/worksheets/sheet1.xml");
3682        let bytes = wb.save_to_buffer().unwrap();
3683        assert_package_integrity(&bytes);
3684    }
3685
3686    #[test]
3687    fn test_new_sheet_skips_unknown_worksheet_path_collision() {
3688        let mut wb = Workbook::new();
3689        let first_rid = wb.workbook_xml.sheets.sheets[0].r_id.clone();
3690        wb.workbook_rels
3691            .relationships
3692            .iter_mut()
3693            .find(|relationship| relationship.id == first_rid)
3694            .unwrap()
3695            .target = "worksheets/sheet9.xml".to_string();
3696        wb.content_types
3697            .overrides
3698            .iter_mut()
3699            .find(|entry| entry.content_type == mime_types::WORKSHEET)
3700            .unwrap()
3701            .part_name = "/xl/worksheets/sheet9.xml".to_string();
3702        wb.unknown_parts
3703            .push(("xl/worksheets/sheet1.xml".to_string(), b"reserved".to_vec()));
3704
3705        wb.new_sheet("Added").unwrap();
3706
3707        assert_eq!(wb.sheet_part_path(1), "xl/worksheets/sheet2.xml");
3708    }
3709
3710    #[test]
3711    fn test_new_sheet_duplicate_returns_error() {
3712        let mut wb = Workbook::new();
3713        let result = wb.new_sheet("Sheet1");
3714        assert!(result.is_err());
3715        assert!(matches!(
3716            result.unwrap_err(),
3717            Error::SheetAlreadyExists { .. }
3718        ));
3719    }
3720
3721    #[test]
3722    fn test_new_sheet_invalid_name_returns_error() {
3723        let mut wb = Workbook::new();
3724        let result = wb.new_sheet("Bad/Name");
3725        assert!(result.is_err());
3726        assert!(matches!(result.unwrap_err(), Error::InvalidSheetName(_)));
3727    }
3728
3729    #[test]
3730    fn test_delete_sheet_basic() {
3731        let mut wb = Workbook::new();
3732        wb.new_sheet("Sheet2").unwrap();
3733        wb.delete_sheet("Sheet1").unwrap();
3734        assert_eq!(wb.sheet_names(), vec!["Sheet2"]);
3735    }
3736
3737    #[test]
3738    fn test_delete_sheet_keeps_parallel_vecs_in_sync() {
3739        let mut wb = Workbook::new();
3740        wb.new_sheet("Sheet2").unwrap();
3741        wb.new_sheet("Sheet3").unwrap();
3742
3743        // Add comments to Sheet2 (middle sheet).
3744        wb.add_comment(
3745            "Sheet2",
3746            &crate::comment::CommentConfig {
3747                cell: "A1".to_string(),
3748                author: "Test".to_string(),
3749                text: "note".to_string(),
3750            },
3751        )
3752        .unwrap();
3753
3754        // Delete the middle sheet and verify no panic.
3755        wb.delete_sheet("Sheet2").unwrap();
3756        assert_eq!(wb.sheet_names(), vec!["Sheet1", "Sheet3"]);
3757
3758        // After deletion, adding a comment to Sheet3 (now index 1)
3759        // should work without index mismatch.
3760        wb.add_comment(
3761            "Sheet3",
3762            &crate::comment::CommentConfig {
3763                cell: "B2".to_string(),
3764                author: "Test".to_string(),
3765                text: "note2".to_string(),
3766            },
3767        )
3768        .unwrap();
3769    }
3770
3771    #[test]
3772    fn test_delete_sheet_reindexes_local_names_and_all_active_tabs() {
3773        use sheetkit_xml::workbook::{DefinedName, DefinedNames};
3774
3775        let mut wb = Workbook::new();
3776        wb.new_sheet("Sheet2").unwrap();
3777        wb.new_sheet("Sheet3").unwrap();
3778        wb.set_defined_name("OnFirst", "Sheet1!$A$1", Some("Sheet1"), None)
3779            .unwrap();
3780        wb.set_defined_name("OnSecond", "Sheet2!$A$1", Some("Sheet2"), None)
3781            .unwrap();
3782        wb.set_defined_name("OnThird", "Sheet3!$A$1", Some("Sheet3"), None)
3783            .unwrap();
3784        wb.workbook_xml
3785            .defined_names
3786            .get_or_insert_with(|| DefinedNames {
3787                defined_names: vec![],
3788            })
3789            .defined_names
3790            .push(DefinedName {
3791                name: "Global".to_string(),
3792                local_sheet_id: None,
3793                comment: None,
3794                hidden: None,
3795                value: "Sheet3!$B$2".to_string(),
3796            });
3797        let views = wb.workbook_xml.book_views.as_mut().unwrap();
3798        let mut extra_view = views.workbook_views[0].clone();
3799        views.workbook_views[0].active_tab = Some(1);
3800        extra_view.active_tab = Some(99);
3801        views.workbook_views.push(extra_view);
3802
3803        wb.delete_sheet("Sheet2").unwrap();
3804
3805        let names = wb.workbook_xml.defined_names.as_ref().unwrap();
3806        assert!(names
3807            .defined_names
3808            .iter()
3809            .all(|name| name.name != "OnSecond"));
3810        assert_eq!(
3811            names
3812                .defined_names
3813                .iter()
3814                .find(|name| name.name == "OnThird")
3815                .unwrap()
3816                .local_sheet_id,
3817            Some(1)
3818        );
3819        assert_eq!(
3820            wb.workbook_xml
3821                .book_views
3822                .as_ref()
3823                .unwrap()
3824                .workbook_views
3825                .iter()
3826                .map(|view| view.active_tab)
3827                .collect::<Vec<_>>(),
3828            vec![Some(1), Some(1)]
3829        );
3830    }
3831
3832    #[test]
3833    fn test_delete_last_sheet_returns_error() {
3834        let mut wb = Workbook::new();
3835        let result = wb.delete_sheet("Sheet1");
3836        assert!(result.is_err());
3837    }
3838
3839    #[test]
3840    fn test_delete_nonexistent_sheet_returns_error() {
3841        let mut wb = Workbook::new();
3842        let result = wb.delete_sheet("NoSuchSheet");
3843        assert!(result.is_err());
3844        assert!(matches!(result.unwrap_err(), Error::SheetNotFound { .. }));
3845    }
3846
3847    #[test]
3848    fn test_set_sheet_name_basic() {
3849        let mut wb = Workbook::new();
3850        wb.set_sheet_name("Sheet1", "Renamed").unwrap();
3851        assert_eq!(wb.sheet_names(), vec!["Renamed"]);
3852    }
3853
3854    #[test]
3855    fn test_set_sheet_name_to_existing_returns_error() {
3856        let mut wb = Workbook::new();
3857        wb.new_sheet("Sheet2").unwrap();
3858        let result = wb.set_sheet_name("Sheet1", "Sheet2");
3859        assert!(result.is_err());
3860        assert!(matches!(
3861            result.unwrap_err(),
3862            Error::SheetAlreadyExists { .. }
3863        ));
3864    }
3865
3866    #[test]
3867    fn test_copy_sheet_basic() {
3868        let mut wb = Workbook::new();
3869        let idx = wb.copy_sheet("Sheet1", "Sheet1 Copy").unwrap();
3870        assert_eq!(idx, 1);
3871        assert_eq!(wb.sheet_names(), vec!["Sheet1", "Sheet1 Copy"]);
3872    }
3873
3874    #[test]
3875    fn test_copy_sheet_clones_mixed_relationship_graph_and_roundtrips() {
3876        use crate::chart::{ChartConfig, ChartSeries, ChartType};
3877        use crate::hyperlink::HyperlinkType;
3878        use crate::table::{TableColumn, TableConfig};
3879
3880        let mut wb = Workbook::new();
3881        wb.set_cell_hyperlink(
3882            "Sheet1",
3883            "A1",
3884            HyperlinkType::External("https://example.com/source".to_string()),
3885            Some("Source"),
3886            None,
3887        )
3888        .unwrap();
3889        wb.add_comment(
3890            "Sheet1",
3891            &crate::comment::CommentConfig {
3892                cell: "B2".to_string(),
3893                author: "Author".to_string(),
3894                text: "Copied note".to_string(),
3895            },
3896        )
3897        .unwrap();
3898        wb.add_threaded_comment(
3899            "Sheet1",
3900            "C3",
3901            &crate::threaded_comment::ThreadedCommentInput {
3902                author: "Author".to_string(),
3903                text: "Copied thread".to_string(),
3904                parent_id: None,
3905            },
3906        )
3907        .unwrap();
3908        wb.add_form_control(
3909            "Sheet1",
3910            crate::control::FormControlConfig::button("D4", "Copied control"),
3911        )
3912        .unwrap();
3913        wb.add_table(
3914            "Sheet1",
3915            &TableConfig {
3916                name: "SourceTable".to_string(),
3917                display_name: "SourceTable".to_string(),
3918                range: "A1:B3".to_string(),
3919                columns: vec![
3920                    TableColumn {
3921                        name: "Name".to_string(),
3922                        totals_row_function: None,
3923                        totals_row_label: None,
3924                    },
3925                    TableColumn {
3926                        name: "Value".to_string(),
3927                        totals_row_function: None,
3928                        totals_row_label: None,
3929                    },
3930                ],
3931                ..TableConfig::default()
3932            },
3933        )
3934        .unwrap();
3935        wb.add_chart(
3936            "Sheet1",
3937            "E1",
3938            "L10",
3939            &ChartConfig {
3940                chart_type: ChartType::Line,
3941                title: None,
3942                series: vec![ChartSeries {
3943                    name: "Series".to_string(),
3944                    categories: "Sheet1!$A$1:$A$3".to_string(),
3945                    values: "Sheet1!$B$1:$B$3".to_string(),
3946                    x_values: None,
3947                    bubble_sizes: None,
3948                }],
3949                show_legend: false,
3950                view_3d: None,
3951            },
3952        )
3953        .unwrap();
3954
3955        let source = wb.save_to_buffer().unwrap();
3956        let mut wb = Workbook::open_from_buffer(&source).unwrap();
3957
3958        wb.copy_sheet("Sheet1", "Copied").unwrap();
3959
3960        let copied_link = wb.get_cell_hyperlink("Copied", "A1").unwrap().unwrap();
3961        assert_eq!(
3962            copied_link.link_type,
3963            HyperlinkType::External("https://example.com/source".to_string())
3964        );
3965        assert_eq!(wb.get_comments("Copied").unwrap().len(), 1);
3966        assert_eq!(wb.get_threaded_comments("Copied").unwrap().len(), 1);
3967        assert_eq!(wb.get_form_controls("Copied").unwrap().len(), 1);
3968        let copied_tables = wb.get_tables("Copied").unwrap();
3969        assert_eq!(copied_tables.len(), 1);
3970        assert_ne!(copied_tables[0].name, "SourceTable");
3971        assert_eq!(wb.drawings.len(), 2);
3972        assert_eq!(wb.charts.len() + wb.raw_charts.len(), 2);
3973
3974        wb.delete_sheet("Sheet1").unwrap();
3975        let bytes = wb.save_to_buffer().unwrap();
3976        assert_package_integrity(&bytes);
3977        let mut archive = zip::ZipArchive::new(std::io::Cursor::new(bytes.clone())).unwrap();
3978        let names: Vec<String> = (0..archive.len())
3979            .map(|index| archive.by_index(index).unwrap().name().to_string())
3980            .collect();
3981        let unique_names: std::collections::HashSet<&str> =
3982            names.iter().map(String::as_str).collect();
3983        assert_eq!(names.len(), unique_names.len());
3984        assert_eq!(
3985            names
3986                .iter()
3987                .filter(|name| name.starts_with("xl/charts/chart"))
3988                .count(),
3989            1
3990        );
3991        let mut reopened = Workbook::open_from_buffer(&bytes).unwrap();
3992        assert_eq!(reopened.sheet_names(), vec!["Copied"]);
3993        assert!(reopened
3994            .get_cell_hyperlink("Copied", "A1")
3995            .unwrap()
3996            .is_some());
3997        assert_eq!(reopened.get_comments("Copied").unwrap().len(), 1);
3998        assert_eq!(reopened.get_threaded_comments("Copied").unwrap().len(), 1);
3999        assert_eq!(reopened.get_form_controls("Copied").unwrap().len(), 1);
4000        assert_eq!(reopened.get_tables("Copied").unwrap().len(), 1);
4001    }
4002
4003    #[test]
4004    fn test_delete_sheet_retargets_threaded_comments_by_surviving_sheet() {
4005        let mut wb = Workbook::new();
4006        wb.new_sheet("Second").unwrap();
4007        wb.new_sheet("Third").unwrap();
4008        for (sheet, text) in [("Second", "Second thread"), ("Third", "Third thread")] {
4009            wb.add_threaded_comment(
4010                sheet,
4011                "A1",
4012                &crate::threaded_comment::ThreadedCommentInput {
4013                    author: "Author".to_string(),
4014                    text: text.to_string(),
4015                    parent_id: None,
4016                },
4017            )
4018            .unwrap();
4019        }
4020
4021        wb.delete_sheet("Sheet1").unwrap();
4022        let bytes = wb.save_to_buffer().unwrap();
4023        let reopened = Workbook::open_from_buffer(&bytes).unwrap();
4024
4025        assert_eq!(
4026            reopened.get_threaded_comments("Second").unwrap()[0].text,
4027            "Second thread"
4028        );
4029        assert_eq!(
4030            reopened.get_threaded_comments("Third").unwrap()[0].text,
4031            "Third thread"
4032        );
4033    }
4034
4035    #[test]
4036    fn test_delete_last_threaded_sheet_removes_person_and_comment_parts() {
4037        let mut wb = Workbook::new();
4038        wb.new_sheet("Survivor").unwrap();
4039        wb.add_threaded_comment(
4040            "Sheet1",
4041            "A1",
4042            &crate::threaded_comment::ThreadedCommentInput {
4043                author: "Author".to_string(),
4044                text: "Removed thread".to_string(),
4045                parent_id: None,
4046            },
4047        )
4048        .unwrap();
4049
4050        wb.delete_sheet("Sheet1").unwrap();
4051        let bytes = wb.save_to_buffer().unwrap();
4052        let mut archive = zip::ZipArchive::new(std::io::Cursor::new(bytes.clone())).unwrap();
4053        let names: Vec<String> = (0..archive.len())
4054            .map(|index| archive.by_index(index).unwrap().name().to_string())
4055            .collect();
4056        assert!(!names
4057            .iter()
4058            .any(|name| name.starts_with("xl/threadedComments/")));
4059        assert!(!names.iter().any(|name| name == "xl/persons/person.xml"));
4060
4061        let reopened = Workbook::open_from_buffer(&bytes).unwrap();
4062        assert!(!reopened
4063            .workbook_rels
4064            .relationships
4065            .iter()
4066            .any(|relationship| {
4067                relationship.rel_type == sheetkit_xml::threaded_comment::REL_TYPE_PERSON
4068            }));
4069        assert!(!reopened.content_types.overrides.iter().any(|entry| {
4070            entry.content_type == sheetkit_xml::threaded_comment::THREADED_COMMENTS_CONTENT_TYPE
4071                || entry.content_type == sheetkit_xml::threaded_comment::PERSON_LIST_CONTENT_TYPE
4072        }));
4073    }
4074
4075    #[test]
4076    fn test_untouched_lazy_threaded_comments_survive_save() {
4077        let mut wb = Workbook::new();
4078        wb.add_threaded_comment(
4079            "Sheet1",
4080            "A1",
4081            &crate::threaded_comment::ThreadedCommentInput {
4082                author: "Author".to_string(),
4083                text: "Deferred thread".to_string(),
4084                parent_id: None,
4085            },
4086        )
4087        .unwrap();
4088        let original = wb.save_to_buffer().unwrap();
4089        let options = OpenOptions::new().read_mode(ReadMode::Lazy);
4090        let lazy = Workbook::open_from_buffer_with_options(&original, &options).unwrap();
4091
4092        let saved = lazy.save_to_buffer().unwrap();
4093        let reopened = Workbook::open_from_buffer(&saved).unwrap();
4094
4095        let comments = reopened.get_threaded_comments("Sheet1").unwrap();
4096        assert_eq!(comments.len(), 1);
4097        assert_eq!(comments[0].text, "Deferred thread");
4098        assert_eq!(reopened.get_persons().len(), 1);
4099    }
4100
4101    #[test]
4102    fn test_copy_sheet_rejects_unsupported_relationship_atomically() {
4103        let mut wb = Workbook::new();
4104        wb.worksheet_rels.insert(
4105            0,
4106            Relationships {
4107                xmlns: sheetkit_xml::namespaces::PACKAGE_RELATIONSHIPS.to_string(),
4108                relationships: vec![Relationship {
4109                    id: "rId1".to_string(),
4110                    rel_type: rel_types::PRINTER_SETTINGS.to_string(),
4111                    target: "../printerSettings/printerSettings1.bin".to_string(),
4112                    target_mode: None,
4113                }],
4114            },
4115        );
4116        let before_names: Vec<String> = wb.sheet_names().into_iter().map(str::to_string).collect();
4117        let before_sheet_count = wb.workbook_xml.sheets.sheets.len();
4118
4119        let error = wb.copy_sheet("Sheet1", "Copied").unwrap_err();
4120
4121        assert!(matches!(error, Error::InvalidArgument(_)));
4122        assert_eq!(
4123            wb.sheet_names(),
4124            before_names.iter().map(String::as_str).collect::<Vec<_>>()
4125        );
4126        assert_eq!(wb.workbook_xml.sheets.sheets.len(), before_sheet_count);
4127    }
4128
4129    fn assert_copy_rejected_without_mutation(mut wb: Workbook) {
4130        let before_names: Vec<String> = wb.sheet_names().into_iter().map(str::to_string).collect();
4131        assert!(matches!(
4132            wb.copy_sheet("Sheet1", "Copied"),
4133            Err(Error::InvalidArgument(_))
4134        ));
4135        assert_eq!(
4136            wb.sheet_names(),
4137            before_names.iter().map(String::as_str).collect::<Vec<_>>()
4138        );
4139    }
4140
4141    #[test]
4142    fn test_copy_sheet_rejects_unresolved_supported_relationships() {
4143        let relationship = |rel_type: &str, target: &str| Relationship {
4144            id: "rId99".to_string(),
4145            rel_type: rel_type.to_string(),
4146            target: target.to_string(),
4147            target_mode: None,
4148        };
4149
4150        let mut comments = Workbook::new();
4151        comments
4152            .add_comment(
4153                "Sheet1",
4154                &crate::comment::CommentConfig {
4155                    cell: "A1".to_string(),
4156                    author: "Author".to_string(),
4157                    text: "Note".to_string(),
4158                },
4159            )
4160            .unwrap();
4161        comments
4162            .worksheet_rels
4163            .entry(0)
4164            .or_insert_with(crate::workbook_paths::default_relationships)
4165            .relationships
4166            .push(relationship(rel_types::COMMENTS, "../comments99.xml"));
4167        assert_copy_rejected_without_mutation(comments);
4168
4169        let mut vml = Workbook::new();
4170        vml.sheet_vml[0] = Some(b"<xml/>".to_vec());
4171        vml.worksheet_rels
4172            .entry(0)
4173            .or_insert_with(crate::workbook_paths::default_relationships)
4174            .relationships
4175            .push(relationship(
4176                rel_types::VML_DRAWING,
4177                "../drawings/vmlDrawing99.vml",
4178            ));
4179        assert_copy_rejected_without_mutation(vml);
4180
4181        let mut table = Workbook::new();
4182        table
4183            .worksheet_rels
4184            .entry(0)
4185            .or_insert_with(crate::workbook_paths::default_relationships)
4186            .relationships
4187            .push(relationship(rel_types::TABLE, "../tables/table99.xml"));
4188        assert_copy_rejected_without_mutation(table);
4189
4190        let mut threaded = Workbook::new();
4191        threaded
4192            .add_threaded_comment(
4193                "Sheet1",
4194                "A1",
4195                &crate::threaded_comment::ThreadedCommentInput {
4196                    author: "Author".to_string(),
4197                    text: "Thread".to_string(),
4198                    parent_id: None,
4199                },
4200            )
4201            .unwrap();
4202        threaded
4203            .worksheet_rels
4204            .entry(0)
4205            .or_insert_with(crate::workbook_paths::default_relationships)
4206            .relationships
4207            .push(relationship(
4208                sheetkit_xml::threaded_comment::REL_TYPE_THREADED_COMMENT,
4209                "../threadedComments/threadedComment99.xml",
4210            ));
4211        assert_copy_rejected_without_mutation(threaded);
4212    }
4213
4214    #[test]
4215    fn test_copy_sheet_rejects_missing_drawing_relationships_and_rids() {
4216        use crate::chart::{ChartConfig, ChartSeries, ChartType};
4217        let config = ChartConfig {
4218            chart_type: ChartType::Line,
4219            title: None,
4220            series: vec![ChartSeries {
4221                name: "Series".to_string(),
4222                categories: "Sheet1!$A$1:$A$3".to_string(),
4223                values: "Sheet1!$B$1:$B$3".to_string(),
4224                x_values: None,
4225                bubble_sizes: None,
4226            }],
4227            show_legend: false,
4228            view_3d: None,
4229        };
4230
4231        let mut missing_rels = Workbook::new();
4232        missing_rels
4233            .add_chart("Sheet1", "E1", "L10", &config)
4234            .unwrap();
4235        missing_rels.drawing_rels.clear();
4236        assert_copy_rejected_without_mutation(missing_rels);
4237
4238        let mut missing_rid = Workbook::new();
4239        missing_rid
4240            .add_chart("Sheet1", "E1", "L10", &config)
4241            .unwrap();
4242        missing_rid.drawings[0].1.two_cell_anchors[0]
4243            .graphic_frame
4244            .as_mut()
4245            .unwrap()
4246            .graphic
4247            .graphic_data
4248            .chart
4249            .r_id = "missing".to_string();
4250        assert_copy_rejected_without_mutation(missing_rid);
4251    }
4252
4253    #[test]
4254    fn test_copy_sheet_rejects_unresolved_worksheet_rids_atomically() {
4255        let mut drawing = Workbook::new();
4256        drawing.worksheets[0].1.get_mut().unwrap().drawing =
4257            Some(sheetkit_xml::worksheet::DrawingRef {
4258                r_id: "missingDrawing".to_string(),
4259            });
4260        assert_copy_rejected_without_mutation(drawing);
4261
4262        let mut legacy = Workbook::new();
4263        legacy.worksheets[0].1.get_mut().unwrap().legacy_drawing =
4264            Some(sheetkit_xml::worksheet::LegacyDrawingRef {
4265                r_id: "missingLegacy".to_string(),
4266            });
4267        assert_copy_rejected_without_mutation(legacy);
4268
4269        let mut hyperlink = Workbook::new();
4270        hyperlink.worksheets[0].1.get_mut().unwrap().hyperlinks =
4271            Some(sheetkit_xml::worksheet::Hyperlinks {
4272                hyperlinks: vec![sheetkit_xml::worksheet::Hyperlink {
4273                    reference: "A1".to_string(),
4274                    r_id: Some("missingHyperlink".to_string()),
4275                    location: None,
4276                    display: None,
4277                    tooltip: None,
4278                }],
4279            });
4280        assert_copy_rejected_without_mutation(hyperlink);
4281
4282        let mut table = Workbook::new();
4283        table.worksheets[0].1.get_mut().unwrap().table_parts =
4284            Some(sheetkit_xml::worksheet::TableParts {
4285                count: Some(1),
4286                table_parts: vec![sheetkit_xml::worksheet::TablePart {
4287                    r_id: "missingTable".to_string(),
4288                }],
4289            });
4290        assert_copy_rejected_without_mutation(table);
4291
4292        let mut page_setup = Workbook::new();
4293        page_setup.worksheets[0].1.get_mut().unwrap().page_setup =
4294            Some(sheetkit_xml::worksheet::PageSetup {
4295                paper_size: None,
4296                orientation: None,
4297                scale: None,
4298                fit_to_width: None,
4299                fit_to_height: None,
4300                first_page_number: None,
4301                horizontal_dpi: None,
4302                vertical_dpi: None,
4303                r_id: Some("missingPrinter".to_string()),
4304            });
4305        assert_copy_rejected_without_mutation(page_setup);
4306    }
4307
4308    #[test]
4309    fn test_copy_sheet_clones_image_and_source_delete_keeps_copy() {
4310        use crate::image::{ImageConfig, ImageFormat};
4311        let mut wb = Workbook::new();
4312        wb.add_image(
4313            "Sheet1",
4314            &ImageConfig {
4315                data: vec![0x89, 0x50, 0x4e, 0x47],
4316                format: ImageFormat::Png,
4317                from_cell: "B2".to_string(),
4318                width_px: 32,
4319                height_px: 32,
4320            },
4321        )
4322        .unwrap();
4323
4324        wb.copy_sheet("Sheet1", "Copied").unwrap();
4325        assert_eq!(wb.images.len(), 2);
4326        assert_ne!(wb.images[0].0, wb.images[1].0);
4327        assert_eq!(wb.images[0].1, wb.images[1].1);
4328
4329        wb.delete_sheet("Sheet1").unwrap();
4330        assert_eq!(wb.images.len(), 1);
4331        let bytes = wb.save_to_buffer().unwrap();
4332        assert_package_integrity(&bytes);
4333        let mut archive = zip::ZipArchive::new(std::io::Cursor::new(bytes.clone())).unwrap();
4334        let media_count = (0..archive.len())
4335            .filter(|index| {
4336                archive
4337                    .by_index(*index)
4338                    .unwrap()
4339                    .name()
4340                    .starts_with("xl/media/")
4341            })
4342            .count();
4343        assert_eq!(media_count, 1);
4344        Workbook::open_from_buffer(&bytes).unwrap();
4345    }
4346
4347    #[test]
4348    fn test_delete_sheet_retains_image_referenced_by_surviving_drawing() {
4349        use crate::image::{ImageConfig, ImageFormat};
4350        let config = ImageConfig {
4351            data: vec![0x89, 0x50, 0x4e, 0x47],
4352            format: ImageFormat::Png,
4353            from_cell: "B2".to_string(),
4354            width_px: 32,
4355            height_px: 32,
4356        };
4357        let mut wb = Workbook::new();
4358        wb.add_image("Sheet1", &config).unwrap();
4359        wb.new_sheet("Survivor").unwrap();
4360        wb.add_image("Survivor", &config).unwrap();
4361        let shared_image_path = wb.images[0].0.clone();
4362        let survivor_drawing_idx = wb.worksheet_drawings[&1];
4363        let survivor_drawing_path = wb.drawings[survivor_drawing_idx].0.clone();
4364        wb.drawing_rels
4365            .get_mut(&survivor_drawing_idx)
4366            .unwrap()
4367            .relationships[0]
4368            .target = crate::workbook_paths::relative_relationship_target(
4369            &survivor_drawing_path,
4370            &shared_image_path,
4371        );
4372        wb.images.remove(1);
4373
4374        wb.delete_sheet("Sheet1").unwrap();
4375
4376        assert_eq!(wb.images.len(), 1);
4377        assert_eq!(wb.images[0].0, shared_image_path);
4378        let bytes = wb.save_to_buffer().unwrap();
4379        assert_package_integrity(&bytes);
4380    }
4381
4382    #[test]
4383    fn test_copy_sheet_remaps_threaded_reply_ids() {
4384        let mut wb = Workbook::new();
4385        let root_id = wb
4386            .add_threaded_comment(
4387                "Sheet1",
4388                "A1",
4389                &crate::threaded_comment::ThreadedCommentInput {
4390                    author: "Author".to_string(),
4391                    text: "Root".to_string(),
4392                    parent_id: None,
4393                },
4394            )
4395            .unwrap();
4396        wb.add_threaded_comment(
4397            "Sheet1",
4398            "A1",
4399            &crate::threaded_comment::ThreadedCommentInput {
4400                author: "Author".to_string(),
4401                text: "Reply".to_string(),
4402                parent_id: Some(root_id),
4403            },
4404        )
4405        .unwrap();
4406
4407        wb.copy_sheet("Sheet1", "Copied").unwrap();
4408        let source = wb.sheet_threaded_comments[0].as_ref().unwrap();
4409        let copied = wb.sheet_threaded_comments[1].as_ref().unwrap();
4410        let source_ids: std::collections::HashSet<&str> = source
4411            .comments
4412            .iter()
4413            .map(|comment| comment.id.as_str())
4414            .collect();
4415        assert!(copied
4416            .comments
4417            .iter()
4418            .all(|comment| !source_ids.contains(comment.id.as_str())));
4419        assert_eq!(
4420            copied.comments[1].parent_id.as_deref(),
4421            Some(copied.comments[0].id.as_str())
4422        );
4423        assert_eq!(source.comments[0].person_id, copied.comments[0].person_id);
4424    }
4425
4426    #[test]
4427    fn test_copy_sheet_table_id_overflow_is_atomic() {
4428        use crate::table::{TableColumn, TableConfig};
4429        let mut wb = Workbook::new();
4430        wb.add_table(
4431            "Sheet1",
4432            &TableConfig {
4433                name: "AtLimit".to_string(),
4434                display_name: "AtLimit".to_string(),
4435                range: "A1:A2".to_string(),
4436                columns: vec![TableColumn {
4437                    name: "Value".to_string(),
4438                    totals_row_function: None,
4439                    totals_row_label: None,
4440                }],
4441                ..TableConfig::default()
4442            },
4443        )
4444        .unwrap();
4445        wb.tables[0].1.id = u32::MAX;
4446        assert_copy_rejected_without_mutation(wb);
4447    }
4448
4449    #[test]
4450    fn test_delete_sheet_rejects_pivot_and_slicer_closure_atomically() {
4451        use crate::workbook::aux::AuxCategory;
4452        for rel_type in [rel_types::PIVOT_TABLE, rel_types::SLICER] {
4453            let mut wb = Workbook::new();
4454            wb.new_sheet("Survivor").unwrap();
4455            wb.worksheet_rels.insert(
4456                0,
4457                Relationships {
4458                    xmlns: sheetkit_xml::namespaces::PACKAGE_RELATIONSHIPS.to_string(),
4459                    relationships: vec![Relationship {
4460                        id: "rId1".to_string(),
4461                        rel_type: rel_type.to_string(),
4462                        target: "../unsupported/part1.xml".to_string(),
4463                        target_mode: None,
4464                    }],
4465                },
4466            );
4467            wb.deferred_parts.insert(
4468                "xl/pivotTables/pivotTable1.xml".to_string(),
4469                b"deferred".to_vec(),
4470            );
4471            assert!(matches!(
4472                wb.delete_sheet("Sheet1"),
4473                Err(Error::InvalidArgument(_))
4474            ));
4475            assert_eq!(wb.sheet_names(), vec!["Sheet1", "Survivor"]);
4476            assert!(wb.deferred_parts.has_category(AuxCategory::PivotTables));
4477        }
4478    }
4479
4480    #[test]
4481    fn test_copy_sheet_skips_unknown_part_path_collisions() {
4482        use crate::chart::{ChartConfig, ChartSeries, ChartType};
4483
4484        let mut wb = Workbook::new();
4485        wb.add_chart(
4486            "Sheet1",
4487            "E1",
4488            "L10",
4489            &ChartConfig {
4490                chart_type: ChartType::Line,
4491                title: None,
4492                series: vec![ChartSeries {
4493                    name: "Series".to_string(),
4494                    categories: "Sheet1!$A$1:$A$3".to_string(),
4495                    values: "Sheet1!$B$1:$B$3".to_string(),
4496                    x_values: None,
4497                    bubble_sizes: None,
4498                }],
4499                show_legend: false,
4500                view_3d: None,
4501            },
4502        )
4503        .unwrap();
4504        wb.unknown_parts.extend([
4505            ("xl/drawings/drawing2.xml".to_string(), b"opaque".to_vec()),
4506            ("xl/charts/chart2.xml".to_string(), b"opaque".to_vec()),
4507        ]);
4508
4509        wb.copy_sheet("Sheet1", "Copied").unwrap();
4510
4511        assert!(wb
4512            .drawings
4513            .iter()
4514            .any(|(path, _)| path == "xl/drawings/drawing3.xml"));
4515        assert!(wb
4516            .charts
4517            .iter()
4518            .any(|(path, _)| path == "xl/charts/chart3.xml"));
4519    }
4520
4521    #[test]
4522    fn test_normal_drawing_chart_and_image_allocation_skips_reserved_paths() {
4523        use crate::chart::{ChartConfig, ChartSeries, ChartType};
4524        use crate::image::{ImageConfig, ImageFormat};
4525        let mut wb = Workbook::new();
4526        wb.unknown_parts.extend([
4527            ("xl/drawings/drawing1.xml".to_string(), b"opaque".to_vec()),
4528            ("xl/charts/chart1.xml".to_string(), b"opaque".to_vec()),
4529            ("xl/media/image1.png".to_string(), b"opaque".to_vec()),
4530        ]);
4531        wb.content_types.overrides.extend([
4532            ContentTypeOverride {
4533                part_name: "/xl/drawings/drawing2.xml".to_string(),
4534                content_type: mime_types::DRAWING.to_string(),
4535            },
4536            ContentTypeOverride {
4537                part_name: "/xl/charts/chart2.xml".to_string(),
4538                content_type: mime_types::CHART.to_string(),
4539            },
4540        ]);
4541        wb.add_chart(
4542            "Sheet1",
4543            "E1",
4544            "L10",
4545            &ChartConfig {
4546                chart_type: ChartType::Line,
4547                title: None,
4548                series: vec![ChartSeries {
4549                    name: "Series".to_string(),
4550                    categories: "Sheet1!$A$1:$A$3".to_string(),
4551                    values: "Sheet1!$B$1:$B$3".to_string(),
4552                    x_values: None,
4553                    bubble_sizes: None,
4554                }],
4555                show_legend: false,
4556                view_3d: None,
4557            },
4558        )
4559        .unwrap();
4560        wb.add_image(
4561            "Sheet1",
4562            &ImageConfig {
4563                data: vec![0x89, 0x50, 0x4e, 0x47],
4564                format: ImageFormat::Png,
4565                from_cell: "B2".to_string(),
4566                width_px: 32,
4567                height_px: 32,
4568            },
4569        )
4570        .unwrap();
4571
4572        assert_eq!(wb.drawings[0].0, "xl/drawings/drawing3.xml");
4573        assert_eq!(wb.charts[0].0, "xl/charts/chart3.xml");
4574        assert_eq!(wb.images[0].0, "xl/media/image2.png");
4575    }
4576
4577    #[test]
4578    fn test_save_rejects_raw_collision_without_dropping_unknown_part() {
4579        let mut wb = Workbook::new();
4580        wb.unknown_parts
4581            .push(("xl/comments1.xml".to_string(), b"opaque".to_vec()));
4582        wb.add_comment(
4583            "Sheet1",
4584            &crate::comment::CommentConfig {
4585                cell: "A1".to_string(),
4586                author: "Author".to_string(),
4587                text: "Note".to_string(),
4588            },
4589        )
4590        .unwrap();
4591
4592        assert!(matches!(
4593            wb.save_to_buffer(),
4594            Err(Error::InvalidArgument(_))
4595        ));
4596        assert_eq!(wb.unknown_parts[0].0, "xl/comments1.xml");
4597        assert_eq!(wb.unknown_parts[0].1, b"opaque");
4598    }
4599
4600    #[test]
4601    fn test_save_rejects_relationship_part_collision_before_writing() {
4602        use crate::hyperlink::HyperlinkType;
4603        let mut wb = Workbook::new();
4604        wb.set_cell_hyperlink(
4605            "Sheet1",
4606            "A1",
4607            HyperlinkType::External("https://example.com".to_string()),
4608            None,
4609            None,
4610        )
4611        .unwrap();
4612        let rel_path = crate::workbook_paths::relationship_part_path(&wb.sheet_part_path(0));
4613        wb.unknown_parts
4614            .push((rel_path.clone(), b"preserved relationships".to_vec()));
4615
4616        assert!(matches!(
4617            wb.save_to_buffer(),
4618            Err(Error::InvalidArgument(_))
4619        ));
4620        assert_eq!(wb.unknown_parts[0].0, rel_path);
4621        assert_eq!(wb.unknown_parts[0].1, b"preserved relationships");
4622
4623        wb.unknown_parts.clear();
4624        let bytes = wb.save_to_buffer().unwrap();
4625        assert_package_integrity(&bytes);
4626    }
4627
4628    #[test]
4629    fn test_delete_sheet_rejects_malformed_deferred_lifecycle_part_atomically() {
4630        use crate::workbook::aux::AuxCategory;
4631
4632        let mut wb = Workbook::new();
4633        wb.new_sheet("Survivor").unwrap();
4634        wb.worksheet_rels.insert(
4635            0,
4636            Relationships {
4637                xmlns: sheetkit_xml::namespaces::PACKAGE_RELATIONSHIPS.to_string(),
4638                relationships: vec![Relationship {
4639                    id: "rId1".to_string(),
4640                    rel_type: rel_types::COMMENTS.to_string(),
4641                    target: "../comments1.xml".to_string(),
4642                    target_mode: None,
4643                }],
4644            },
4645        );
4646        assert!(wb.deferred_parts.insert(
4647            "xl/comments1.xml".to_string(),
4648            b"<comments><broken>".to_vec(),
4649        ));
4650        assert!(wb.deferred_parts.has_category(AuxCategory::Comments));
4651        let before_names: Vec<String> = wb.sheet_names().into_iter().map(str::to_string).collect();
4652
4653        let error = wb.delete_sheet("Sheet1").unwrap_err();
4654
4655        assert!(matches!(error, Error::XmlDeserialize(_)));
4656        assert_eq!(
4657            wb.sheet_names(),
4658            before_names.iter().map(String::as_str).collect::<Vec<_>>()
4659        );
4660        assert!(wb.deferred_parts.has_category(AuxCategory::Comments));
4661    }
4662
4663    #[test]
4664    fn test_get_sheet_index() {
4665        let mut wb = Workbook::new();
4666        wb.new_sheet("Sheet2").unwrap();
4667        assert_eq!(wb.get_sheet_index("Sheet1"), Some(0));
4668        assert_eq!(wb.get_sheet_index("Sheet2"), Some(1));
4669        assert_eq!(wb.get_sheet_index("Nonexistent"), None);
4670    }
4671
4672    #[test]
4673    fn test_get_active_sheet_default() {
4674        let wb = Workbook::new();
4675        assert_eq!(wb.get_active_sheet(), "Sheet1");
4676    }
4677
4678    #[test]
4679    fn test_get_active_sheet_is_safe_for_empty_workbook() {
4680        let mut wb = Workbook::new();
4681        wb.worksheets.clear();
4682
4683        assert_eq!(wb.get_active_sheet(), "");
4684    }
4685
4686    #[test]
4687    fn test_set_active_sheet() {
4688        let mut wb = Workbook::new();
4689        wb.new_sheet("Sheet2").unwrap();
4690        wb.set_active_sheet("Sheet2").unwrap();
4691        assert_eq!(wb.get_active_sheet(), "Sheet2");
4692    }
4693
4694    #[test]
4695    fn test_set_active_sheet_not_found() {
4696        let mut wb = Workbook::new();
4697        let result = wb.set_active_sheet("NoSuchSheet");
4698        assert!(result.is_err());
4699        assert!(matches!(result.unwrap_err(), Error::SheetNotFound { .. }));
4700    }
4701
4702    #[test]
4703    fn test_sheet_management_roundtrip_save_open() {
4704        let dir = TempDir::new().unwrap();
4705        let path = dir.path().join("sheet_mgmt.xlsx");
4706
4707        let mut wb = Workbook::new();
4708        wb.new_sheet("Data").unwrap();
4709        wb.new_sheet("Summary").unwrap();
4710        wb.set_sheet_name("Sheet1", "Overview").unwrap();
4711        wb.save(&path).unwrap();
4712
4713        let wb2 = Workbook::open(&path).unwrap();
4714        assert_eq!(wb2.sheet_names(), vec!["Overview", "Data", "Summary"]);
4715    }
4716
4717    #[test]
4718    fn test_workbook_insert_rows() {
4719        let mut wb = Workbook::new();
4720        wb.set_cell_value("Sheet1", "A1", "stay").unwrap();
4721        wb.set_cell_value("Sheet1", "A2", "shift").unwrap();
4722        wb.insert_rows("Sheet1", 2, 1).unwrap();
4723
4724        assert_eq!(
4725            wb.get_cell_value("Sheet1", "A1").unwrap(),
4726            CellValue::String("stay".to_string())
4727        );
4728        assert_eq!(
4729            wb.get_cell_value("Sheet1", "A3").unwrap(),
4730            CellValue::String("shift".to_string())
4731        );
4732        assert_eq!(wb.get_cell_value("Sheet1", "A2").unwrap(), CellValue::Empty);
4733    }
4734
4735    #[test]
4736    fn test_zero_count_structural_edits_leave_lazy_sheet_clean() {
4737        let dir = TempDir::new().unwrap();
4738        let path = dir.path().join("zero_count_structural_edit.xlsx");
4739        Workbook::new().save(&path).unwrap();
4740
4741        let mut wb = Workbook::open(&path).unwrap();
4742        assert!(!wb.is_sheet_dirty(0));
4743
4744        wb.insert_rows("Sheet1", 1, 0).unwrap();
4745        wb.insert_cols("Sheet1", "A", 0).unwrap();
4746
4747        assert!(!wb.is_sheet_dirty(0));
4748    }
4749
4750    #[test]
4751    fn test_workbook_insert_rows_updates_formula_and_ranges() {
4752        let mut wb = Workbook::new();
4753        wb.set_cell_value(
4754            "Sheet1",
4755            "C1",
4756            CellValue::Formula {
4757                expr: "SUM(A2:B2)".to_string(),
4758                result: None,
4759            },
4760        )
4761        .unwrap();
4762        wb.add_data_validation(
4763            "Sheet1",
4764            &crate::validation::DataValidationConfig::whole_number("A2:A5", 1, 9),
4765        )
4766        .unwrap();
4767        wb.set_auto_filter("Sheet1", "A2:B10").unwrap();
4768        wb.merge_cells("Sheet1", "A2", "B3").unwrap();
4769
4770        wb.insert_rows("Sheet1", 2, 1).unwrap();
4771
4772        match wb.get_cell_value("Sheet1", "C1").unwrap() {
4773            CellValue::Formula { expr, .. } => assert_eq!(expr, "SUM(A3:B3)"),
4774            other => panic!("expected formula, got {other:?}"),
4775        }
4776
4777        let validations = wb.get_data_validations("Sheet1").unwrap();
4778        assert_eq!(validations.len(), 1);
4779        assert_eq!(validations[0].sqref, "A3:A6");
4780
4781        let merges = wb.get_merge_cells("Sheet1").unwrap();
4782        assert_eq!(merges, vec!["A3:B4".to_string()]);
4783
4784        let ws = wb.worksheet_ref("Sheet1").unwrap();
4785        assert_eq!(ws.auto_filter.as_ref().unwrap().reference, "A3:B11");
4786    }
4787
4788    #[test]
4789    fn test_structural_edit_updates_target_references_workbook_wide() {
4790        let mut wb = Workbook::new();
4791        wb.new_sheet("Other").unwrap();
4792        wb.new_sheet("다른 시트").unwrap();
4793        wb.set_cell_formula(
4794            "Other",
4795            "C1",
4796            "sheet1!A2+'다른 시트'!A2+A2+\"A2\"+LOG10(A2)",
4797        )
4798        .unwrap();
4799        wb.set_defined_name("BookRange", "Sheet1!$A$2:$A$3", None, None)
4800            .unwrap();
4801        wb.set_defined_name("LocalRange", "$A$2:$A$3", Some("Sheet1"), None)
4802            .unwrap();
4803        wb.set_defined_name("OtherRange", "$A$2:$A$3+Sheet1!A2", Some("Other"), None)
4804            .unwrap();
4805        wb.add_sparkline(
4806            "Other",
4807            &crate::sparkline::SparklineConfig::new("Sheet1!A2:A3", "B2"),
4808        )
4809        .unwrap();
4810        wb.add_table(
4811            "Sheet1",
4812            &crate::table::TableConfig {
4813                name: "ShiftedTable".into(),
4814                display_name: "ShiftedTable".into(),
4815                range: "A2:B4".into(),
4816                columns: vec![
4817                    crate::table::TableColumn {
4818                        name: "First".into(),
4819                        totals_row_function: None,
4820                        totals_row_label: None,
4821                    },
4822                    crate::table::TableColumn {
4823                        name: "Second".into(),
4824                        totals_row_function: None,
4825                        totals_row_label: None,
4826                    },
4827                ],
4828                ..Default::default()
4829            },
4830        )
4831        .unwrap();
4832        wb.set_cell_formula("Sheet1", "A2", "A2").unwrap();
4833
4834        {
4835            let ws = wb.worksheet_mut("Sheet1").unwrap();
4836            let formula = ws.sheet_data.rows[0].cells[0].f.as_mut().unwrap();
4837            formula.t = Some("shared".into());
4838            formula.reference = Some("A2:B2".into());
4839            formula.si = Some(0);
4840        }
4841
4842        wb.insert_rows("Sheet1", 2, 1).unwrap();
4843
4844        match wb.get_cell_value("Other", "C1").unwrap() {
4845            CellValue::Formula { expr, .. } => {
4846                assert_eq!(expr, "sheet1!A3+'다른 시트'!A2+A2+\"A2\"+LOG10(A2)");
4847            }
4848            value => panic!("expected formula, got {value:?}"),
4849        }
4850        assert_eq!(
4851            wb.get_defined_name("BookRange", None)
4852                .unwrap()
4853                .unwrap()
4854                .value,
4855            "Sheet1!$A$3:$A$4"
4856        );
4857        assert_eq!(
4858            wb.get_defined_name("LocalRange", Some("Sheet1"))
4859                .unwrap()
4860                .unwrap()
4861                .value,
4862            "$A$3:$A$4"
4863        );
4864        assert_eq!(
4865            wb.get_defined_name("OtherRange", Some("Other"))
4866                .unwrap()
4867                .unwrap()
4868                .value,
4869            "$A$2:$A$3+Sheet1!A3"
4870        );
4871        assert_eq!(
4872            wb.get_sparklines("Other").unwrap()[0].data_range,
4873            "Sheet1!A3:A4"
4874        );
4875        assert_eq!(wb.get_sparklines("Other").unwrap()[0].location, "B2");
4876        let shared = wb.worksheet_ref("Sheet1").unwrap().sheet_data.rows[0].cells[0]
4877            .f
4878            .as_ref()
4879            .unwrap();
4880        assert_eq!(shared.reference.as_deref(), Some("A3:B3"));
4881        assert_eq!(wb.get_tables("Sheet1").unwrap()[0].range, "A3:B5");
4882        assert_eq!(
4883            wb.tables[0].1.auto_filter.as_ref().unwrap().reference,
4884            "A3:B5"
4885        );
4886    }
4887
4888    #[test]
4889    fn lazy_sparklines_are_materialized_for_copy_and_structural_edits() {
4890        let mut source = Workbook::new();
4891        source
4892            .add_sparkline(
4893                "Sheet1",
4894                &crate::sparkline::SparklineConfig::new("Sheet1!A2:A3", "B2"),
4895            )
4896            .unwrap();
4897        let bytes = source.save_to_buffer().unwrap();
4898        let mut workbook = Workbook::open_from_buffer(&bytes).unwrap();
4899
4900        workbook.copy_sheet("Sheet1", "Copy").unwrap();
4901        assert_eq!(workbook.get_sparklines("Copy").unwrap().len(), 1);
4902
4903        workbook.insert_rows("Sheet1", 2, 1).unwrap();
4904        let original = workbook.get_sparklines("Sheet1").unwrap();
4905        assert_eq!(original[0].data_range, "Sheet1!A3:A4");
4906        assert_eq!(original[0].location, "B3");
4907        let copied = workbook.get_sparklines("Copy").unwrap();
4908        assert_eq!(copied[0].data_range, "Sheet1!A3:A4");
4909        assert_eq!(copied[0].location, "B2");
4910    }
4911
4912    #[test]
4913    fn structural_edit_targets_sparkline_elements_not_matching_cell_references() {
4914        let mut source = Workbook::new();
4915        source.set_cell_value("Sheet1", "B2", 42).unwrap();
4916        source
4917            .add_sparkline(
4918                "Sheet1",
4919                &crate::sparkline::SparklineConfig::new("Sheet1!A2:A3", "B2"),
4920            )
4921            .unwrap();
4922        let bytes = source.save_to_buffer().unwrap();
4923        let mut workbook = Workbook::open_from_buffer(&bytes).unwrap();
4924
4925        workbook.insert_rows("Sheet1", 2, 1).unwrap();
4926
4927        assert_eq!(
4928            workbook.get_cell_value("Sheet1", "B3").unwrap(),
4929            CellValue::Number(42.0)
4930        );
4931        let sparklines = workbook.get_sparklines("Sheet1").unwrap();
4932        assert_eq!(sparklines[0].data_range, "Sheet1!A3:A4");
4933        assert_eq!(sparklines[0].location, "B3");
4934    }
4935
4936    #[test]
4937    fn structural_edit_shifts_sparklines_that_share_a_data_range() {
4938        let mut source = Workbook::new();
4939        for location in ["B2", "C2"] {
4940            source
4941                .add_sparkline(
4942                    "Sheet1",
4943                    &crate::sparkline::SparklineConfig::new("Sheet1!A2:A3", location),
4944                )
4945                .unwrap();
4946        }
4947        let bytes = source.save_to_buffer().unwrap();
4948        let mut workbook = Workbook::open_from_buffer(&bytes).unwrap();
4949
4950        workbook.insert_rows("Sheet1", 2, 1).unwrap();
4951
4952        let sparklines = workbook.get_sparklines("Sheet1").unwrap();
4953        assert_eq!(sparklines.len(), 2);
4954        assert!(sparklines
4955            .iter()
4956            .all(|sparkline| sparkline.data_range == "Sheet1!A3:A4"));
4957        assert_eq!(sparklines[0].location, "B3");
4958        assert_eq!(sparklines[1].location, "C3");
4959        let saved = workbook.save_to_buffer().unwrap();
4960        let sheet = String::from_utf8(zip_part(&saved, "xl/worksheets/sheet1.xml")).unwrap();
4961        assert_eq!(sheet.matches("<xm:f>Sheet1!A3:A4</xm:f>").count(), 2);
4962    }
4963
4964    #[test]
4965    fn structural_edit_rejects_unpatchable_sparkline_xml_atomically() {
4966        let mut source = Workbook::new();
4967        source.set_cell_value("Sheet1", "B2", 42).unwrap();
4968        source
4969            .add_sparkline(
4970                "Sheet1",
4971                &crate::sparkline::SparklineConfig::new("Sheet1!A2:A3", "B2"),
4972            )
4973            .unwrap();
4974        let bytes = source.save_to_buffer().unwrap();
4975        let mut workbook = Workbook::open_from_buffer(&bytes).unwrap();
4976        workbook.hydrate_sparklines_for_sheet(0);
4977        assert_eq!(workbook.sheet_sparklines[0][0].location, "B2");
4978        let raw = String::from_utf8(workbook.raw_sheet_extensions[0].clone().unwrap()).unwrap();
4979        workbook.raw_sheet_extensions[0] = Some(
4980            raw.replace("<xm:sqref>B2</xm:sqref>", "<xm:sqref>B2:B2</xm:sqref>")
4981                .into_bytes(),
4982        );
4983        let before = workbook.save_to_buffer().unwrap();
4984
4985        let error = workbook.insert_rows("Sheet1", 2, 1).unwrap_err();
4986
4987        assert!(matches!(error, Error::InvalidArgument(_)));
4988        assert_eq!(workbook.save_to_buffer().unwrap(), before);
4989        assert_eq!(
4990            workbook.get_cell_value("Sheet1", "B2").unwrap(),
4991            CellValue::Number(42.0)
4992        );
4993        assert!(!workbook.is_sheet_dirty(0));
4994    }
4995
4996    #[test]
4997    fn structural_edit_preserves_raw_sparkline_group_metadata() {
4998        let mut source = Workbook::new();
4999        source
5000            .add_sparkline(
5001                "Sheet1",
5002                &crate::sparkline::SparklineConfig::new("Sheet1!A2:A3", "B2"),
5003            )
5004            .unwrap();
5005        let bytes = source.save_to_buffer().unwrap();
5006        let mut workbook = Workbook::open_from_buffer(&bytes).unwrap();
5007        workbook.hydrate_sparklines_for_sheet(0);
5008        let raw = String::from_utf8(workbook.raw_sheet_extensions[0].clone().unwrap()).unwrap();
5009        workbook.raw_sheet_extensions[0] = Some(
5010            raw.replace(
5011                "</x14:sparklineGroup>",
5012                "<x14:colorSeries rgb=\"FF112233\"/><x14:colorAxis rgb=\"FF445566\"/><x14:displayEmptyCellsAs val=\"span\"/></x14:sparklineGroup>",
5013            )
5014            .into_bytes(),
5015        );
5016
5017        workbook.insert_rows("Sheet1", 2, 1).unwrap();
5018        let saved = workbook.save_to_buffer().unwrap();
5019        let sheet = String::from_utf8(zip_part(&saved, "xl/worksheets/sheet1.xml")).unwrap();
5020        assert!(sheet.contains("colorSeries rgb=\"FF112233\""));
5021        assert!(sheet.contains("colorAxis rgb=\"FF445566\""));
5022        assert!(sheet.contains("displayEmptyCellsAs val=\"span\""));
5023        assert!(sheet.contains("Sheet1!A3:A4"));
5024        assert!(sheet.contains("<xm:sqref>B3</xm:sqref>"));
5025    }
5026
5027    #[test]
5028    fn structural_edit_preserves_advanced_raw_chart_and_drawing_fragments() {
5029        let mut source = Workbook::new();
5030        source.set_cell_value("Sheet1", "A2", 1).unwrap();
5031        source.set_cell_value("Sheet1", "B2", 2).unwrap();
5032        source
5033            .add_chart(
5034                "Sheet1",
5035                "D2",
5036                "J12",
5037                &ChartConfig {
5038                    chart_type: ChartType::Line,
5039                    title: None,
5040                    series: vec![ChartSeries {
5041                        name: "Series".into(),
5042                        categories: "Sheet1!A2:A2".into(),
5043                        values: "Sheet1!B2:B2".into(),
5044                        x_values: None,
5045                        bubble_sizes: None,
5046                    }],
5047                    show_legend: false,
5048                    view_3d: None,
5049                },
5050            )
5051            .unwrap();
5052        source
5053            .add_image(
5054                "Sheet1",
5055                &ImageConfig {
5056                    data: vec![0x89, 0x50, 0x4e, 0x47],
5057                    format: ImageFormat::Png,
5058                    from_cell: "B2".into(),
5059                    width_px: 8,
5060                    height_px: 8,
5061                },
5062            )
5063            .unwrap();
5064        let bytes = source.save_to_buffer().unwrap();
5065        let drawing_path = source.drawings[0].0.clone();
5066        let chart_path = source.charts[0].0.clone();
5067        let drawing = String::from_utf8(zip_part(&bytes, &drawing_path)).unwrap();
5068        let chart = String::from_utf8(zip_part(&bytes, &chart_path)).unwrap();
5069        source.raw_graph_parts.insert(
5070            drawing_path.clone(),
5071            drawing
5072                .replace("</wsDr>", "<xdr:opaque><xdr:keep/></xdr:opaque></wsDr>")
5073                .into_bytes(),
5074        );
5075        source.dirty_graph_parts.remove(&drawing_path);
5076        source.raw_graph_parts.insert(
5077            chart_path.clone(),
5078            chart
5079                .replace("</chartSpace>", "<c:extLst><c:ext uri=\"{opaque}\"><c:dLbls/><c:dateAx/><c:spPr/></c:ext></c:extLst></chartSpace>")
5080                .into_bytes(),
5081        );
5082        source.dirty_graph_parts.remove(&chart_path);
5083
5084        source.insert_rows("Sheet1", 2, 1).unwrap();
5085        let saved = source.save_to_buffer().unwrap();
5086        let drawing = String::from_utf8(zip_part(&saved, &drawing_path)).unwrap();
5087        let chart = String::from_utf8(zip_part(&saved, &chart_path)).unwrap();
5088        assert!(drawing.contains("<xdr:opaque><xdr:keep/></xdr:opaque>"));
5089        assert!(chart.contains("<c:dLbls/><c:dateAx/><c:spPr/>"));
5090        assert!(chart.contains("Sheet1!A3:A3"));
5091    }
5092
5093    #[test]
5094    fn structural_edit_rejects_unpatchable_raw_drawing_before_mutation() {
5095        let mut workbook = Workbook::new();
5096        workbook
5097            .set_cell_value("Sheet1", "A1", "unchanged")
5098            .unwrap();
5099        workbook
5100            .add_image(
5101                "Sheet1",
5102                &ImageConfig {
5103                    data: vec![0x89, 0x50, 0x4e, 0x47],
5104                    format: ImageFormat::Png,
5105                    from_cell: "B2".into(),
5106                    width_px: 8,
5107                    height_px: 8,
5108                },
5109            )
5110            .unwrap();
5111        let drawing_path = workbook.drawings[0].0.clone();
5112        workbook
5113            .raw_graph_parts
5114            .insert(drawing_path, b"<xdr:wsDr/>".to_vec());
5115
5116        assert!(matches!(
5117            workbook.insert_rows("Sheet1", 1, 1),
5118            Err(Error::InvalidArgument(_))
5119        ));
5120        assert_eq!(
5121            workbook.get_cell_value("Sheet1", "A1").unwrap(),
5122            CellValue::String("unchanged".into())
5123        );
5124    }
5125
5126    #[test]
5127    fn test_structural_edit_rejects_streamed_workbook_before_mutation() {
5128        let mut wb = Workbook::new();
5129        wb.set_cell_value("Sheet1", "A1", "unchanged").unwrap();
5130        let writer = wb.new_stream_writer("Streamed").unwrap();
5131        wb.apply_stream_writer(writer).unwrap();
5132
5133        let error = wb.insert_rows("Sheet1", 1, 1).unwrap_err();
5134        assert!(matches!(error, Error::InvalidArgument(_)));
5135        assert_eq!(
5136            wb.get_cell_value("Sheet1", "A1").unwrap(),
5137            CellValue::String("unchanged".into())
5138        );
5139    }
5140
5141    #[test]
5142    fn test_structural_edit_rejects_sheet_rows_limit_before_mutation() {
5143        let mut wb = Workbook::new();
5144        wb.set_cell_value("Sheet1", "A1", "unchanged").unwrap();
5145        wb.sheet_rows_limit = Some(1);
5146
5147        let error = wb.insert_rows("Sheet1", 1, 1).unwrap_err();
5148        assert!(matches!(error, Error::InvalidArgument(_)));
5149        assert_eq!(
5150            wb.get_cell_value("Sheet1", "A1").unwrap(),
5151            CellValue::String("unchanged".into())
5152        );
5153    }
5154
5155    #[test]
5156    fn test_structural_edit_updates_typed_chart_series_references() {
5157        let mut wb = Workbook::new();
5158        wb.add_chart(
5159            "Sheet1",
5160            "D1",
5161            "K10",
5162            &ChartConfig {
5163                chart_type: crate::chart::ChartType::Col,
5164                title: None,
5165                series: vec![crate::chart::ChartSeries {
5166                    name: "sheet1!$A$2".into(),
5167                    categories: "Sheet1!$A$2:$A$4".into(),
5168                    values: "Sheet1!$B$2:$B$4".into(),
5169                    x_values: None,
5170                    bubble_sizes: None,
5171                }],
5172                show_legend: false,
5173                view_3d: None,
5174            },
5175        )
5176        .unwrap();
5177
5178        wb.insert_rows("Sheet1", 2, 1).unwrap();
5179
5180        let series = &wb.charts[0]
5181            .1
5182            .chart
5183            .plot_area
5184            .bar_chart
5185            .as_ref()
5186            .unwrap()
5187            .series[0];
5188        assert_eq!(
5189            series.tx.as_ref().unwrap().str_ref.as_ref().unwrap().f,
5190            "sheet1!$A$3"
5191        );
5192        assert_eq!(
5193            series.cat.as_ref().unwrap().str_ref.as_ref().unwrap().f,
5194            "Sheet1!$A$3:$A$5"
5195        );
5196        assert_eq!(
5197            series.val.as_ref().unwrap().num_ref.as_ref().unwrap().f,
5198            "Sheet1!$B$3:$B$5"
5199        );
5200    }
5201
5202    #[test]
5203    fn test_structural_edit_rejects_unparseable_deferred_chart_without_mutation() {
5204        let dir = tempfile::tempdir().unwrap();
5205        let path = dir.path().join("lazy_chart.xlsx");
5206        let mut wb = Workbook::new();
5207        wb.add_chart(
5208            "Sheet1",
5209            "D1",
5210            "K10",
5211            &ChartConfig {
5212                chart_type: crate::chart::ChartType::Col,
5213                title: None,
5214                series: vec![crate::chart::ChartSeries {
5215                    name: "Sheet1!$A$2".into(),
5216                    categories: "Sheet1!$A$2:$A$4".into(),
5217                    values: "Sheet1!$B$2:$B$4".into(),
5218                    x_values: None,
5219                    bubble_sizes: None,
5220                }],
5221                show_legend: false,
5222                view_3d: None,
5223            },
5224        )
5225        .unwrap();
5226        wb.set_cell_value("Sheet1", "A1", "unchanged").unwrap();
5227        wb.save(&path).unwrap();
5228
5229        let mut lazy = Workbook::open(&path).unwrap();
5230        let error = lazy.insert_rows("Sheet1", 2, 1).unwrap_err();
5231        assert!(matches!(error, Error::XmlDeserialize(_)));
5232        assert!(lazy.raw_charts.is_empty());
5233        assert!(lazy.charts.is_empty());
5234        assert!(lazy
5235            .deferred_parts
5236            .has_category(crate::workbook::aux::AuxCategory::Charts));
5237        assert_eq!(
5238            lazy.get_cell_value("Sheet1", "A1").unwrap(),
5239            CellValue::String("unchanged".into())
5240        );
5241        assert!(!lazy.is_sheet_dirty(0));
5242        lazy.save(&path).unwrap();
5243        let reopened = Workbook::open(&path).unwrap();
5244        assert_eq!(
5245            reopened.get_cell_value("Sheet1", "A1").unwrap(),
5246            CellValue::String("unchanged".into())
5247        );
5248    }
5249
5250    #[test]
5251    fn test_structural_edit_rejects_lazy_orphan_chart_before_mutation() {
5252        let mut workbook = Workbook::new();
5253        workbook.new_sheet("Sheet2").unwrap();
5254        workbook
5255            .add_chart(
5256                "Sheet1",
5257                "D1",
5258                "K10",
5259                &ChartConfig {
5260                    chart_type: crate::chart::ChartType::Col,
5261                    title: None,
5262                    series: vec![crate::chart::ChartSeries {
5263                        name: "Sheet1!$A$1".into(),
5264                        categories: "Sheet1!$A$1:$A$2".into(),
5265                        values: "Sheet1!$B$1:$B$2".into(),
5266                        x_values: None,
5267                        bubble_sizes: None,
5268                    }],
5269                    show_legend: false,
5270                    view_3d: None,
5271                },
5272            )
5273            .unwrap();
5274        let chart_path = workbook.charts[0].0.clone();
5275        let parseable_chart = concat!(
5276            r#"<chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" "#,
5277            r#"xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" "#,
5278            r#"xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">"#,
5279            "<chart><plotArea/></chart></chartSpace>"
5280        )
5281        .as_bytes()
5282        .to_vec();
5283        let original = workbook.save_to_buffer().unwrap();
5284        let options = OpenOptions::new().read_mode(ReadMode::Lazy);
5285        let mut lazy = Workbook::open_from_buffer_with_options(&original, &options).unwrap();
5286        lazy.deferred_parts
5287            .remove_path(AuxCategory::Charts, &chart_path);
5288        assert!(lazy
5289            .deferred_parts
5290            .insert(chart_path.clone(), parseable_chart.clone()));
5291        let drawing_path = lazy
5292            .worksheet_rels
5293            .get(&0)
5294            .unwrap()
5295            .relationships
5296            .iter()
5297            .find(|relationship| relationship.rel_type == rel_types::DRAWING)
5298            .map(|relationship| {
5299                resolve_relationship_target(&lazy.sheet_part_path(0), &relationship.target)
5300            })
5301            .unwrap();
5302        let drawing_rels_path = relationship_part_path(&drawing_path);
5303        let raw_drawing_rels = lazy
5304            .deferred_parts
5305            .get_path(AuxCategory::DrawingRels, &drawing_rels_path)
5306            .unwrap()
5307            .to_vec();
5308        assert!(lazy
5309            .deferred_parts
5310            .remove_path(AuxCategory::Drawings, &drawing_path)
5311            .is_some());
5312        let before = lazy.save_to_buffer().unwrap();
5313
5314        let error = lazy.insert_rows("Sheet2", 1, 1).unwrap_err();
5315
5316        assert!(
5317            matches!(&error, Error::InvalidArgument(message) if message.contains("unresolved chart owner")),
5318            "{error:?}"
5319        );
5320        assert!(lazy.charts.is_empty());
5321        assert!(lazy.raw_graph_parts.is_empty());
5322        assert_eq!(
5323            lazy.deferred_parts
5324                .get_path(AuxCategory::Charts, &chart_path),
5325            Some(parseable_chart.as_slice())
5326        );
5327        assert_eq!(
5328            lazy.deferred_parts
5329                .get_path(AuxCategory::DrawingRels, &drawing_rels_path),
5330            Some(raw_drawing_rels.as_slice())
5331        );
5332        assert!(lazy
5333            .deferred_parts
5334            .get_path(AuxCategory::Drawings, &drawing_path)
5335            .is_none());
5336        assert!(!lazy.is_sheet_dirty(0));
5337        assert!(!lazy.is_sheet_dirty(1));
5338        assert_eq!(lazy.save_to_buffer().unwrap(), before);
5339    }
5340
5341    #[test]
5342    fn test_duplicate_row_hydrates_filtered_target_from_raw_xml() {
5343        let mut workbook = Workbook::new();
5344        workbook.new_sheet("Selected").unwrap();
5345        workbook.set_cell_value("Sheet1", "A1", "source").unwrap();
5346        let original = workbook.save_to_buffer().unwrap();
5347        let options = OpenOptions::new()
5348            .read_mode(ReadMode::Eager)
5349            .sheets(vec!["Selected".to_string()]);
5350        let mut opened = Workbook::open_from_buffer_with_options(&original, &options).unwrap();
5351        let selected_raw = zip_part(&original, "xl/worksheets/sheet2.xml");
5352
5353        opened.duplicate_row("Sheet1", 1).unwrap();
5354        let saved = opened.save_to_buffer().unwrap();
5355
5356        let duplicated = opened
5357            .worksheet_ref("Sheet1")
5358            .unwrap()
5359            .sheet_data
5360            .rows
5361            .iter()
5362            .find(|row| row.r == 2)
5363            .unwrap();
5364        assert_eq!(duplicated.cells[0].r, "A2");
5365        assert!(!opened.is_sheet_dirty(1));
5366        assert_eq!(zip_part(&saved, "xl/worksheets/sheet2.xml"), selected_raw);
5367    }
5368
5369    #[test]
5370    fn test_structural_edit_preserves_untouched_sheet_raw_bytes() {
5371        let mut workbook = Workbook::new();
5372        workbook.new_sheet("Untouched").unwrap();
5373        let base = workbook.save_to_buffer().unwrap();
5374        let mut workbook = Workbook::open_from_buffer(&base).unwrap();
5375        let sheet_path = "xl/worksheets/sheet2.xml";
5376        let raw_sheet = String::from_utf8(zip_part(&base, sheet_path))
5377            .unwrap()
5378            .replacen(
5379                "</worksheet>",
5380                "<extLst><ext uri=\"{opaque}\"><opaque:payload xmlns:opaque=\"urn:test\"/></ext></extLst></worksheet>",
5381                1,
5382            )
5383            .into_bytes();
5384        workbook.raw_sheet_xml[1] = Some(raw_sheet.clone());
5385
5386        workbook.insert_rows("Sheet1", 1, 1).unwrap();
5387        let saved = workbook.save_to_buffer().unwrap();
5388
5389        assert!(!workbook.is_sheet_dirty(1));
5390        assert_eq!(zip_part(&saved, sheet_path), raw_sheet);
5391    }
5392
5393    #[test]
5394    fn test_structural_edit_rejects_unparsed_eager_drawing_relationships_atomically() {
5395        let mut workbook = Workbook::new();
5396        workbook
5397            .add_image(
5398                "Sheet1",
5399                &crate::image::ImageConfig {
5400                    data: vec![0x89, 0x50, 0x4e, 0x47],
5401                    format: crate::image::ImageFormat::Png,
5402                    from_cell: "A1".to_string(),
5403                    width_px: 1,
5404                    height_px: 1,
5405                },
5406            )
5407            .unwrap();
5408        let base = workbook.save_to_buffer().unwrap();
5409        let options = OpenOptions::new()
5410            .read_mode(ReadMode::Eager)
5411            .aux_parts(AuxParts::EagerLoad);
5412        let mut opened = Workbook::open_from_buffer_with_options(&base, &options).unwrap();
5413        let drawing_idx = opened.worksheet_drawings[&0];
5414        let drawing_path = opened.drawings[drawing_idx].0.clone();
5415        let rels_path = relationship_part_path(&drawing_path);
5416        opened.drawing_rels.remove(&drawing_idx);
5417        opened
5418            .raw_graph_parts
5419            .insert(rels_path.clone(), b"<Relationships><Relationship".to_vec());
5420        let before = opened.save_to_buffer().unwrap();
5421
5422        let error = opened.insert_rows("Sheet1", 1, 1).unwrap_err();
5423
5424        assert!(matches!(error, Error::InvalidArgument(_)));
5425        assert_eq!(opened.save_to_buffer().unwrap(), before);
5426        assert_eq!(
5427            zip_part(&before, &rels_path),
5428            b"<Relationships><Relationship"
5429        );
5430        assert!(!opened.is_sheet_dirty(0));
5431    }
5432
5433    #[test]
5434    fn test_structural_edit_rejects_unresolved_chart_owner_on_other_sheet() {
5435        let mut workbook = Workbook::new();
5436        workbook.new_sheet("Other").unwrap();
5437        workbook
5438            .add_chart(
5439                "Other",
5440                "D1",
5441                "K10",
5442                &ChartConfig {
5443                    chart_type: crate::chart::ChartType::Col,
5444                    title: None,
5445                    series: vec![crate::chart::ChartSeries {
5446                        name: "Other!$A$1".into(),
5447                        categories: "Other!$A$1:$A$2".into(),
5448                        values: "Other!$B$1:$B$2".into(),
5449                        x_values: None,
5450                        bubble_sizes: None,
5451                    }],
5452                    show_legend: false,
5453                    view_3d: None,
5454                },
5455            )
5456            .unwrap();
5457        let base = workbook.save_to_buffer().unwrap();
5458        let options = OpenOptions::new()
5459            .read_mode(ReadMode::Eager)
5460            .aux_parts(AuxParts::EagerLoad);
5461        let mut opened = Workbook::open_from_buffer_with_options(&base, &options).unwrap();
5462        let drawing_idx = opened.worksheet_drawings[&1];
5463        let drawing_path = opened.drawings[drawing_idx].0.clone();
5464        let rels_path = relationship_part_path(&drawing_path);
5465        opened.drawing_rels.remove(&drawing_idx);
5466        opened
5467            .raw_graph_parts
5468            .insert(rels_path.clone(), b"<Relationships><Relationship".to_vec());
5469        let before = opened.save_to_buffer().unwrap();
5470
5471        let error = opened.insert_rows("Sheet1", 1, 1).unwrap_err();
5472
5473        assert!(matches!(error, Error::InvalidArgument(_)));
5474        assert_eq!(opened.save_to_buffer().unwrap(), before);
5475        assert_eq!(
5476            zip_part(&before, &rels_path),
5477            b"<Relationships><Relationship"
5478        );
5479        assert!(!opened.is_sheet_dirty(0));
5480        assert!(!opened.is_sheet_dirty(1));
5481    }
5482
5483    #[test]
5484    fn test_structural_edit_rejects_filtered_sheet_reference_overflow_atomically() {
5485        let mut workbook = Workbook::new();
5486        workbook.new_sheet("Filtered").unwrap();
5487        workbook
5488            .set_cell_formula("Filtered", "A1", "Sheet1!XFD1")
5489            .unwrap();
5490        let original = workbook.save_to_buffer().unwrap();
5491        let options = OpenOptions::new()
5492            .read_mode(ReadMode::Eager)
5493            .sheets(vec!["Sheet1".to_string()]);
5494        let mut opened = Workbook::open_from_buffer_with_options(&original, &options).unwrap();
5495        let before = opened.save_to_buffer().unwrap();
5496
5497        let error = opened.insert_cols("Sheet1", "A", 1).unwrap_err();
5498
5499        assert!(matches!(error, Error::InvalidColumnNumber(_)));
5500        assert_eq!(opened.save_to_buffer().unwrap(), before);
5501        assert!(!opened.is_sheet_dirty(0));
5502        assert!(!opened.is_sheet_dirty(1));
5503    }
5504
5505    #[test]
5506    fn test_delete_sheet_rejects_unparsed_eager_drawing_relationships_atomically() {
5507        let mut workbook = Workbook::new();
5508        workbook.new_sheet("Survivor").unwrap();
5509        workbook
5510            .add_image(
5511                "Sheet1",
5512                &crate::image::ImageConfig {
5513                    data: vec![0x89, 0x50, 0x4e, 0x47],
5514                    format: crate::image::ImageFormat::Png,
5515                    from_cell: "A1".to_string(),
5516                    width_px: 1,
5517                    height_px: 1,
5518                },
5519            )
5520            .unwrap();
5521        let base = workbook.save_to_buffer().unwrap();
5522        let options = OpenOptions::new()
5523            .read_mode(ReadMode::Eager)
5524            .aux_parts(AuxParts::EagerLoad);
5525        let mut opened = Workbook::open_from_buffer_with_options(&base, &options).unwrap();
5526        let drawing_idx = opened.worksheet_drawings[&0];
5527        let drawing_path = opened.drawings[drawing_idx].0.clone();
5528        let rels_path = relationship_part_path(&drawing_path);
5529        opened.drawing_rels.remove(&drawing_idx);
5530        opened
5531            .raw_graph_parts
5532            .insert(rels_path.clone(), b"<Relationships><Relationship".to_vec());
5533        let before = opened.save_to_buffer().unwrap();
5534
5535        let error = opened.delete_sheet("Sheet1").unwrap_err();
5536
5537        assert!(matches!(error, Error::InvalidArgument(_)));
5538        assert_eq!(opened.sheet_names(), vec!["Sheet1", "Survivor"]);
5539        assert_eq!(opened.save_to_buffer().unwrap(), before);
5540        assert_eq!(
5541            zip_part(&before, &rels_path),
5542            b"<Relationships><Relationship"
5543        );
5544    }
5545
5546    #[test]
5547    fn test_delete_graph_free_sheet_ignores_unrelated_deferred_drawing() {
5548        let mut workbook = Workbook::new();
5549        workbook.new_sheet("Survivor").unwrap();
5550        let original = workbook.save_to_buffer().unwrap();
5551        let options = OpenOptions::new().read_mode(ReadMode::Lazy);
5552        let mut lazy = Workbook::open_from_buffer_with_options(&original, &options).unwrap();
5553        let drawing_path = "xl/drawings/drawing99.xml";
5554        let raw_drawing = b"<xdr:wsDr><opaque></xdr:wsDr>".to_vec();
5555        assert!(lazy
5556            .deferred_parts
5557            .insert(drawing_path.to_string(), raw_drawing.clone()));
5558
5559        lazy.delete_sheet("Sheet1").unwrap();
5560        let saved = lazy.save_to_buffer().unwrap();
5561
5562        assert_eq!(lazy.sheet_names(), vec!["Survivor"]);
5563        assert_eq!(zip_part(&saved, drawing_path), raw_drawing);
5564    }
5565
5566    #[test]
5567    fn test_delete_graph_free_sheet_preserves_opaque_survivor_graph_closure() {
5568        let mut workbook = Workbook::new();
5569        workbook.new_sheet("Survivor").unwrap();
5570        workbook
5571            .add_image(
5572                "Survivor",
5573                &crate::image::ImageConfig {
5574                    data: vec![0x89, 0x50, 0x4e, 0x47],
5575                    format: crate::image::ImageFormat::Png,
5576                    from_cell: "A1".to_string(),
5577                    width_px: 1,
5578                    height_px: 1,
5579                },
5580            )
5581            .unwrap();
5582        let original = workbook.save_to_buffer().unwrap();
5583        let options = OpenOptions::new().read_mode(ReadMode::Lazy);
5584        let mut lazy = Workbook::open_from_buffer_with_options(&original, &options).unwrap();
5585        let sheet_path = lazy.sheet_part_path(1);
5586        let drawing_path = lazy
5587            .worksheet_rels
5588            .get(&1)
5589            .unwrap()
5590            .relationships
5591            .iter()
5592            .find(|relationship| relationship.rel_type == rel_types::DRAWING)
5593            .map(|relationship| resolve_relationship_target(&sheet_path, &relationship.target))
5594            .unwrap();
5595        let drawing_rels_path = relationship_part_path(&drawing_path);
5596        let drawing_rels = quick_xml::de::from_reader::<_, Relationships>(
5597            lazy.deferred_parts
5598                .get_path(AuxCategory::DrawingRels, &drawing_rels_path)
5599                .unwrap(),
5600        )
5601        .unwrap();
5602        let image_path = drawing_rels
5603            .relationships
5604            .iter()
5605            .find(|relationship| relationship.rel_type == rel_types::IMAGE)
5606            .map(|relationship| resolve_relationship_target(&drawing_path, &relationship.target))
5607            .unwrap();
5608        let raw_drawing = b"<xdr:wsDr><opaque></xdr:wsDr>".to_vec();
5609        lazy.deferred_parts
5610            .remove_path(AuxCategory::Drawings, &drawing_path);
5611        assert!(lazy
5612            .deferred_parts
5613            .insert(drawing_path.clone(), raw_drawing.clone()));
5614        let raw_sheet_rels = zip_part(&original, &relationship_part_path(&sheet_path));
5615        let raw_drawing_rels = zip_part(&original, &drawing_rels_path);
5616        let raw_image = zip_part(&original, &image_path);
5617
5618        lazy.delete_sheet("Sheet1").unwrap();
5619        let saved = lazy.save_to_buffer().unwrap();
5620
5621        assert_eq!(lazy.sheet_names(), vec!["Survivor"]);
5622        assert_eq!(zip_part(&saved, &drawing_path), raw_drawing);
5623        assert_eq!(zip_part(&saved, &drawing_rels_path), raw_drawing_rels);
5624        assert_eq!(zip_part(&saved, &image_path), raw_image);
5625        assert_eq!(
5626            zip_part(&saved, "xl/worksheets/_rels/sheet2.xml.rels"),
5627            raw_sheet_rels
5628        );
5629        assert_eq!(zip_entry_count(&saved, &drawing_path), 1);
5630        assert_package_integrity(&saved);
5631    }
5632
5633    #[test]
5634    fn test_structural_edit_reference_overflow_leaves_workbook_unchanged() {
5635        let mut wb = Workbook::new();
5636        wb.set_cell_formula("Sheet1", "A1", "XFD1").unwrap();
5637        wb.set_auto_filter("Sheet1", "A1:XFD1").unwrap();
5638
5639        let error = wb.insert_cols("Sheet1", "A", 1).unwrap_err();
5640        assert!(matches!(error, Error::InvalidColumnNumber(_)));
5641        match wb.get_cell_value("Sheet1", "A1").unwrap() {
5642            CellValue::Formula { expr, .. } => assert_eq!(expr, "XFD1"),
5643            value => panic!("expected formula, got {value:?}"),
5644        }
5645        assert_eq!(
5646            wb.worksheet_ref("Sheet1")
5647                .unwrap()
5648                .auto_filter
5649                .as_ref()
5650                .unwrap()
5651                .reference,
5652            "A1:XFD1"
5653        );
5654    }
5655
5656    #[test]
5657    fn test_workbook_insert_rows_sheet_not_found() {
5658        let mut wb = Workbook::new();
5659        let result = wb.insert_rows("NoSheet", 1, 1);
5660        assert!(matches!(result.unwrap_err(), Error::SheetNotFound { .. }));
5661    }
5662
5663    #[test]
5664    fn test_workbook_remove_row() {
5665        let mut wb = Workbook::new();
5666        wb.set_cell_value("Sheet1", "A1", "first").unwrap();
5667        wb.set_cell_value("Sheet1", "A2", "second").unwrap();
5668        wb.set_cell_value("Sheet1", "A3", "third").unwrap();
5669        wb.remove_row("Sheet1", 2).unwrap();
5670
5671        assert_eq!(
5672            wb.get_cell_value("Sheet1", "A1").unwrap(),
5673            CellValue::String("first".to_string())
5674        );
5675        assert_eq!(
5676            wb.get_cell_value("Sheet1", "A2").unwrap(),
5677            CellValue::String("third".to_string())
5678        );
5679    }
5680
5681    #[test]
5682    fn test_workbook_remove_row_sheet_not_found() {
5683        let mut wb = Workbook::new();
5684        let result = wb.remove_row("NoSheet", 1);
5685        assert!(matches!(result.unwrap_err(), Error::SheetNotFound { .. }));
5686    }
5687
5688    #[test]
5689    fn test_workbook_duplicate_row() {
5690        let mut wb = Workbook::new();
5691        wb.set_cell_value("Sheet1", "A1", "original").unwrap();
5692        wb.duplicate_row("Sheet1", 1).unwrap();
5693
5694        assert_eq!(
5695            wb.get_cell_value("Sheet1", "A1").unwrap(),
5696            CellValue::String("original".to_string())
5697        );
5698        // The duplicated row at row 2 has the same SST index.
5699        assert_eq!(
5700            wb.get_cell_value("Sheet1", "A2").unwrap(),
5701            CellValue::String("original".to_string())
5702        );
5703    }
5704
5705    #[test]
5706    fn test_duplicate_row_adjusts_only_relative_formula_rows() {
5707        let mut wb = Workbook::new();
5708        wb.new_sheet("Other").unwrap();
5709        wb.set_cell_formula("Sheet1", "B1", "A1+$A$1+Other!A1+Other!A2+Other!$A$1")
5710            .unwrap();
5711
5712        wb.duplicate_row("Sheet1", 1).unwrap();
5713
5714        match wb.get_cell_value("Sheet1", "B2").unwrap() {
5715            CellValue::Formula { expr, .. } => {
5716                assert_eq!(expr, "A2+$A$1+Other!A2+Other!A3+Other!$A$1");
5717            }
5718            value => panic!("expected formula, got {value:?}"),
5719        }
5720    }
5721
5722    #[test]
5723    fn test_duplicate_row_shifts_existing_merge_and_hyperlink_once() {
5724        let mut wb = Workbook::new();
5725        wb.set_cell_value("Sheet1", "A1", "source").unwrap();
5726        wb.merge_cells("Sheet1", "C3", "D3").unwrap();
5727        wb.set_cell_hyperlink(
5728            "Sheet1",
5729            "A3",
5730            crate::hyperlink::HyperlinkType::Internal("Sheet1!B3".into()),
5731            None,
5732            None,
5733        )
5734        .unwrap();
5735
5736        wb.duplicate_row("Sheet1", 1).unwrap();
5737
5738        assert_eq!(wb.get_merge_cells("Sheet1").unwrap(), vec!["C4:D4"]);
5739        let hyperlink = wb.get_cell_hyperlink("Sheet1", "A4").unwrap().unwrap();
5740        assert_eq!(
5741            hyperlink.link_type,
5742            crate::hyperlink::HyperlinkType::Internal("Sheet1!B4".into())
5743        );
5744    }
5745
5746    #[test]
5747    fn test_duplicate_row_formula_overflow_leaves_workbook_unchanged() {
5748        let mut wb = Workbook::new();
5749        wb.new_sheet("Other").unwrap();
5750        wb.set_cell_formula("Sheet1", "A1", "Other!A1048576")
5751            .unwrap();
5752
5753        let error = wb.duplicate_row("Sheet1", 1).unwrap_err();
5754        assert!(matches!(error, Error::InvalidRowNumber(1_048_577)));
5755        match wb.get_cell_value("Sheet1", "A1").unwrap() {
5756            CellValue::Formula { expr, .. } => assert_eq!(expr, "Other!A1048576"),
5757            value => panic!("expected formula, got {value:?}"),
5758        }
5759        assert_eq!(wb.get_cell_value("Sheet1", "A2").unwrap(), CellValue::Empty);
5760    }
5761
5762    #[test]
5763    fn duplicate_row_expands_shared_formula_copies_from_master() {
5764        let mut wb = Workbook::new();
5765        wb.set_cell_formula("Sheet1", "B1", "A1*2").unwrap();
5766        wb.set_cell_formula("Sheet1", "B2", "A2*2").unwrap();
5767        {
5768            let ws = wb.worksheet_mut("Sheet1").unwrap();
5769            let master = ws.sheet_data.rows[0].cells[0].f.as_mut().unwrap();
5770            master.t = Some("shared".into());
5771            master.reference = Some("B1:B2".into());
5772            master.si = Some(0);
5773            let child = ws.sheet_data.rows[1].cells[0].f.as_mut().unwrap();
5774            child.t = Some("shared".into());
5775            child.si = Some(0);
5776            child.value = None;
5777        }
5778
5779        wb.duplicate_row("Sheet1", 2).unwrap();
5780        wb.duplicate_row("Sheet1", 1).unwrap();
5781
5782        let ws = wb.worksheet_ref("Sheet1").unwrap();
5783        let formula_at = |row: u32| {
5784            ws.sheet_data
5785                .rows
5786                .iter()
5787                .find(|candidate| candidate.r == row)
5788                .unwrap()
5789                .cells[0]
5790                .f
5791                .clone()
5792                .unwrap()
5793        };
5794        let master_copy = formula_at(2);
5795        assert_eq!(master_copy.value.as_deref(), Some("A2*2"));
5796        assert_eq!(
5797            (master_copy.t, master_copy.si, master_copy.reference),
5798            (None, None, None)
5799        );
5800        let child_copy = formula_at(4);
5801        assert_eq!(child_copy.value.as_deref(), Some("A4*2"));
5802        assert_eq!((child_copy.t, child_copy.si), (None, None));
5803        let master = formula_at(1);
5804        assert_eq!(master.si, Some(0));
5805        assert_eq!(master.reference.as_deref(), Some("B1:B3"));
5806    }
5807
5808    #[test]
5809    fn duplicate_row_moves_array_formula_range_with_copy() {
5810        let mut wb = Workbook::new();
5811        wb.set_cell_formula("Sheet1", "B3", "SUM(A3:A4)").unwrap();
5812        {
5813            let ws = wb.worksheet_mut("Sheet1").unwrap();
5814            let formula = ws.sheet_data.rows[0].cells[0].f.as_mut().unwrap();
5815            formula.t = Some("array".into());
5816            formula.reference = Some("B3".into());
5817        }
5818
5819        wb.duplicate_row("Sheet1", 3).unwrap();
5820
5821        let ws = wb.worksheet_ref("Sheet1").unwrap();
5822        let copy = ws.sheet_data.rows[1].cells[0].f.clone().unwrap();
5823        assert_eq!(copy.t.as_deref(), Some("array"));
5824        assert_eq!(copy.reference.as_deref(), Some("B4"));
5825        assert_eq!(copy.value.as_deref(), Some("SUM(A4:A5)"));
5826        let source = ws.sheet_data.rows[0].cells[0].f.clone().unwrap();
5827        assert_eq!(source.reference.as_deref(), Some("B3"));
5828        assert_eq!(source.value.as_deref(), Some("SUM(A3:A5)"));
5829    }
5830
5831    #[test]
5832    fn column_edits_shift_and_drop_column_page_breaks() {
5833        let mut wb = Workbook::new();
5834        wb.worksheet_mut("Sheet1").unwrap().col_breaks = Some(sheetkit_xml::worksheet::RowBreaks {
5835            count: Some(2),
5836            manual_break_count: Some(2),
5837            brk: vec![
5838                sheetkit_xml::worksheet::Break {
5839                    id: 2,
5840                    max: None,
5841                    man: Some(true),
5842                },
5843                sheetkit_xml::worksheet::Break {
5844                    id: 5,
5845                    max: None,
5846                    man: Some(true),
5847                },
5848            ],
5849        });
5850
5851        wb.insert_cols("Sheet1", "A", 2).unwrap();
5852        wb.remove_col("Sheet1", "E").unwrap();
5853
5854        let breaks = wb
5855            .worksheet_ref("Sheet1")
5856            .unwrap()
5857            .col_breaks
5858            .clone()
5859            .unwrap();
5860        assert_eq!(
5861            breaks.brk.iter().map(|brk| brk.id).collect::<Vec<_>>(),
5862            vec![6]
5863        );
5864        assert_eq!(
5865            (breaks.count, breaks.manual_break_count),
5866            (Some(1), Some(1))
5867        );
5868        assert!(wb.worksheet_ref("Sheet1").unwrap().row_breaks.is_none());
5869    }
5870
5871    #[test]
5872    fn insert_rows_rejects_comment_pushed_off_grid_without_mutation() {
5873        let mut wb = Workbook::new();
5874        wb.add_comment(
5875            "Sheet1",
5876            &crate::comment::CommentConfig {
5877                cell: "A1048576".into(),
5878                author: "Author".into(),
5879                text: "edge".into(),
5880            },
5881        )
5882        .unwrap();
5883        wb.set_cell_formula("Sheet1", "B1", "A2").unwrap();
5884
5885        let error = wb.insert_rows("Sheet1", 1, 1).unwrap_err();
5886        assert!(matches!(error, Error::InvalidRowNumber(1_048_577)));
5887        match wb.get_cell_value("Sheet1", "B1").unwrap() {
5888            CellValue::Formula { expr, .. } => assert_eq!(expr, "A2"),
5889            value => panic!("expected formula, got {value:?}"),
5890        }
5891        assert_eq!(wb.get_comments("Sheet1").unwrap()[0].cell, "A1048576");
5892    }
5893
5894    #[test]
5895    fn test_workbook_set_and_get_row_height() {
5896        let mut wb = Workbook::new();
5897        wb.set_row_height("Sheet1", 3, 25.0).unwrap();
5898        assert_eq!(wb.get_row_height("Sheet1", 3).unwrap(), Some(25.0));
5899    }
5900
5901    #[test]
5902    fn test_workbook_get_row_height_sheet_not_found() {
5903        let wb = Workbook::new();
5904        let result = wb.get_row_height("NoSheet", 1);
5905        assert!(matches!(result.unwrap_err(), Error::SheetNotFound { .. }));
5906    }
5907
5908    #[test]
5909    fn test_workbook_set_row_visible() {
5910        let mut wb = Workbook::new();
5911        wb.set_row_visible("Sheet1", 1, false).unwrap();
5912    }
5913
5914    #[test]
5915    fn test_workbook_set_row_visible_sheet_not_found() {
5916        let mut wb = Workbook::new();
5917        let result = wb.set_row_visible("NoSheet", 1, false);
5918        assert!(matches!(result.unwrap_err(), Error::SheetNotFound { .. }));
5919    }
5920
5921    #[test]
5922    fn test_workbook_set_and_get_col_width() {
5923        let mut wb = Workbook::new();
5924        wb.set_col_width("Sheet1", "A", 18.0).unwrap();
5925        assert_eq!(wb.get_col_width("Sheet1", "A").unwrap(), Some(18.0));
5926    }
5927
5928    #[test]
5929    fn test_workbook_get_col_width_sheet_not_found() {
5930        let wb = Workbook::new();
5931        let result = wb.get_col_width("NoSheet", "A");
5932        assert!(matches!(result.unwrap_err(), Error::SheetNotFound { .. }));
5933    }
5934
5935    #[test]
5936    fn test_workbook_set_col_visible() {
5937        let mut wb = Workbook::new();
5938        wb.set_col_visible("Sheet1", "B", false).unwrap();
5939    }
5940
5941    #[test]
5942    fn test_workbook_set_col_visible_sheet_not_found() {
5943        let mut wb = Workbook::new();
5944        let result = wb.set_col_visible("NoSheet", "A", false);
5945        assert!(matches!(result.unwrap_err(), Error::SheetNotFound { .. }));
5946    }
5947
5948    #[test]
5949    fn test_workbook_insert_cols() {
5950        let mut wb = Workbook::new();
5951        wb.set_cell_value("Sheet1", "A1", "a").unwrap();
5952        wb.set_cell_value("Sheet1", "B1", "b").unwrap();
5953        wb.insert_cols("Sheet1", "B", 1).unwrap();
5954
5955        assert_eq!(
5956            wb.get_cell_value("Sheet1", "A1").unwrap(),
5957            CellValue::String("a".to_string())
5958        );
5959        assert_eq!(wb.get_cell_value("Sheet1", "B1").unwrap(), CellValue::Empty);
5960        assert_eq!(
5961            wb.get_cell_value("Sheet1", "C1").unwrap(),
5962            CellValue::String("b".to_string())
5963        );
5964    }
5965
5966    #[test]
5967    fn test_workbook_insert_cols_updates_formula_and_ranges() {
5968        let mut wb = Workbook::new();
5969        wb.set_cell_value(
5970            "Sheet1",
5971            "D1",
5972            CellValue::Formula {
5973                expr: "SUM(A1:B1)".to_string(),
5974                result: None,
5975            },
5976        )
5977        .unwrap();
5978        wb.add_data_validation(
5979            "Sheet1",
5980            &crate::validation::DataValidationConfig::whole_number("B2:C3", 1, 9),
5981        )
5982        .unwrap();
5983        wb.set_auto_filter("Sheet1", "A1:C10").unwrap();
5984        wb.merge_cells("Sheet1", "B3", "C4").unwrap();
5985
5986        wb.insert_cols("Sheet1", "B", 2).unwrap();
5987
5988        match wb.get_cell_value("Sheet1", "F1").unwrap() {
5989            CellValue::Formula { expr, .. } => assert_eq!(expr, "SUM(A1:D1)"),
5990            other => panic!("expected formula, got {other:?}"),
5991        }
5992
5993        let validations = wb.get_data_validations("Sheet1").unwrap();
5994        assert_eq!(validations.len(), 1);
5995        assert_eq!(validations[0].sqref, "D2:E3");
5996
5997        let merges = wb.get_merge_cells("Sheet1").unwrap();
5998        assert_eq!(merges, vec!["D3:E4".to_string()]);
5999
6000        let ws = wb.worksheet_ref("Sheet1").unwrap();
6001        assert_eq!(ws.auto_filter.as_ref().unwrap().reference, "A1:E10");
6002    }
6003
6004    #[test]
6005    fn test_workbook_insert_cols_sheet_not_found() {
6006        let mut wb = Workbook::new();
6007        let result = wb.insert_cols("NoSheet", "A", 1);
6008        assert!(matches!(result.unwrap_err(), Error::SheetNotFound { .. }));
6009    }
6010
6011    #[test]
6012    fn test_workbook_remove_col() {
6013        let mut wb = Workbook::new();
6014        wb.set_cell_value("Sheet1", "A1", "a").unwrap();
6015        wb.set_cell_value("Sheet1", "B1", "b").unwrap();
6016        wb.set_cell_value("Sheet1", "C1", "c").unwrap();
6017        wb.remove_col("Sheet1", "B").unwrap();
6018
6019        assert_eq!(
6020            wb.get_cell_value("Sheet1", "A1").unwrap(),
6021            CellValue::String("a".to_string())
6022        );
6023        assert_eq!(
6024            wb.get_cell_value("Sheet1", "B1").unwrap(),
6025            CellValue::String("c".to_string())
6026        );
6027    }
6028
6029    #[test]
6030    fn test_workbook_remove_col_sheet_not_found() {
6031        let mut wb = Workbook::new();
6032        let result = wb.remove_col("NoSheet", "A");
6033        assert!(matches!(result.unwrap_err(), Error::SheetNotFound { .. }));
6034    }
6035
6036    #[test]
6037    fn test_new_stream_writer_validates_name() {
6038        let wb = Workbook::new();
6039        let result = wb.new_stream_writer("Bad[Name");
6040        assert!(result.is_err());
6041        assert!(matches!(result.unwrap_err(), Error::InvalidSheetName(_)));
6042    }
6043
6044    #[test]
6045    fn test_new_stream_writer_rejects_duplicate() {
6046        let wb = Workbook::new();
6047        let result = wb.new_stream_writer("Sheet1");
6048        assert!(result.is_err());
6049        assert!(matches!(
6050            result.unwrap_err(),
6051            Error::SheetAlreadyExists { .. }
6052        ));
6053    }
6054
6055    #[test]
6056    fn test_new_stream_writer_valid_name() {
6057        let wb = Workbook::new();
6058        let sw = wb.new_stream_writer("StreamSheet").unwrap();
6059        assert_eq!(sw.sheet_name(), "StreamSheet");
6060    }
6061
6062    #[test]
6063    fn test_apply_stream_writer_adds_sheet() {
6064        let mut wb = Workbook::new();
6065        let mut sw = wb.new_stream_writer("StreamSheet").unwrap();
6066        sw.write_row(1, &[CellValue::from("Hello"), CellValue::from(42)])
6067            .unwrap();
6068        let idx = wb.apply_stream_writer(sw).unwrap();
6069        assert_eq!(idx, 1);
6070        assert_eq!(wb.sheet_names(), vec!["Sheet1", "StreamSheet"]);
6071    }
6072
6073    #[test]
6074    fn test_apply_stream_writer_uses_inline_strings() {
6075        // Streamed sheets use inline strings, not the shared string table.
6076        let mut wb = Workbook::new();
6077        wb.set_cell_value("Sheet1", "A1", "Existing").unwrap();
6078        let sst_before = wb.sst_runtime.len();
6079
6080        let mut sw = wb.new_stream_writer("StreamSheet").unwrap();
6081        sw.write_row(1, &[CellValue::from("New"), CellValue::from("Existing")])
6082            .unwrap();
6083        wb.apply_stream_writer(sw).unwrap();
6084
6085        // SST should not grow because streamed sheets use inline strings.
6086        assert_eq!(wb.sst_runtime.len(), sst_before);
6087    }
6088
6089    #[test]
6090    fn test_stream_writer_save_and_reopen() {
6091        let dir = TempDir::new().unwrap();
6092        let path = dir.path().join("stream_test.xlsx");
6093
6094        let mut wb = Workbook::new();
6095        wb.set_cell_value("Sheet1", "A1", "Normal").unwrap();
6096
6097        let mut sw = wb.new_stream_writer("Streamed").unwrap();
6098        sw.write_row(1, &[CellValue::from("Name"), CellValue::from("Value")])
6099            .unwrap();
6100        sw.write_row(2, &[CellValue::from("Alice"), CellValue::from(100)])
6101            .unwrap();
6102        sw.write_row(3, &[CellValue::from("Bob"), CellValue::from(200)])
6103            .unwrap();
6104        wb.apply_stream_writer(sw).unwrap();
6105
6106        wb.save(&path).unwrap();
6107
6108        let wb2 = Workbook::open(&path).unwrap();
6109        assert_eq!(wb2.sheet_names(), vec!["Sheet1", "Streamed"]);
6110        assert_eq!(
6111            wb2.get_cell_value("Sheet1", "A1").unwrap(),
6112            CellValue::String("Normal".to_string())
6113        );
6114        assert_eq!(
6115            wb2.get_cell_value("Streamed", "A1").unwrap(),
6116            CellValue::String("Name".to_string())
6117        );
6118        assert_eq!(
6119            wb2.get_cell_value("Streamed", "B2").unwrap(),
6120            CellValue::Number(100.0)
6121        );
6122        assert_eq!(
6123            wb2.get_cell_value("Streamed", "A3").unwrap(),
6124            CellValue::String("Bob".to_string())
6125        );
6126    }
6127
6128    #[test]
6129    fn test_workbook_get_rows_empty_sheet() {
6130        let wb = Workbook::new();
6131        let rows = wb.get_rows("Sheet1").unwrap();
6132        assert!(rows.is_empty());
6133    }
6134
6135    #[test]
6136    fn test_workbook_get_rows_with_data() {
6137        let mut wb = Workbook::new();
6138        wb.set_cell_value("Sheet1", "A1", "Name").unwrap();
6139        wb.set_cell_value("Sheet1", "B1", 42.0).unwrap();
6140        wb.set_cell_value("Sheet1", "A2", "Alice").unwrap();
6141        wb.set_cell_value("Sheet1", "B2", true).unwrap();
6142
6143        let rows = wb.get_rows("Sheet1").unwrap();
6144        assert_eq!(rows.len(), 2);
6145        assert_eq!(rows[0].0, 1);
6146        assert_eq!(rows[0].1.len(), 2);
6147        assert_eq!(rows[0].1[0].0, 1);
6148        assert_eq!(rows[0].1[0].1, CellValue::String("Name".to_string()));
6149        assert_eq!(rows[0].1[1].0, 2);
6150        assert_eq!(rows[0].1[1].1, CellValue::Number(42.0));
6151        assert_eq!(rows[1].0, 2);
6152        assert_eq!(rows[1].1[0].1, CellValue::String("Alice".to_string()));
6153        assert_eq!(rows[1].1[1].1, CellValue::Bool(true));
6154    }
6155
6156    #[test]
6157    fn test_workbook_get_rows_sheet_not_found() {
6158        let wb = Workbook::new();
6159        assert!(wb.get_rows("NoSheet").is_err());
6160    }
6161
6162    #[test]
6163    fn test_workbook_get_cols_empty_sheet() {
6164        let wb = Workbook::new();
6165        let cols = wb.get_cols("Sheet1").unwrap();
6166        assert!(cols.is_empty());
6167    }
6168
6169    #[test]
6170    fn test_workbook_get_cols_with_data() {
6171        let mut wb = Workbook::new();
6172        wb.set_cell_value("Sheet1", "A1", "Name").unwrap();
6173        wb.set_cell_value("Sheet1", "B1", 42.0).unwrap();
6174        wb.set_cell_value("Sheet1", "A2", "Alice").unwrap();
6175        wb.set_cell_value("Sheet1", "B2", 30.0).unwrap();
6176
6177        let cols = wb.get_cols("Sheet1").unwrap();
6178        assert_eq!(cols.len(), 2);
6179        assert_eq!(cols[0].0, "A");
6180        assert_eq!(cols[0].1.len(), 2);
6181        assert_eq!(cols[0].1[0], (1, CellValue::String("Name".to_string())));
6182        assert_eq!(cols[0].1[1], (2, CellValue::String("Alice".to_string())));
6183        assert_eq!(cols[1].0, "B");
6184        assert_eq!(cols[1].1[0], (1, CellValue::Number(42.0)));
6185        assert_eq!(cols[1].1[1], (2, CellValue::Number(30.0)));
6186    }
6187
6188    #[test]
6189    fn test_workbook_get_cols_with_limits() {
6190        let mut wb = Workbook::new();
6191        wb.set_cell_value("Sheet1", "A1", "first").unwrap();
6192        wb.set_cell_value("Sheet1", "B2", "second").unwrap();
6193
6194        let exact = crate::traversal::TraversalLimits::new(2, 2, 2, 1_024).unwrap();
6195        assert_eq!(wb.get_cols_with_limits("Sheet1", exact).unwrap().len(), 2);
6196
6197        let rejected = crate::traversal::TraversalLimits::new(1, 2, 2, 1_024).unwrap();
6198        assert!(matches!(
6199            wb.get_cols_with_limits("Sheet1", rejected),
6200            Err(Error::ResourceLimitExceeded(_))
6201        ));
6202    }
6203
6204    #[test]
6205    fn test_workbook_get_cols_sheet_not_found() {
6206        let wb = Workbook::new();
6207        assert!(wb.get_cols("NoSheet").is_err());
6208    }
6209
6210    #[test]
6211    fn test_streamed_sheet_cells_empty_before_save() {
6212        // Streamed sheet data lives in a temp file, not in the WorksheetXml.
6213        // Reading cells before save returns Empty.
6214        let mut wb = Workbook::new();
6215        let mut sw = wb.new_stream_writer("Streamed").unwrap();
6216        sw.write_row(1, &[CellValue::from("Name"), CellValue::from("Age")])
6217            .unwrap();
6218        wb.apply_stream_writer(sw).unwrap();
6219
6220        assert_eq!(
6221            wb.get_cell_value("Streamed", "A1").unwrap(),
6222            CellValue::Empty
6223        );
6224        assert_eq!(
6225            wb.get_cell_value("Streamed", "B1").unwrap(),
6226            CellValue::Empty
6227        );
6228    }
6229
6230    #[test]
6231    fn test_streamed_sheet_readable_after_save_reopen() {
6232        let dir = TempDir::new().unwrap();
6233        let path = dir.path().join("stream_reopen.xlsx");
6234
6235        let mut wb = Workbook::new();
6236        let mut sw = wb.new_stream_writer("Streamed").unwrap();
6237        sw.write_row(1, &[CellValue::from("Name"), CellValue::from("Age")])
6238            .unwrap();
6239        sw.write_row(2, &[CellValue::from("Alice"), CellValue::from(30)])
6240            .unwrap();
6241        wb.apply_stream_writer(sw).unwrap();
6242        wb.save(&path).unwrap();
6243
6244        let wb2 = Workbook::open(&path).unwrap();
6245        assert_eq!(
6246            wb2.get_cell_value("Streamed", "A1").unwrap(),
6247            CellValue::String("Name".to_string())
6248        );
6249        assert_eq!(
6250            wb2.get_cell_value("Streamed", "B1").unwrap(),
6251            CellValue::String("Age".to_string())
6252        );
6253        assert_eq!(
6254            wb2.get_cell_value("Streamed", "A2").unwrap(),
6255            CellValue::String("Alice".to_string())
6256        );
6257        assert_eq!(
6258            wb2.get_cell_value("Streamed", "B2").unwrap(),
6259            CellValue::Number(30.0)
6260        );
6261    }
6262
6263    #[test]
6264    fn test_workbook_get_rows_roundtrip_save_open() {
6265        let mut wb = Workbook::new();
6266        wb.set_cell_value("Sheet1", "A1", "hello").unwrap();
6267        wb.set_cell_value("Sheet1", "B1", 99.0).unwrap();
6268        wb.set_cell_value("Sheet1", "A2", true).unwrap();
6269
6270        let tmp = std::env::temp_dir().join("test_get_rows_roundtrip.xlsx");
6271        wb.save(&tmp).unwrap();
6272
6273        let wb2 = Workbook::open(&tmp).unwrap();
6274        let rows = wb2.get_rows("Sheet1").unwrap();
6275        assert_eq!(rows.len(), 2);
6276        assert_eq!(rows[0].1[0].1, CellValue::String("hello".to_string()));
6277        assert_eq!(rows[0].1[1].1, CellValue::Number(99.0));
6278        assert_eq!(rows[1].1[0].1, CellValue::Bool(true));
6279
6280        let _ = std::fs::remove_file(&tmp);
6281    }
6282
6283    #[test]
6284    fn test_stream_save_reopen_basic() {
6285        let dir = TempDir::new().unwrap();
6286        let path = dir.path().join("stream_basic.xlsx");
6287
6288        let mut wb = Workbook::new();
6289        let mut sw = wb.new_stream_writer("Optimized").unwrap();
6290        sw.write_row(1, &[CellValue::from("Hello"), CellValue::from(42)])
6291            .unwrap();
6292        sw.write_row(2, &[CellValue::from("World"), CellValue::from(99)])
6293            .unwrap();
6294        let idx = wb.apply_stream_writer(sw).unwrap();
6295        assert_eq!(idx, 1);
6296
6297        wb.save(&path).unwrap();
6298        let wb2 = Workbook::open(&path).unwrap();
6299        assert_eq!(
6300            wb2.get_cell_value("Optimized", "A1").unwrap(),
6301            CellValue::String("Hello".to_string())
6302        );
6303        assert_eq!(
6304            wb2.get_cell_value("Optimized", "B1").unwrap(),
6305            CellValue::Number(42.0)
6306        );
6307        assert_eq!(
6308            wb2.get_cell_value("Optimized", "A2").unwrap(),
6309            CellValue::String("World".to_string())
6310        );
6311        assert_eq!(
6312            wb2.get_cell_value("Optimized", "B2").unwrap(),
6313            CellValue::Number(99.0)
6314        );
6315    }
6316
6317    #[test]
6318    fn test_stream_save_reopen_all_types() {
6319        let dir = TempDir::new().unwrap();
6320        let path = dir.path().join("stream_types.xlsx");
6321
6322        let mut wb = Workbook::new();
6323        let mut sw = wb.new_stream_writer("Types").unwrap();
6324        sw.write_row(
6325            1,
6326            &[
6327                CellValue::from("text"),
6328                CellValue::from(42),
6329                CellValue::from(3.14),
6330                CellValue::from(true),
6331                CellValue::Formula {
6332                    expr: "SUM(B1:C1)".to_string(),
6333                    result: None,
6334                },
6335                CellValue::Error("#N/A".to_string()),
6336                CellValue::Empty,
6337            ],
6338        )
6339        .unwrap();
6340        wb.apply_stream_writer(sw).unwrap();
6341
6342        wb.save(&path).unwrap();
6343        let wb2 = Workbook::open(&path).unwrap();
6344        assert_eq!(
6345            wb2.get_cell_value("Types", "A1").unwrap(),
6346            CellValue::String("text".to_string())
6347        );
6348        assert_eq!(
6349            wb2.get_cell_value("Types", "B1").unwrap(),
6350            CellValue::Number(42.0)
6351        );
6352        assert_eq!(
6353            wb2.get_cell_value("Types", "D1").unwrap(),
6354            CellValue::Bool(true)
6355        );
6356        match wb2.get_cell_value("Types", "E1").unwrap() {
6357            CellValue::Formula { expr, .. } => assert_eq!(expr, "SUM(B1:C1)"),
6358            other => panic!("expected formula, got {other:?}"),
6359        }
6360        assert_eq!(
6361            wb2.get_cell_value("Types", "F1").unwrap(),
6362            CellValue::Error("#N/A".to_string())
6363        );
6364        assert_eq!(wb2.get_cell_value("Types", "G1").unwrap(), CellValue::Empty);
6365    }
6366
6367    #[test]
6368    fn test_apply_stream_optimized_save_reopen() {
6369        let dir = TempDir::new().unwrap();
6370        let path = dir.path().join("stream_optimized.xlsx");
6371
6372        let mut wb = Workbook::new();
6373        wb.set_cell_value("Sheet1", "A1", "Normal").unwrap();
6374
6375        let mut sw = wb.new_stream_writer("Fast").unwrap();
6376        sw.write_row(1, &[CellValue::from("Name"), CellValue::from("Value")])
6377            .unwrap();
6378        sw.write_row(2, &[CellValue::from("Alice"), CellValue::from(100)])
6379            .unwrap();
6380        sw.write_row(3, &[CellValue::from("Bob"), CellValue::from(200)])
6381            .unwrap();
6382        wb.apply_stream_writer(sw).unwrap();
6383
6384        wb.save(&path).unwrap();
6385
6386        let wb2 = Workbook::open(&path).unwrap();
6387        assert_eq!(wb2.sheet_names(), vec!["Sheet1", "Fast"]);
6388        assert_eq!(
6389            wb2.get_cell_value("Fast", "A1").unwrap(),
6390            CellValue::String("Name".to_string())
6391        );
6392        assert_eq!(
6393            wb2.get_cell_value("Fast", "B2").unwrap(),
6394            CellValue::Number(100.0)
6395        );
6396        assert_eq!(
6397            wb2.get_cell_value("Fast", "A3").unwrap(),
6398            CellValue::String("Bob".to_string())
6399        );
6400    }
6401
6402    #[test]
6403    fn test_stream_freeze_panes_roundtrip() {
6404        let dir = TempDir::new().unwrap();
6405        let path = dir.path().join("stream_freeze.xlsx");
6406
6407        let mut wb = Workbook::new();
6408        let mut sw = wb.new_stream_writer("FreezeSheet").unwrap();
6409        sw.set_freeze_panes("B3").unwrap();
6410        sw.write_row(1, &[CellValue::from("A"), CellValue::from("B")])
6411            .unwrap();
6412        sw.write_row(2, &[CellValue::from("C"), CellValue::from("D")])
6413            .unwrap();
6414        wb.apply_stream_writer(sw).unwrap();
6415        wb.save(&path).unwrap();
6416
6417        let wb2 = Workbook::open(&path).unwrap();
6418        assert_eq!(
6419            wb2.get_panes("FreezeSheet").unwrap(),
6420            Some("B3".to_string())
6421        );
6422        assert_eq!(
6423            wb2.get_cell_value("FreezeSheet", "A1").unwrap(),
6424            CellValue::String("A".to_string())
6425        );
6426    }
6427
6428    #[test]
6429    fn test_stream_merge_cells_roundtrip() {
6430        let dir = TempDir::new().unwrap();
6431        let path = dir.path().join("stream_merge.xlsx");
6432
6433        let mut wb = Workbook::new();
6434        let mut sw = wb.new_stream_writer("MergeSheet").unwrap();
6435        sw.add_merge_cell("A1:C1").unwrap();
6436        sw.add_merge_cell("A3:B4").unwrap();
6437        sw.write_row(1, &[CellValue::from("Header")]).unwrap();
6438        sw.write_row(2, &[CellValue::from("Data")]).unwrap();
6439        wb.apply_stream_writer(sw).unwrap();
6440        wb.save(&path).unwrap();
6441
6442        let wb2 = Workbook::open(&path).unwrap();
6443        let merges = wb2.get_merge_cells("MergeSheet").unwrap();
6444        assert!(merges.contains(&"A1:C1".to_string()));
6445        assert!(merges.contains(&"A3:B4".to_string()));
6446        assert_eq!(
6447            wb2.get_cell_value("MergeSheet", "A1").unwrap(),
6448            CellValue::String("Header".to_string())
6449        );
6450    }
6451
6452    #[test]
6453    fn test_stream_col_widths_roundtrip() {
6454        let dir = TempDir::new().unwrap();
6455        let path = dir.path().join("stream_colw.xlsx");
6456
6457        let mut wb = Workbook::new();
6458        let mut sw = wb.new_stream_writer("ColSheet").unwrap();
6459        sw.set_col_width(1, 25.0).unwrap();
6460        sw.set_col_width(2, 12.5).unwrap();
6461        sw.write_row(1, &[CellValue::from("Wide"), CellValue::from("Narrow")])
6462            .unwrap();
6463        wb.apply_stream_writer(sw).unwrap();
6464        wb.save(&path).unwrap();
6465
6466        let wb2 = Workbook::open(&path).unwrap();
6467        let w1 = wb2.get_col_width("ColSheet", "A").unwrap().unwrap();
6468        let w2 = wb2.get_col_width("ColSheet", "B").unwrap().unwrap();
6469        assert!((w1 - 25.0).abs() < 0.01);
6470        assert!((w2 - 12.5).abs() < 0.01);
6471    }
6472
6473    #[test]
6474    fn test_stream_multiple_sheets() {
6475        let dir = TempDir::new().unwrap();
6476        let path = dir.path().join("stream_multi.xlsx");
6477
6478        let mut wb = Workbook::new();
6479        wb.set_cell_value("Sheet1", "A1", "Normal").unwrap();
6480
6481        let mut sw1 = wb.new_stream_writer("Stream1").unwrap();
6482        sw1.write_row(1, &[CellValue::from("S1R1")]).unwrap();
6483        sw1.write_row(2, &[CellValue::from("S1R2")]).unwrap();
6484        wb.apply_stream_writer(sw1).unwrap();
6485
6486        let mut sw2 = wb.new_stream_writer("Stream2").unwrap();
6487        sw2.write_row(1, &[CellValue::from("S2R1")]).unwrap();
6488        wb.apply_stream_writer(sw2).unwrap();
6489
6490        wb.save(&path).unwrap();
6491
6492        let wb2 = Workbook::open(&path).unwrap();
6493        assert_eq!(wb2.sheet_names(), vec!["Sheet1", "Stream1", "Stream2"]);
6494        assert_eq!(
6495            wb2.get_cell_value("Sheet1", "A1").unwrap(),
6496            CellValue::String("Normal".to_string())
6497        );
6498        assert_eq!(
6499            wb2.get_cell_value("Stream1", "A1").unwrap(),
6500            CellValue::String("S1R1".to_string())
6501        );
6502        assert_eq!(
6503            wb2.get_cell_value("Stream1", "A2").unwrap(),
6504            CellValue::String("S1R2".to_string())
6505        );
6506        assert_eq!(
6507            wb2.get_cell_value("Stream2", "A1").unwrap(),
6508            CellValue::String("S2R1".to_string())
6509        );
6510    }
6511
6512    #[test]
6513    fn test_stream_delete_sheet() {
6514        let dir = TempDir::new().unwrap();
6515        let path = dir.path().join("stream_delete.xlsx");
6516
6517        let mut wb = Workbook::new();
6518        let mut sw = wb.new_stream_writer("ToDelete").unwrap();
6519        sw.write_row(1, &[CellValue::from("Gone")]).unwrap();
6520        wb.apply_stream_writer(sw).unwrap();
6521
6522        let mut sw2 = wb.new_stream_writer("Kept").unwrap();
6523        sw2.write_row(1, &[CellValue::from("Stays")]).unwrap();
6524        wb.apply_stream_writer(sw2).unwrap();
6525
6526        wb.delete_sheet("ToDelete").unwrap();
6527        wb.save(&path).unwrap();
6528
6529        let wb2 = Workbook::open(&path).unwrap();
6530        assert_eq!(wb2.sheet_names(), vec!["Sheet1", "Kept"]);
6531        assert_eq!(
6532            wb2.get_cell_value("Kept", "A1").unwrap(),
6533            CellValue::String("Stays".to_string())
6534        );
6535    }
6536
6537    #[test]
6538    fn test_stream_combined_features_roundtrip() {
6539        let dir = TempDir::new().unwrap();
6540        let path = dir.path().join("stream_combined.xlsx");
6541
6542        let mut wb = Workbook::new();
6543        let mut sw = wb.new_stream_writer("Combined").unwrap();
6544        sw.set_freeze_panes("A2").unwrap();
6545        sw.set_col_width(1, 30.0).unwrap();
6546        sw.set_col_width_range(2, 3, 15.0).unwrap();
6547        sw.add_merge_cell("B1:C1").unwrap();
6548        sw.write_row(
6549            1,
6550            &[
6551                CellValue::from("Name"),
6552                CellValue::from("Merged Header"),
6553                CellValue::Empty,
6554            ],
6555        )
6556        .unwrap();
6557        sw.write_row(
6558            2,
6559            &[
6560                CellValue::from("Alice"),
6561                CellValue::from(100),
6562                CellValue::from(true),
6563            ],
6564        )
6565        .unwrap();
6566        wb.apply_stream_writer(sw).unwrap();
6567        wb.save(&path).unwrap();
6568
6569        let wb2 = Workbook::open(&path).unwrap();
6570        assert_eq!(wb2.get_panes("Combined").unwrap(), Some("A2".to_string()));
6571        let merges = wb2.get_merge_cells("Combined").unwrap();
6572        assert!(merges.contains(&"B1:C1".to_string()));
6573        let w1 = wb2.get_col_width("Combined", "A").unwrap().unwrap();
6574        assert!((w1 - 30.0).abs() < 0.01);
6575        assert_eq!(
6576            wb2.get_cell_value("Combined", "A1").unwrap(),
6577            CellValue::String("Name".to_string())
6578        );
6579        assert_eq!(
6580            wb2.get_cell_value("Combined", "B2").unwrap(),
6581            CellValue::Number(100.0)
6582        );
6583        assert_eq!(
6584            wb2.get_cell_value("Combined", "C2").unwrap(),
6585            CellValue::Bool(true)
6586        );
6587    }
6588
6589    // --- Regression tests for P1 bugs ---
6590
6591    #[test]
6592    fn test_stream_formula_result_types_roundtrip() {
6593        // Regression: formula cached results must preserve their type via the
6594        // cell t attribute (t="str", t="b", t="e"). Without it, string results
6595        // are dropped and bool results are decoded as Number(1.0).
6596        let dir = TempDir::new().unwrap();
6597        let path = dir.path().join("stream_formula_types.xlsx");
6598
6599        let mut wb = Workbook::new();
6600        let mut sw = wb.new_stream_writer("Formulas").unwrap();
6601        sw.write_row(
6602            1,
6603            &[
6604                CellValue::Formula {
6605                    expr: "A2&B2".to_string(),
6606                    result: Some(Box::new(CellValue::String("hello".to_string()))),
6607                },
6608                CellValue::Formula {
6609                    expr: "A2>0".to_string(),
6610                    result: Some(Box::new(CellValue::Bool(true))),
6611                },
6612                CellValue::Formula {
6613                    expr: "1/0".to_string(),
6614                    result: Some(Box::new(CellValue::Error("#DIV/0!".to_string()))),
6615                },
6616                CellValue::Formula {
6617                    expr: "SUM(A2:A10)".to_string(),
6618                    result: Some(Box::new(CellValue::Number(55.0))),
6619                },
6620            ],
6621        )
6622        .unwrap();
6623        wb.apply_stream_writer(sw).unwrap();
6624        wb.save(&path).unwrap();
6625
6626        let wb2 = Workbook::open(&path).unwrap();
6627        // String result
6628        assert_eq!(
6629            wb2.get_cell_value("Formulas", "A1").unwrap(),
6630            CellValue::Formula {
6631                expr: "A2&B2".to_string(),
6632                result: Some(Box::new(CellValue::String("hello".to_string()))),
6633            }
6634        );
6635        // Bool result
6636        assert_eq!(
6637            wb2.get_cell_value("Formulas", "B1").unwrap(),
6638            CellValue::Formula {
6639                expr: "A2>0".to_string(),
6640                result: Some(Box::new(CellValue::Bool(true))),
6641            }
6642        );
6643        // Error result
6644        assert_eq!(
6645            wb2.get_cell_value("Formulas", "C1").unwrap(),
6646            CellValue::Formula {
6647                expr: "1/0".to_string(),
6648                result: Some(Box::new(CellValue::Error("#DIV/0!".to_string()))),
6649            }
6650        );
6651        // Numeric result
6652        assert_eq!(
6653            wb2.get_cell_value("Formulas", "D1").unwrap(),
6654            CellValue::Formula {
6655                expr: "SUM(A2:A10)".to_string(),
6656                result: Some(Box::new(CellValue::Number(55.0))),
6657            }
6658        );
6659    }
6660
6661    #[test]
6662    fn test_stream_edit_after_apply_is_rejected_without_losing_rows() {
6663        let dir = TempDir::new().unwrap();
6664        let path = dir.path().join("stream_edit_after.xlsx");
6665
6666        let mut wb = Workbook::new();
6667        let mut sw = wb.new_stream_writer("S").unwrap();
6668        sw.write_row(1, &[CellValue::from("old")]).unwrap();
6669        wb.apply_stream_writer(sw).unwrap();
6670
6671        let error = wb.set_cell_value("S", "A1", "new").unwrap_err();
6672        assert!(matches!(error, Error::StreamedSheetMutation { .. }));
6673        wb.save(&path).unwrap();
6674
6675        let wb2 = Workbook::open(&path).unwrap();
6676        assert_eq!(
6677            wb2.get_cell_value("S", "A1").unwrap(),
6678            CellValue::String("old".to_string())
6679        );
6680    }
6681
6682    #[test]
6683    fn test_stream_copy_sheet_preserves_data() {
6684        // Regression: copy_sheet must clone the streamed payload so both
6685        // source and target sheets have the streamed data on save.
6686        let dir = TempDir::new().unwrap();
6687        let path = dir.path().join("stream_copy.xlsx");
6688
6689        let mut wb = Workbook::new();
6690        let mut sw = wb.new_stream_writer("Src").unwrap();
6691        sw.write_row(1, &[CellValue::from("x")]).unwrap();
6692        sw.write_row(2, &[CellValue::from("y")]).unwrap();
6693        wb.apply_stream_writer(sw).unwrap();
6694
6695        wb.copy_sheet("Src", "Dst").unwrap();
6696        wb.save(&path).unwrap();
6697
6698        let wb2 = Workbook::open(&path).unwrap();
6699        assert_eq!(
6700            wb2.get_cell_value("Src", "A1").unwrap(),
6701            CellValue::String("x".to_string())
6702        );
6703        assert_eq!(
6704            wb2.get_cell_value("Src", "A2").unwrap(),
6705            CellValue::String("y".to_string())
6706        );
6707        assert_eq!(
6708            wb2.get_cell_value("Dst", "A1").unwrap(),
6709            CellValue::String("x".to_string())
6710        );
6711        assert_eq!(
6712            wb2.get_cell_value("Dst", "A2").unwrap(),
6713            CellValue::String("y".to_string())
6714        );
6715    }
6716}