1use std::borrow::Cow;
37
38use crate::error::{Error, Result};
39use crate::raw_transfer::{inline_string_visible_text, RawValueBudget, SharedFormulaResolver};
40use crate::resource::ResourceDimension;
41use crate::sst::SharedStringTable;
42use crate::traversal::{
43 check_limit, checked_output_add, checked_output_mul, CheckedRect, TraversalLimits,
44 TraversalMode, TraversalOptions,
45};
46use crate::utils::cell_ref::cell_name_to_coordinates;
47use sheetkit_xml::worksheet::{CellTypeTag, WorksheetXml};
48
49pub const MAGIC_V2: u32 = 0x534B5232;
50pub const VERSION_V2: u16 = 2;
51pub const HEADER_SIZE: usize = 16;
52
53pub const TYPE_EMPTY: u8 = 0x00;
54pub const TYPE_NUMBER: u8 = 0x01;
55pub const TYPE_STRING: u8 = 0x02;
56pub const TYPE_BOOL: u8 = 0x03;
57pub const TYPE_DATE: u8 = 0x04;
58pub const TYPE_ERROR: u8 = 0x05;
59pub const TYPE_FORMULA: u8 = 0x06;
60pub const TYPE_RICH_STRING: u8 = 0x07;
61
62#[cfg(test)]
63const EMPTY_ROW_OFFSET: u32 = 0xFFFF_FFFF;
64
65struct CellEntryV2<'a> {
67 col: u16,
68 type_tag: u8,
69 payload: CellPayload<'a>,
70}
71
72enum CellPayload<'a> {
76 Empty,
77 Number(f64),
78 Bool(u8),
79 Str(Cow<'a, str>),
80}
81
82impl CellPayload<'_> {
83 fn byte_size(&self, limits: TraversalLimits) -> Result<u64> {
84 match self {
85 CellPayload::Empty => Ok(0),
86 CellPayload::Number(_) => Ok(8),
87 CellPayload::Bool(_) => Ok(1),
88 CellPayload::Str(s) => checked_output_add(4, s.len() as u64, limits),
89 }
90 }
91
92 fn write_to(&self, buf: &mut Vec<u8>) {
93 match self {
94 CellPayload::Empty => {}
95 CellPayload::Number(n) => {
96 buf.extend_from_slice(&n.to_le_bytes());
97 }
98 CellPayload::Bool(b) => {
99 buf.push(*b);
100 }
101 CellPayload::Str(s) => {
102 buf.extend_from_slice(&(s.len() as u32).to_le_bytes());
103 buf.extend_from_slice(s.as_bytes());
104 }
105 }
106 }
107}
108
109struct RowEntriesV2<'a> {
110 row_num: u32,
111 cells: Vec<CellEntryV2<'a>>,
112}
113
114impl RowEntriesV2<'_> {
115 fn byte_size(&self, limits: TraversalLimits) -> Result<u64> {
117 let mut size = 2u64;
118 for cell in &self.cells {
119 size = checked_output_add(size, 3, limits)?;
120 size = checked_output_add(size, cell.payload.byte_size(limits)?, limits)?;
121 }
122 Ok(size)
123 }
124}
125
126pub fn sheet_to_raw_buffer_v2(ws: &WorksheetXml, sst: &SharedStringTable) -> Result<Vec<u8>> {
132 sheet_to_raw_buffer_v2_with_options(ws, sst, TraversalOptions::default())
133}
134
135pub fn sheet_to_raw_buffer_v2_with_options(
137 ws: &WorksheetXml,
138 sst: &SharedStringTable,
139 options: TraversalOptions,
140) -> Result<Vec<u8>> {
141 sheet_to_raw_buffer_v2_with_date_styles_and_options(ws, sst, &[], options)
142}
143
144pub fn sheet_to_raw_buffer_v2_with_date_styles(
146 ws: &WorksheetXml,
147 sst: &SharedStringTable,
148 style_is_date: &[bool],
149) -> Result<Vec<u8>> {
150 sheet_to_raw_buffer_v2_with_date_styles_and_options(
151 ws,
152 sst,
153 style_is_date,
154 TraversalOptions::default(),
155 )
156}
157
158pub fn sheet_to_raw_buffer_v2_with_date_styles_and_options(
160 ws: &WorksheetXml,
161 sst: &SharedStringTable,
162 style_is_date: &[bool],
163 options: TraversalOptions,
164) -> Result<Vec<u8>> {
165 if options.mode() != TraversalMode::Sparse {
166 return Err(Error::Internal(
167 "raw transfer v2 supports sparse traversal only".to_string(),
168 ));
169 }
170 let rows = &ws.sheet_data.rows;
171 let limits = options.limits();
172
173 if rows.is_empty() {
174 return write_empty_buffer(limits);
175 }
176
177 let (min_row, max_row, min_col, max_col, total_cells) = scan_dimensions(ws, limits)?;
178
179 if total_cells == 0 {
180 return write_empty_buffer(limits);
181 }
182
183 let rect = CheckedRect::new_sparse(min_row, max_row, min_col, max_col, limits)?;
184 let occupied_rows = rows.iter().filter(|row| !row.cells.is_empty()).count() as u64;
185 check_limit(
186 ResourceDimension::RowCount,
187 limits.max_rows(),
188 occupied_rows,
189 )?;
190 check_limit(
191 ResourceDimension::CellCount,
192 limits.max_cells(),
193 total_cells,
194 )?;
195 let row_count = occupied_rows;
196 let col_count = rect.column_count();
197
198 let mut raw_value_budget = RawValueBudget::new(limits);
199 let shared_formulas = SharedFormulaResolver::new(ws, &mut raw_value_budget)?;
200 let mut cell_entries = collect_cell_entries_v2(
201 ws,
202 sst,
203 &shared_formulas,
204 &mut raw_value_budget,
205 min_col,
206 style_is_date,
207 limits,
208 occupied_rows,
209 )?;
210 cell_entries.sort_unstable_by_key(|row| row.row_num);
211
212 let flags: u32 = (min_col & 0xFFFF) << 16;
213
214 let row_index_size = checked_output_mul(row_count, 8, limits)?;
215 let mut row_sizes = Vec::new();
216 row_sizes
217 .try_reserve_exact(cell_entries.len())
218 .map_err(|_| Error::Internal("raw transfer v2 row size allocation failed".to_string()))?;
219 let cell_data_size = cell_entries.iter().try_fold(0u64, |total, row| {
220 let row_size = row.byte_size(limits)?;
221 row_sizes.push(row_size);
222 checked_output_add(total, row_size, limits)
223 })?;
224 let total_size = checked_output_add(
225 checked_output_add(HEADER_SIZE as u64, row_index_size, limits)?,
226 cell_data_size,
227 limits,
228 )?;
229 let total_size = usize::try_from(total_size)
230 .map_err(|_| Error::Internal("raw transfer v2 output is not addressable".to_string()))?;
231
232 validate_cell_data_v2(&cell_entries, cell_data_size)?;
233 validate_row_index_v2(&row_sizes, row_index_size)?;
234
235 let mut buf = Vec::new();
236 buf.try_reserve_exact(total_size)
237 .map_err(|_| Error::Internal("raw transfer v2 output allocation failed".to_string()))?;
238
239 buf.extend_from_slice(&MAGIC_V2.to_le_bytes());
240 buf.extend_from_slice(&VERSION_V2.to_le_bytes());
241 buf.extend_from_slice(&(row_count as u32).to_le_bytes());
242 buf.extend_from_slice(&(col_count as u16).to_le_bytes());
243 buf.extend_from_slice(&flags.to_le_bytes());
244
245 write_row_index_v2(&mut buf, &cell_entries, &row_sizes);
246 write_cell_data_v2(&mut buf, &cell_entries);
247 debug_assert_eq!(buf.len(), total_size);
248
249 Ok(buf)
250}
251
252fn write_empty_buffer(limits: TraversalLimits) -> Result<Vec<u8>> {
253 checked_output_add(0, HEADER_SIZE as u64, limits)?;
254 let mut buf = Vec::new();
255 buf.try_reserve_exact(HEADER_SIZE)
256 .map_err(|_| Error::Internal("raw transfer v2 output allocation failed".to_string()))?;
257 buf.extend_from_slice(&MAGIC_V2.to_le_bytes());
258 buf.extend_from_slice(&VERSION_V2.to_le_bytes());
259 buf.extend_from_slice(&0u32.to_le_bytes());
260 buf.extend_from_slice(&0u16.to_le_bytes());
261 buf.extend_from_slice(&0u32.to_le_bytes());
262 Ok(buf)
263}
264
265fn scan_dimensions(
266 ws: &WorksheetXml,
267 limits: TraversalLimits,
268) -> Result<(u32, u32, u32, u32, u64)> {
269 let mut min_row = u32::MAX;
270 let mut max_row = 0u32;
271 let mut min_col = u32::MAX;
272 let mut max_col = 0u32;
273 let mut total_cells = 0u64;
274
275 for row in &ws.sheet_data.rows {
276 if row.cells.is_empty() {
277 continue;
278 }
279 min_row = min_row.min(row.r);
280 max_row = max_row.max(row.r);
281 total_cells = total_cells
282 .checked_add(row.cells.len() as u64)
283 .ok_or_else(|| Error::Internal("raw transfer v2 cell count overflow".to_string()))?;
284 check_limit(
285 ResourceDimension::CellCount,
286 limits.max_cells(),
287 total_cells,
288 )?;
289 for cell in &row.cells {
290 let col = resolve_col(cell)?;
291 min_col = min_col.min(col);
292 max_col = max_col.max(col);
293 }
294 }
295
296 if total_cells == 0 {
297 return Ok((1, 1, 1, 1, 0));
298 }
299
300 Ok((min_row, max_row, min_col, max_col, total_cells))
301}
302
303fn resolve_col(cell: &sheetkit_xml::worksheet::Cell) -> Result<u32> {
304 if cell.col > 0 {
305 return Ok(cell.col);
306 }
307 let (col, _row) = cell_name_to_coordinates(cell.r.as_str())?;
308 Ok(col)
309}
310
311#[allow(clippy::too_many_arguments)]
312fn collect_cell_entries_v2<'a>(
313 ws: &'a WorksheetXml,
314 sst: &'a SharedStringTable,
315 shared_formulas: &'a SharedFormulaResolver,
316 raw_value_budget: &mut RawValueBudget,
317 min_col: u32,
318 style_is_date: &[bool],
319 limits: TraversalLimits,
320 occupied_rows: u64,
321) -> Result<Vec<RowEntriesV2<'a>>> {
322 let mut result = Vec::new();
323 let occupied_rows = usize::try_from(occupied_rows)
324 .map_err(|_| Error::Internal("raw transfer v2 row count is not addressable".to_string()))?;
325 result
326 .try_reserve_exact(occupied_rows)
327 .map_err(|_| Error::Internal("raw transfer v2 row allocation failed".to_string()))?;
328 let mut payload_bytes = 0u64;
329
330 for row in &ws.sheet_data.rows {
331 if row.cells.is_empty() {
332 continue;
333 }
334
335 check_limit(
336 ResourceDimension::ColumnCount,
337 limits.max_columns(),
338 row.cells.len() as u64,
339 )?;
340 let mut cells = Vec::new();
341 cells
342 .try_reserve_exact(row.cells.len())
343 .map_err(|_| Error::Internal("raw transfer v2 cell allocation failed".to_string()))?;
344 for cell in &row.cells {
345 let col = resolve_col(cell)?;
346 let relative_col = (col - min_col) as u16;
347 let (type_tag, payload) = encode_cell_value_v2(
348 cell,
349 sst,
350 shared_formulas,
351 style_is_date,
352 limits,
353 &mut payload_bytes,
354 raw_value_budget,
355 )?;
356 cells.push(CellEntryV2 {
357 col: relative_col,
358 type_tag,
359 payload,
360 });
361 }
362
363 result.push(RowEntriesV2 {
364 row_num: row.r,
365 cells,
366 });
367 }
368
369 Ok(result)
370}
371
372fn encode_cell_value_v2<'a>(
373 cell: &'a sheetkit_xml::worksheet::Cell,
374 sst: &'a SharedStringTable,
375 shared_formulas: &'a SharedFormulaResolver,
376 style_is_date: &[bool],
377 limits: TraversalLimits,
378 payload_bytes: &mut u64,
379 raw_value_budget: &mut RawValueBudget,
380) -> Result<(u8, CellPayload<'a>)> {
381 if cell.f.is_some() {
382 if let Some(formula_expr) = shared_formulas.formula_for(cell, raw_value_budget)? {
383 let formula_expr = bounded_string(formula_expr, limits, payload_bytes)?;
384 return Ok((TYPE_FORMULA, CellPayload::Str(formula_expr)));
385 }
386 }
387
388 match cell.t {
389 CellTypeTag::SharedString => {
390 if let Some(ref v) = cell.v {
391 if let Ok(sst_idx) = v.parse::<usize>() {
392 let text = sst.get(sst_idx).unwrap_or("");
393 if sst.get_rich_text(sst_idx).is_some() {
394 return Ok((
395 TYPE_RICH_STRING,
396 CellPayload::Str(bounded_string(
397 Cow::Borrowed(text),
398 limits,
399 payload_bytes,
400 )?),
401 ));
402 }
403 return Ok((
404 TYPE_STRING,
405 CellPayload::Str(bounded_string(
406 Cow::Borrowed(text),
407 limits,
408 payload_bytes,
409 )?),
410 ));
411 }
412 }
413 Ok((TYPE_EMPTY, CellPayload::Empty))
414 }
415 CellTypeTag::Boolean => {
416 let b = if let Some(ref v) = cell.v {
417 if v == "1" || v.eq_ignore_ascii_case("true") {
418 1u8
419 } else {
420 0u8
421 }
422 } else {
423 0u8
424 };
425 Ok((TYPE_BOOL, CellPayload::Bool(b)))
426 }
427 CellTypeTag::Error => {
428 let error_text = cell.v.as_deref().unwrap_or("#VALUE!");
429 Ok((
430 TYPE_ERROR,
431 CellPayload::Str(bounded_string(
432 Cow::Borrowed(error_text),
433 limits,
434 payload_bytes,
435 )?),
436 ))
437 }
438 CellTypeTag::InlineString => {
439 let text = if let Some(inline) = cell.is.as_deref() {
440 inline_string_visible_text(inline, raw_value_budget)?
441 } else {
442 Cow::Borrowed(cell.v.as_deref().unwrap_or(""))
443 };
444 Ok((
445 TYPE_STRING,
446 CellPayload::Str(bounded_string(text, limits, payload_bytes)?),
447 ))
448 }
449 CellTypeTag::Date => {
450 if let Some(ref v) = cell.v {
451 if let Ok(n) = v.parse::<f64>() {
452 return Ok((TYPE_DATE, CellPayload::Number(n)));
453 }
454 }
455 Ok((TYPE_EMPTY, CellPayload::Empty))
456 }
457 CellTypeTag::FormulaString => {
458 if let Some(ref v) = cell.v {
459 return Ok((
460 TYPE_STRING,
461 CellPayload::Str(bounded_string(Cow::Borrowed(v), limits, payload_bytes)?),
462 ));
463 }
464 Ok((TYPE_EMPTY, CellPayload::Empty))
465 }
466 CellTypeTag::None | CellTypeTag::Number => {
467 if let Some(ref v) = cell.v {
468 if let Ok(n) = v.parse::<f64>() {
469 let is_date = cell
470 .s
471 .and_then(|idx| style_is_date.get(idx as usize).copied())
472 .unwrap_or(false);
473 return Ok((
474 if is_date { TYPE_DATE } else { TYPE_NUMBER },
475 CellPayload::Number(n),
476 ));
477 }
478 }
479 Ok((TYPE_EMPTY, CellPayload::Empty))
480 }
481 }
482}
483
484fn bounded_string<'a>(
487 value: Cow<'a, str>,
488 limits: TraversalLimits,
489 payload_bytes: &mut u64,
490) -> Result<Cow<'a, str>> {
491 *payload_bytes = checked_output_add(*payload_bytes, value.len() as u64, limits)?;
492 Ok(value)
493}
494
495fn validate_cell_data_v2(row_entries: &[RowEntriesV2<'_>], total: u64) -> Result<()> {
497 usize::try_from(total)
498 .map_err(|_| Error::Internal("raw transfer v2 cell data is too large".to_string()))?;
499 for row in row_entries {
500 u16::try_from(row.cells.len())
501 .map_err(|_| Error::Internal("raw transfer v2 row has too many cells".to_string()))?;
502 }
503 Ok(())
504}
505
506fn validate_row_index_v2(row_sizes: &[u64], total: u64) -> Result<()> {
508 usize::try_from(total)
509 .map_err(|_| Error::Internal("raw transfer v2 row index is too large".to_string()))?;
510 let mut byte_offset = 0u32;
511 for row_size in row_sizes {
512 let row_size = u32::try_from(*row_size)
513 .map_err(|_| Error::Internal("raw transfer v2 row is too large".to_string()))?;
514 byte_offset = byte_offset
515 .checked_add(row_size)
516 .ok_or_else(|| Error::Internal("raw transfer v2 offset overflow".to_string()))?;
517 }
518 Ok(())
519}
520
521fn write_row_index_v2(buf: &mut Vec<u8>, row_entries: &[RowEntriesV2<'_>], row_sizes: &[u64]) {
523 let mut byte_offset = 0u32;
524 for (row, row_size) in row_entries.iter().zip(row_sizes) {
525 buf.extend_from_slice(&row.row_num.to_le_bytes());
526 buf.extend_from_slice(&byte_offset.to_le_bytes());
527 byte_offset = byte_offset.wrapping_add(*row_size as u32);
528 }
529}
530
531fn write_cell_data_v2(buf: &mut Vec<u8>, row_entries: &[RowEntriesV2<'_>]) {
533 for row in row_entries {
534 buf.extend_from_slice(&(row.cells.len() as u16).to_le_bytes());
535 for cell in &row.cells {
536 buf.extend_from_slice(&cell.col.to_le_bytes());
537 buf.push(cell.type_tag);
538 cell.payload.write_to(buf);
539 }
540 }
541}
542
543#[cfg(test)]
544#[allow(clippy::field_reassign_with_default)]
545mod tests {
546 use super::*;
547 use sheetkit_xml::shared_strings::{R, T};
548 use sheetkit_xml::worksheet::{
549 Cell, CellFormula, CellTypeTag, CompactCellRef, InlineString, Row, SheetData, WorksheetXml,
550 };
551
552 fn make_cell(col_ref: &str, col_num: u32, t: CellTypeTag, v: Option<&str>) -> Cell {
553 Cell {
554 r: CompactCellRef::new(col_ref).unwrap(),
555 col: col_num,
556 s: None,
557 t,
558 v: v.map(|s| s.to_string()),
559 f: None,
560 is: None,
561 }
562 }
563
564 fn make_row(row_num: u32, cells: Vec<Cell>) -> Row {
565 Row {
566 r: row_num,
567 spans: None,
568 s: None,
569 custom_format: None,
570 ht: None,
571 hidden: None,
572 custom_height: None,
573 outline_level: None,
574 cells,
575 }
576 }
577
578 fn make_worksheet(rows: Vec<Row>) -> WorksheetXml {
579 let mut ws = WorksheetXml::default();
580 ws.sheet_data = SheetData { rows };
581 ws
582 }
583
584 fn make_sst(strings: &[&str]) -> SharedStringTable {
585 let mut sst = SharedStringTable::new();
586 for s in strings {
587 sst.add(s);
588 }
589 sst
590 }
591
592 fn read_u32_le(buf: &[u8], offset: usize) -> u32 {
593 u32::from_le_bytes(buf[offset..offset + 4].try_into().unwrap())
594 }
595
596 fn read_u16_le(buf: &[u8], offset: usize) -> u16 {
597 u16::from_le_bytes(buf[offset..offset + 2].try_into().unwrap())
598 }
599
600 fn read_f64_le(buf: &[u8], offset: usize) -> f64 {
601 f64::from_le_bytes(buf[offset..offset + 8].try_into().unwrap())
602 }
603
604 fn read_inline_string(buf: &[u8], offset: usize) -> (String, usize) {
605 let len = read_u32_le(buf, offset) as usize;
606 let s = std::str::from_utf8(&buf[offset + 4..offset + 4 + len])
607 .unwrap()
608 .to_string();
609 (s, 4 + len)
610 }
611
612 fn read_v2_row_cells(buf: &[u8], abs_offset: usize) -> Vec<(u16, u8, String)> {
615 let cell_count = read_u16_le(buf, abs_offset) as usize;
616 let mut pos = abs_offset + 2;
617 let mut result = Vec::with_capacity(cell_count);
618
619 for _ in 0..cell_count {
620 let col = read_u16_le(buf, pos);
621 let type_tag = buf[pos + 2];
622 pos += 3;
623
624 let val = match type_tag {
625 TYPE_EMPTY => String::new(),
626 TYPE_NUMBER | TYPE_DATE => {
627 let n = read_f64_le(buf, pos);
628 pos += 8;
629 format!("{n}")
630 }
631 TYPE_BOOL => {
632 let b = buf[pos];
633 pos += 1;
634 format!("{b}")
635 }
636 TYPE_STRING | TYPE_ERROR | TYPE_FORMULA | TYPE_RICH_STRING => {
637 let (s, consumed) = read_inline_string(buf, pos);
638 pos += consumed;
639 s
640 }
641 _ => panic!("unknown type tag: {type_tag}"),
642 };
643
644 result.push((col, type_tag, val));
645 }
646
647 result
648 }
649
650 #[test]
651 fn test_empty_sheet() {
652 let ws = make_worksheet(vec![]);
653 let sst = SharedStringTable::new();
654 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
655
656 assert_eq!(buf.len(), HEADER_SIZE);
657 assert_eq!(read_u32_le(&buf, 0), MAGIC_V2);
658 assert_eq!(read_u16_le(&buf, 4), VERSION_V2);
659 assert_eq!(read_u32_le(&buf, 6), 0);
660 assert_eq!(read_u16_le(&buf, 10), 0);
661 assert_eq!(read_u32_le(&buf, 12), 0);
662 }
663
664 #[test]
665 fn test_single_number_cell() {
666 let ws = make_worksheet(vec![make_row(
667 1,
668 vec![make_cell("A1", 1, CellTypeTag::None, Some("42.5"))],
669 )]);
670 let sst = SharedStringTable::new();
671 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
672
673 assert_eq!(read_u32_le(&buf, 0), MAGIC_V2);
674 assert_eq!(read_u32_le(&buf, 6), 1); assert_eq!(read_u16_le(&buf, 10), 1); let row_index_start = HEADER_SIZE;
678 let row1_num = read_u32_le(&buf, row_index_start);
679 let row1_offset = read_u32_le(&buf, row_index_start + 4);
680 assert_eq!(row1_num, 1);
681 assert_ne!(row1_offset, EMPTY_ROW_OFFSET);
682
683 let cell_data_start = HEADER_SIZE + 8;
684 let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
685 assert_eq!(cells.len(), 1);
686 assert_eq!(cells[0].0, 0); assert_eq!(cells[0].1, TYPE_NUMBER);
688 assert_eq!(cells[0].2, "42.5");
689 }
690
691 #[test]
692 fn test_string_cell_sst() {
693 let sst = make_sst(&["Hello", "World"]);
694 let ws = make_worksheet(vec![make_row(
695 1,
696 vec![make_cell("A1", 1, CellTypeTag::SharedString, Some("1"))],
697 )]);
698 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
699
700 let cell_data_start = HEADER_SIZE + 8;
701 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
702 let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
703
704 assert_eq!(cells.len(), 1);
705 assert_eq!(cells[0].1, TYPE_STRING);
706 assert_eq!(cells[0].2, "World"); }
708
709 #[test]
710 fn test_bool_cell() {
711 let sst = SharedStringTable::new();
712 let ws = make_worksheet(vec![make_row(
713 1,
714 vec![
715 make_cell("A1", 1, CellTypeTag::Boolean, Some("1")),
716 make_cell("B1", 2, CellTypeTag::Boolean, Some("0")),
717 ],
718 )]);
719 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
720
721 let cell_data_start = HEADER_SIZE + 8;
722 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
723 let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
724
725 assert_eq!(cells.len(), 2);
726 assert_eq!(cells[0].1, TYPE_BOOL);
727 assert_eq!(cells[0].2, "1");
728 assert_eq!(cells[1].1, TYPE_BOOL);
729 assert_eq!(cells[1].2, "0");
730 }
731
732 #[test]
733 fn test_error_cell() {
734 let sst = SharedStringTable::new();
735 let ws = make_worksheet(vec![make_row(
736 1,
737 vec![make_cell("A1", 1, CellTypeTag::Error, Some("#DIV/0!"))],
738 )]);
739 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
740
741 let cell_data_start = HEADER_SIZE + 8;
742 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
743 let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
744
745 assert_eq!(cells.len(), 1);
746 assert_eq!(cells[0].1, TYPE_ERROR);
747 assert_eq!(cells[0].2, "#DIV/0!");
748 }
749
750 #[test]
751 fn test_formula_cell() {
752 let sst = SharedStringTable::new();
753 let mut cell = make_cell("A1", 1, CellTypeTag::None, Some("84"));
754 cell.f = Some(Box::new(CellFormula {
755 t: None,
756 reference: None,
757 si: None,
758 value: Some("A2+B2".to_string()),
759 }));
760 let ws = make_worksheet(vec![make_row(1, vec![cell])]);
761 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
762
763 let cell_data_start = HEADER_SIZE + 8;
764 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
765 let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
766
767 assert_eq!(cells.len(), 1);
768 assert_eq!(cells[0].1, TYPE_FORMULA);
769 assert_eq!(cells[0].2, "A2+B2");
770 }
771
772 #[test]
773 fn test_shared_formula_followers_shift_relative_references() {
774 let sst = SharedStringTable::new();
775 let mut master = make_cell("B2", 2, CellTypeTag::None, Some("1"));
776 master.f = Some(Box::new(CellFormula {
777 t: Some("shared".to_string()),
778 reference: Some("B2:C3".to_string()),
779 si: Some(7),
780 value: Some("A2+$A$1".to_string()),
781 }));
782 let mut across = make_cell("C2", 3, CellTypeTag::None, Some("2"));
783 across.f = Some(Box::new(CellFormula {
784 t: Some("shared".to_string()),
785 reference: None,
786 si: Some(7),
787 value: None,
788 }));
789 let mut down = make_cell("B3", 2, CellTypeTag::None, Some("3"));
790 down.f = Some(Box::new(CellFormula {
791 t: Some("shared".to_string()),
792 reference: None,
793 si: Some(7),
794 value: None,
795 }));
796 let ws = make_worksheet(vec![
797 make_row(2, vec![master, across]),
798 make_row(3, vec![down]),
799 ]);
800 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
801 let cell_data_start = HEADER_SIZE + 16;
802 let row2_offset = read_u32_le(&buf, HEADER_SIZE + 4);
803 let row3_offset = read_u32_le(&buf, HEADER_SIZE + 12);
804 let row2 = read_v2_row_cells(&buf, cell_data_start + row2_offset as usize);
805 let row3 = read_v2_row_cells(&buf, cell_data_start + row3_offset as usize);
806
807 assert_eq!(
808 row2,
809 vec![
810 (0, TYPE_FORMULA, "A2+$A$1".to_string()),
811 (1, TYPE_FORMULA, "B2+$A$1".to_string())
812 ]
813 );
814 assert_eq!(row3, vec![(0, TYPE_FORMULA, "A3+$A$1".to_string())]);
815 }
816
817 #[test]
818 fn v1_and_v2_match_for_budgeted_shared_formulas_and_inline_rich_text() {
819 let sst = SharedStringTable::new();
820 let mut master = make_cell("A1", 1, CellTypeTag::None, Some("1"));
821 master.f = Some(Box::new(CellFormula {
822 t: Some("shared".to_string()),
823 reference: Some("A1:B1".to_string()),
824 si: Some(12),
825 value: Some("A1+$A$1".to_string()),
826 }));
827 let mut follower = make_cell("B1", 2, CellTypeTag::None, Some("2"));
828 follower.f = Some(Box::new(CellFormula {
829 t: Some("shared".to_string()),
830 reference: None,
831 si: Some(12),
832 value: None,
833 }));
834 let mut rich = make_cell("C1", 3, CellTypeTag::InlineString, None);
835 rich.is = Some(Box::new(InlineString {
836 t: None,
837 r: vec![
838 R {
839 r_pr: None,
840 t: T {
841 xml_space: None,
842 value: "Rich".to_string(),
843 },
844 },
845 R {
846 r_pr: None,
847 t: T {
848 xml_space: None,
849 value: " Text".to_string(),
850 },
851 },
852 ],
853 r_ph: vec![],
854 }));
855 let ws = make_worksheet(vec![make_row(1, vec![master, follower, rich])]);
856
857 let v1 = crate::raw_transfer::sheet_to_raw_buffer(&ws, &sst).unwrap();
858 let v2 = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
859
860 assert_eq!(
861 crate::raw_transfer_write::raw_buffer_to_cells(&v1).unwrap(),
862 crate::raw_transfer_write::raw_buffer_to_cells(&v2).unwrap()
863 );
864 }
865
866 #[test]
867 fn test_shared_formula_without_master_uses_cached_value_or_empty() {
868 let sst = SharedStringTable::new();
869 let mut cached = make_cell("A1", 1, CellTypeTag::None, Some("17"));
870 cached.f = Some(Box::new(CellFormula {
871 t: Some("shared".to_string()),
872 reference: None,
873 si: Some(99),
874 value: None,
875 }));
876 let mut missing = make_cell("B1", 2, CellTypeTag::None, None);
877 missing.f = Some(Box::new(CellFormula {
878 t: Some("shared".to_string()),
879 reference: None,
880 si: Some(99),
881 value: None,
882 }));
883 let ws = make_worksheet(vec![make_row(1, vec![cached, missing])]);
884 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
885 let cells = read_v2_row_cells(&buf, HEADER_SIZE + 8);
886
887 assert_eq!(cells[0], (0, TYPE_NUMBER, "17".to_string()));
888 assert_eq!(cells[1], (1, TYPE_EMPTY, String::new()));
889 }
890
891 #[test]
892 fn test_inline_string_cell() {
893 let sst = SharedStringTable::new();
894 let mut cell = make_cell("A1", 1, CellTypeTag::InlineString, None);
895 cell.is = Some(Box::new(InlineString {
896 t: Some("Inline Text".to_string()),
897 r: vec![],
898 r_ph: vec![],
899 }));
900 let ws = make_worksheet(vec![make_row(1, vec![cell])]);
901 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
902
903 let cell_data_start = HEADER_SIZE + 8;
904 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
905 let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
906
907 assert_eq!(cells.len(), 1);
908 assert_eq!(cells[0].1, TYPE_STRING);
909 assert_eq!(cells[0].2, "Inline Text");
910 }
911
912 #[test]
913 fn test_inline_string_preserves_escaped_visible_text() {
914 let sst = SharedStringTable::new();
915 let mut cell = make_cell("A1", 1, CellTypeTag::InlineString, None);
916 cell.is = Some(Box::new(InlineString {
917 t: Some("A < B & C".to_string()),
918 r: vec![],
919 r_ph: vec![],
920 }));
921 let ws = make_worksheet(vec![make_row(1, vec![cell])]);
922 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
923 let cells = read_v2_row_cells(&buf, HEADER_SIZE + 8);
924
925 assert_eq!(cells, vec![(0, TYPE_STRING, "A < B & C".to_string())]);
926 }
927
928 #[test]
929 fn test_inline_rich_text_concatenates_runs_without_phonetics() {
930 let sst = SharedStringTable::new();
931 let mut cell = make_cell("A1", 1, CellTypeTag::InlineString, None);
932 cell.is = Some(Box::new(InlineString {
933 t: None,
934 r: vec![
935 R {
936 r_pr: None,
937 t: T {
938 xml_space: None,
939 value: "Bold".to_string(),
940 },
941 },
942 R {
943 r_pr: None,
944 t: T {
945 xml_space: Some("preserve".to_string()),
946 value: " Text & More".to_string(),
947 },
948 },
949 ],
950 r_ph: vec![sheetkit_xml::worksheet::PhoneticRun {
951 sb: Some(0),
952 eb: Some(4),
953 value: "phonetic".to_string(),
954 }],
955 }));
956 let ws = make_worksheet(vec![make_row(1, vec![cell])]);
957 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
958 let cells = read_v2_row_cells(&buf, HEADER_SIZE + 8);
959
960 assert_eq!(
961 cells,
962 vec![(0, TYPE_STRING, "Bold Text & More".to_string())]
963 );
964 }
965
966 #[test]
967 fn test_date_cell() {
968 let sst = SharedStringTable::new();
969 let ws = make_worksheet(vec![make_row(
970 1,
971 vec![make_cell("A1", 1, CellTypeTag::Date, Some("44927.0"))],
972 )]);
973 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
974
975 let cell_data_start = HEADER_SIZE + 8;
976 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
977 let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
978
979 assert_eq!(cells.len(), 1);
980 assert_eq!(cells[0].1, TYPE_DATE);
981 let val: f64 = cells[0].2.parse().unwrap();
982 assert!((val - 44927.0).abs() < f64::EPSILON);
983 }
984
985 #[test]
986 fn test_mixed_types_row() {
987 let sst = make_sst(&["Hello"]);
988 let ws = make_worksheet(vec![make_row(
989 1,
990 vec![
991 make_cell("A1", 1, CellTypeTag::None, Some("3.14")),
992 make_cell("B1", 2, CellTypeTag::SharedString, Some("0")),
993 make_cell("C1", 3, CellTypeTag::Boolean, Some("1")),
994 ],
995 )]);
996 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
997
998 let cell_data_start = HEADER_SIZE + 8;
999 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1000 let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
1001
1002 assert_eq!(cells.len(), 3);
1003 assert_eq!(cells[0].1, TYPE_NUMBER);
1004 assert_eq!(cells[1].1, TYPE_STRING);
1005 assert_eq!(cells[1].2, "Hello");
1006 assert_eq!(cells[2].1, TYPE_BOOL);
1007 }
1008
1009 #[test]
1010 fn test_sparse_rows_with_gaps() {
1011 let sst = SharedStringTable::new();
1012 let rows = vec![
1013 make_row(1, vec![make_cell("A1", 1, CellTypeTag::None, Some("1"))]),
1014 make_row(
1015 100,
1016 vec![make_cell("T100", 20, CellTypeTag::None, Some("2"))],
1017 ),
1018 ];
1019 let ws = make_worksheet(rows);
1020 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1021
1022 let row_count = read_u32_le(&buf, 6) as usize;
1023 assert_eq!(row_count, 2);
1024 let col_count = read_u16_le(&buf, 10) as usize;
1025 assert_eq!(col_count, 20);
1026
1027 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1029 assert_ne!(row1_offset, EMPTY_ROW_OFFSET);
1030
1031 assert_eq!(read_u32_le(&buf, HEADER_SIZE + 8), 100);
1033 let row100_offset = read_u32_le(&buf, HEADER_SIZE + 12);
1034 assert_ne!(row100_offset, EMPTY_ROW_OFFSET);
1035 }
1036
1037 #[test]
1038 fn canonical_sparse_size_depends_on_occupied_rows_not_row_distance() {
1039 let sst = SharedStringTable::new();
1040 let near = make_worksheet(vec![
1041 make_row(1, vec![make_cell("A1", 1, CellTypeTag::None, Some("1"))]),
1042 make_row(2, vec![make_cell("A2", 1, CellTypeTag::None, Some("2"))]),
1043 ]);
1044 let far = make_worksheet(vec![
1045 make_row(1, vec![make_cell("A1", 1, CellTypeTag::None, Some("1"))]),
1046 make_row(
1047 1_048_576,
1048 vec![make_cell("A1048576", 1, CellTypeTag::None, Some("2"))],
1049 ),
1050 ]);
1051
1052 let near_buffer = sheet_to_raw_buffer_v2(&near, &sst).unwrap();
1053 let far_buffer = sheet_to_raw_buffer_v2(&far, &sst).unwrap();
1054
1055 assert_eq!(read_u32_le(&near_buffer, 6), 2);
1056 assert_eq!(read_u32_le(&far_buffer, 6), 2);
1057 assert_eq!(near_buffer.len(), far_buffer.len());
1058 assert_eq!(read_u32_le(&far_buffer, HEADER_SIZE + 8), 1_048_576);
1059 let decoded = crate::raw_transfer_write::raw_buffer_to_cells(&far_buffer).unwrap();
1060 assert_eq!(decoded[0].0, 1);
1061 assert_eq!(decoded[1].0, 1_048_576);
1062 }
1063
1064 #[test]
1065 fn canonical_sparse_enforces_exact_output_boundary() {
1066 let sst = SharedStringTable::new();
1067 let ws = make_worksheet(vec![make_row(
1068 1,
1069 vec![make_cell(
1070 "A1",
1071 1,
1072 CellTypeTag::InlineString,
1073 Some("payload"),
1074 )],
1075 )]);
1076 let baseline = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1077 let exact = TraversalLimits::new(1, 1, 1, baseline.len() as u64).unwrap();
1078 sheet_to_raw_buffer_v2_with_options(
1079 &ws,
1080 &sst,
1081 TraversalOptions::default().with_limits(exact),
1082 )
1083 .unwrap();
1084
1085 let error = sheet_to_raw_buffer_v2_with_options(
1086 &ws,
1087 &sst,
1088 TraversalOptions::default()
1089 .with_limits(TraversalLimits::new(1, 1, 1, baseline.len() as u64 - 1).unwrap()),
1090 )
1091 .unwrap_err();
1092 let Error::ResourceLimitExceeded(metadata) = error else {
1093 panic!("expected resource limit error");
1094 };
1095 assert_eq!(metadata.dimension(), ResourceDimension::OutputBytes);
1096 assert_eq!(metadata.observed(), baseline.len() as u64);
1097 }
1098
1099 #[test]
1100 fn test_row_index_entries() {
1101 let sst = SharedStringTable::new();
1102 let ws = make_worksheet(vec![
1103 make_row(1, vec![make_cell("A1", 1, CellTypeTag::None, Some("1"))]),
1104 make_row(3, vec![make_cell("A3", 1, CellTypeTag::None, Some("3"))]),
1105 ]);
1106 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1107
1108 let row_count = read_u32_le(&buf, 6) as usize;
1109 assert_eq!(row_count, 2);
1110
1111 let row1_num = read_u32_le(&buf, HEADER_SIZE);
1112 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1113 assert_eq!(row1_num, 1);
1114 assert_ne!(row1_offset, EMPTY_ROW_OFFSET);
1115
1116 let row3_num = read_u32_le(&buf, HEADER_SIZE + 8);
1117 let row3_offset = read_u32_le(&buf, HEADER_SIZE + 12);
1118 assert_eq!(row3_num, 3);
1119 assert_ne!(row3_offset, EMPTY_ROW_OFFSET);
1120 }
1121
1122 #[test]
1123 fn test_header_format() {
1124 let sst = SharedStringTable::new();
1125 let ws = make_worksheet(vec![
1126 make_row(
1127 2,
1128 vec![
1129 make_cell("B2", 2, CellTypeTag::None, Some("10")),
1130 make_cell("D2", 4, CellTypeTag::None, Some("20")),
1131 ],
1132 ),
1133 make_row(5, vec![make_cell("C5", 3, CellTypeTag::None, Some("30"))]),
1134 ]);
1135 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1136
1137 assert_eq!(read_u32_le(&buf, 0), MAGIC_V2);
1138 assert_eq!(read_u16_le(&buf, 4), VERSION_V2);
1139 let row_count = read_u32_le(&buf, 6);
1140 assert_eq!(row_count, 2, "only occupied rows are indexed");
1141 let col_count = read_u16_le(&buf, 10);
1142 assert_eq!(col_count, 3, "cols B-D = 3 columns");
1143 }
1144
1145 #[test]
1146 fn test_no_string_table_section() {
1147 let sst = make_sst(&["Alpha", "Beta"]);
1148 let ws = make_worksheet(vec![make_row(
1149 1,
1150 vec![
1151 make_cell("A1", 1, CellTypeTag::SharedString, Some("0")),
1152 make_cell("B1", 2, CellTypeTag::SharedString, Some("1")),
1153 ],
1154 )]);
1155 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1156
1157 let cell_data_start = HEADER_SIZE + 8; let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1160 let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
1161
1162 assert_eq!(cells.len(), 2);
1163 assert_eq!(cells[0].1, TYPE_STRING);
1164 assert_eq!(cells[0].2, "Alpha");
1165 assert_eq!(cells[1].1, TYPE_STRING);
1166 assert_eq!(cells[1].2, "Beta");
1167 }
1168
1169 #[test]
1170 fn test_large_string_inline() {
1171 let sst = SharedStringTable::new();
1172 let long_str = "A".repeat(10000);
1173 let ws = make_worksheet(vec![make_row(
1174 1,
1175 vec![make_cell(
1176 "A1",
1177 1,
1178 CellTypeTag::InlineString,
1179 Some(&long_str),
1180 )],
1181 )]);
1182 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1185
1186 let cell_data_start = HEADER_SIZE + 8;
1187 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1188 let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
1189
1190 assert_eq!(cells.len(), 1);
1191 assert_eq!(cells[0].1, TYPE_STRING);
1192 assert_eq!(cells[0].2, long_str);
1193 }
1194
1195 #[test]
1196 fn test_formula_string_type() {
1197 let sst = SharedStringTable::new();
1198 let ws = make_worksheet(vec![make_row(
1199 1,
1200 vec![make_cell(
1201 "A1",
1202 1,
1203 CellTypeTag::FormulaString,
1204 Some("computed"),
1205 )],
1206 )]);
1207 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1208
1209 let cell_data_start = HEADER_SIZE + 8;
1210 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1211 let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
1212
1213 assert_eq!(cells[0].1, TYPE_STRING);
1214 assert_eq!(cells[0].2, "computed");
1215 }
1216
1217 #[test]
1218 fn test_rich_string_from_sst() {
1219 use crate::rich_text::RichTextRun;
1220
1221 let mut sst = SharedStringTable::new();
1222 sst.add("plain");
1223 sst.add_rich_text(&[
1224 RichTextRun {
1225 text: "Bold".to_string(),
1226 font: None,
1227 size: None,
1228 bold: true,
1229 italic: false,
1230 color: None,
1231 },
1232 RichTextRun {
1233 text: " Normal".to_string(),
1234 font: None,
1235 size: None,
1236 bold: false,
1237 italic: false,
1238 color: None,
1239 },
1240 ]);
1241
1242 let ws = make_worksheet(vec![make_row(
1243 1,
1244 vec![make_cell("A1", 1, CellTypeTag::SharedString, Some("1"))],
1245 )]);
1246 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1247
1248 let cell_data_start = HEADER_SIZE + 8;
1249 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1250 let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
1251
1252 assert_eq!(cells[0].1, TYPE_RICH_STRING);
1253 assert_eq!(cells[0].2, "Bold Normal");
1254 }
1255
1256 #[test]
1257 fn test_multiple_rows_multiple_types() {
1258 let sst = make_sst(&["Hello", "World"]);
1259 let ws = make_worksheet(vec![
1260 make_row(
1261 1,
1262 vec![
1263 make_cell("A1", 1, CellTypeTag::None, Some("42")),
1264 make_cell("B1", 2, CellTypeTag::SharedString, Some("0")),
1265 ],
1266 ),
1267 make_row(
1268 2,
1269 vec![
1270 make_cell("A2", 1, CellTypeTag::Boolean, Some("1")),
1271 make_cell("B2", 2, CellTypeTag::Error, Some("#N/A")),
1272 ],
1273 ),
1274 ]);
1275 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1276
1277 let row_count = read_u32_le(&buf, 6) as usize;
1278 assert_eq!(row_count, 2);
1279
1280 let cell_data_start = HEADER_SIZE + row_count * 8;
1281
1282 let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1283 let cells1 = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
1284 assert_eq!(cells1.len(), 2);
1285 assert_eq!(cells1[0].1, TYPE_NUMBER);
1286 assert_eq!(cells1[1].1, TYPE_STRING);
1287 assert_eq!(cells1[1].2, "Hello");
1288
1289 let row2_offset = read_u32_le(&buf, HEADER_SIZE + 8 + 4);
1290 let cells2 = read_v2_row_cells(&buf, cell_data_start + row2_offset as usize);
1291 assert_eq!(cells2.len(), 2);
1292 assert_eq!(cells2[0].1, TYPE_BOOL);
1293 assert_eq!(cells2[1].1, TYPE_ERROR);
1294 assert_eq!(cells2[1].2, "#N/A");
1295 }
1296
1297 #[test]
1298 fn test_cell_without_col_uses_ref_parsing() {
1299 let sst = SharedStringTable::new();
1300 let mut cell = make_cell("C5", 0, CellTypeTag::None, Some("42"));
1301 cell.col = 0;
1302 let ws = make_worksheet(vec![make_row(5, vec![cell])]);
1303 let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1304
1305 let row_count = read_u32_le(&buf, 6);
1306 assert_eq!(row_count, 1);
1307 let col_count = read_u16_le(&buf, 10);
1308 assert_eq!(col_count, 1);
1309 }
1310}