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
20fn 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
37fn 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
66fn 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#[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
89fn 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
130fn 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
159fn 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
199fn 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 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 pub fn sheet_names(&self) -> Vec<&str> {
679 self.worksheets
680 .iter()
681 .map(|(name, _)| name.as_str())
682 .collect()
683 }
684
685 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 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 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 self.tables.retain(|(_, _, si)| *si != idx);
791 for (_, _, si) in &mut self.tables {
792 if *si > idx {
793 *si -= 1;
794 }
795 }
796
797 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 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 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 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 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 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 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 pub fn get_sheet_index(&self, name: &str) -> Option<usize> {
1778 crate::sheet::find_sheet_index(&self.worksheets, name)
1779 }
1780
1781 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 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 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 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 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 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 self.streamed_sheets.insert(idx, streamed_data);
1858
1859 self.rebuild_sheet_index();
1860 Ok(idx)
1861 }
1862
1863 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 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 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 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 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 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 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 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 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 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 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 #[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 #[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 #[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 #[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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 let ws_rid = self.next_worksheet_rid(sheet_idx);
3449 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 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 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 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 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 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 wb.delete_sheet("Sheet2").unwrap();
3756 assert_eq!(wb.sheet_names(), vec!["Sheet1", "Sheet3"]);
3757
3758 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 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 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 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 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 #[test]
6592 fn test_stream_formula_result_types_roundtrip() {
6593 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 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 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 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 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 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}