WIP

Makefile

@@ -31,7 +31,12 @@ clean: remove-artifacts
 	rm -r -f base/target
 	rm -r -f xlsx/target
 	rm -r -f bindings/python/target
-	rm -r -f bindings/wasm/targets
+	rm -r -f bindings/wasm/target
+	rm -r -f bindings/wasm/pkg
+	rm -r -f webapp/IronCalc/node_modules
+	rm -r -f webapp/IronCalc/dist
+	rm -r -f webapp/app.ironcalc.com/frontend/node_modules
+	rm -r -f webapp/app.ironcalc.com/frontend/dist
 	rm -f cargo-test-*
 	rm -f base/cargo-test-*
 	rm -f xlsx/cargo-test-*

README.md

@@ -84,7 +84,7 @@ And then use this code in `main.rs`:
 
 ```rust
 use ironcalc::{
-    base::{expressions::utils::number_to_column, Model},
+    base::{expressions::utils::number_to_column, model::Model},
     export::save_to_xlsx,
 };
 

base/CALC.md

@@ -0,0 +1,61 @@
+# Evaluation Strategy
+
+
+We have a list of the spill cells:
+
+```
+// Checks if the array starting at cell will cover cells whose values
+// has been requested
+def CheckSpill(cell, array):
+    for c in cell+array:
+        support CellHasBeenRequested(c):
+        if support is not empty:
+            return support
+    return []
+
+// Fills cells with the result (an array)
+def FillCells(cell, result):
+
+
+def EvaluateNodeInContext(node, context):
+    match node:
+        case OP(left, right, op):
+            l = EvaluateNodeInContext(left, context)?
+            r = EvaluateNodeInContext(left, context)?
+            return op(l, r)
+        case FUNCTION(args, fn):
+            ...
+        case CELL(cell):
+            EvaluateCell(cell)
+        case RANGE(start, end):
+            ...
+
+
+
+def EvaluateCell(cell):
+    if IsCellEvaluating(cell):
+        return CIRC
+    MarkEvaluating(cell)
+    result = EvaluateNodeInContext(cell.formula, cell)
+    if isSpill(result):
+        CheckSpill(cell, array)?
+        FillCells(result)
+
+
+def EvaluateWorkbook():
+    spill_cells = [cell_1, ...., cell_n];
+
+
+    for cell in spill_cells:
+        result = evaluate(cell)
+```   
+
+
+
+
+
+
+
+# When updating a cell value
+
+If it was a spill cell we nee

base/src/actions.rs

@@ -22,7 +22,7 @@ impl Model {
             .cell(row, column)
             .and_then(|c| c.get_formula())
         {
-            let node = &self.parsed_formulas[sheet as usize][f as usize].clone();
+            let node = &self.parsed_formulas[sheet as usize][f as usize].0.clone();
             let cell_reference = CellReferenceRC {
                 sheet: self.workbook.worksheets[sheet as usize].get_name(),
                 row,

base/src/arithmetic.rs

@@ -77,8 +77,6 @@ impl Model {
                         match to_f64(&node) {
                             Ok(f2) => match op(f1, f2) {
                                 Ok(x) => data_row.push(ArrayNode::Number(x)),
-                                Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
-                                Err(Error::VALUE) => data_row.push(ArrayNode::Error(Error::VALUE)),
                                 Err(e) => data_row.push(ArrayNode::Error(e)),
                             },
                             Err(err) => data_row.push(ArrayNode::Error(err)),
@@ -100,8 +98,6 @@ impl Model {
                         match to_f64(&node) {
                             Ok(f1) => match op(f1, f2) {
                                 Ok(x) => data_row.push(ArrayNode::Number(x)),
-                                Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
-                                Err(Error::VALUE) => data_row.push(ArrayNode::Error(Error::VALUE)),
                                 Err(e) => data_row.push(ArrayNode::Error(e)),
                             },
                             Err(err) => data_row.push(ArrayNode::Error(err)),
@@ -137,10 +133,6 @@ impl Model {
                             (Some(v1), Some(v2)) => match (to_f64(v1), to_f64(v2)) {
                                 (Ok(f1), Ok(f2)) => match op(f1, f2) {
                                     Ok(x) => data_row.push(ArrayNode::Number(x)),
-                                    Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
-                                    Err(Error::VALUE) => {
-                                        data_row.push(ArrayNode::Error(Error::VALUE))
-                                    }
                                     Err(e) => data_row.push(ArrayNode::Error(e)),
                                 },
                                 (Err(e), _) | (_, Err(e)) => data_row.push(ArrayNode::Error(e)),

base/src/cell.rs

@@ -64,12 +64,50 @@ impl Cell {
     /// Returns the formula of a cell if any.
     pub fn get_formula(&self) -> Option<i32> {
         match self {
-            Cell::CellFormula { f, .. } => Some(*f),
+            Cell::CellFormula { f, .. }
-            Cell::CellFormulaBoolean { f, .. } => Some(*f),
+            | Cell::CellFormulaBoolean { f, .. }
-            Cell::CellFormulaNumber { f, .. } => Some(*f),
+            | Cell::CellFormulaNumber { f, .. }
-            Cell::CellFormulaString { f, .. } => Some(*f),
+            | Cell::CellFormulaString { f, .. }
-            Cell::CellFormulaError { f, .. } => Some(*f),
+            | Cell::CellFormulaError { f, .. }
-            _ => None,
+            | Cell::DynamicCellFormula { f, .. }
+            | Cell::DynamicCellFormulaBoolean { f, .. }
+            | Cell::DynamicCellFormulaNumber { f, .. }
+            | Cell::DynamicCellFormulaString { f, .. }
+            | Cell::DynamicCellFormulaError { f, .. } => Some(*f),
+            Cell::EmptyCell { .. }
+            | Cell::BooleanCell { .. }
+            | Cell::NumberCell { .. }
+            | Cell::ErrorCell { .. }
+            | Cell::SharedString { .. }
+            | Cell::SpillNumberCell { .. }
+            | Cell::SpillBooleanCell { .. }
+            | Cell::SpillErrorCell { .. }
+            | Cell::SpillStringCell { .. } => None,
+        }
+    }
+
+    /// Returns the dynamic range of a cell if any.
+    pub fn get_dynamic_range(&self) -> Option<(i32, i32)> {
+        match self {
+            Cell::DynamicCellFormula { r, .. } => Some(*r),
+            Cell::DynamicCellFormulaBoolean { r, .. } => Some(*r),
+            Cell::DynamicCellFormulaNumber { r, .. } => Some(*r),
+            Cell::DynamicCellFormulaString { r, .. } => Some(*r),
+            Cell::DynamicCellFormulaError { r, .. } => Some(*r),
+            Cell::EmptyCell { .. }
+            | Cell::BooleanCell { .. }
+            | Cell::NumberCell { .. }
+            | Cell::ErrorCell { .. }
+            | Cell::SharedString { .. }
+            | Cell::CellFormula { .. }
+            | Cell::CellFormulaBoolean { .. }
+            | Cell::CellFormulaNumber { .. }
+            | Cell::CellFormulaString { .. }
+            | Cell::CellFormulaError { .. }
+            | Cell::SpillNumberCell { .. }
+            | Cell::SpillBooleanCell { .. }
+            | Cell::SpillErrorCell { .. }
+            | Cell::SpillStringCell { .. } => None,
         }
     }
 
@@ -89,6 +127,15 @@ impl Cell {
             Cell::CellFormulaNumber { s, .. } => *s = style,
             Cell::CellFormulaString { s, .. } => *s = style,
             Cell::CellFormulaError { s, .. } => *s = style,
+            Cell::SpillBooleanCell { s, .. } => *s = style,
+            Cell::SpillNumberCell { s, .. } => *s = style,
+            Cell::SpillStringCell { s, .. } => *s = style,
+            Cell::SpillErrorCell { s, .. } => *s = style,
+            Cell::DynamicCellFormula { s, .. } => *s = style,
+            Cell::DynamicCellFormulaBoolean { s, .. } => *s = style,
+            Cell::DynamicCellFormulaNumber { s, .. } => *s = style,
+            Cell::DynamicCellFormulaString { s, .. } => *s = style,
+            Cell::DynamicCellFormulaError { s, .. } => *s = style,
         };
     }
 
@@ -104,6 +151,15 @@ impl Cell {
             Cell::CellFormulaNumber { s, .. } => *s,
             Cell::CellFormulaString { s, .. } => *s,
             Cell::CellFormulaError { s, .. } => *s,
+            Cell::SpillBooleanCell { s, .. } => *s,
+            Cell::SpillNumberCell { s, .. } => *s,
+            Cell::SpillStringCell { s, .. } => *s,
+            Cell::SpillErrorCell { s, .. } => *s,
+            Cell::DynamicCellFormula { s, .. } => *s,
+            Cell::DynamicCellFormulaBoolean { s, .. } => *s,
+            Cell::DynamicCellFormulaNumber { s, .. } => *s,
+            Cell::DynamicCellFormulaString { s, .. } => *s,
+            Cell::DynamicCellFormulaError { s, .. } => *s,
         }
     }
 
@@ -119,6 +175,15 @@ impl Cell {
             Cell::CellFormulaNumber { .. } => CellType::Number,
             Cell::CellFormulaString { .. } => CellType::Text,
             Cell::CellFormulaError { .. } => CellType::ErrorValue,
+            Cell::SpillBooleanCell { .. } => CellType::LogicalValue,
+            Cell::SpillNumberCell { .. } => CellType::Number,
+            Cell::SpillStringCell { .. } => CellType::Text,
+            Cell::SpillErrorCell { .. } => CellType::ErrorValue,
+            Cell::DynamicCellFormula { .. } => CellType::Number,
+            Cell::DynamicCellFormulaBoolean { .. } => CellType::LogicalValue,
+            Cell::DynamicCellFormulaNumber { .. } => CellType::Number,
+            Cell::DynamicCellFormulaString { .. } => CellType::Text,
+            Cell::DynamicCellFormulaError { .. } => CellType::ErrorValue,
         }
     }
 
@@ -136,7 +201,7 @@ impl Cell {
             Cell::EmptyCell { .. } => CellValue::None,
             Cell::BooleanCell { v, s: _ } => CellValue::Boolean(*v),
             Cell::NumberCell { v, s: _ } => CellValue::Number(*v),
-            Cell::ErrorCell { ei, .. } => {
+            Cell::ErrorCell { ei, .. } | Cell::SpillErrorCell { ei, .. } => {
                 let v = ei.to_localized_error_string(language);
                 CellValue::String(v)
             }
@@ -148,14 +213,25 @@ impl Cell {
                 };
                 CellValue::String(v)
             }
-            Cell::CellFormula { .. } => CellValue::String("#ERROR!".to_string()),
+            Cell::DynamicCellFormula { .. } | Cell::CellFormula { .. } => {
-            Cell::CellFormulaBoolean { v, .. } => CellValue::Boolean(*v),
+                CellValue::String("#ERROR!".to_string())
-            Cell::CellFormulaNumber { v, .. } => CellValue::Number(*v),
+            }
-            Cell::CellFormulaString { v, .. } => CellValue::String(v.clone()),
+            Cell::DynamicCellFormulaBoolean { v, .. } | Cell::CellFormulaBoolean { v, .. } => {
-            Cell::CellFormulaError { ei, .. } => {
+                CellValue::Boolean(*v)
+            }
+            Cell::DynamicCellFormulaNumber { v, .. } | Cell::CellFormulaNumber { v, .. } => {
+                CellValue::Number(*v)
+            }
+            Cell::DynamicCellFormulaString { v, .. } | Cell::CellFormulaString { v, .. } => {
+                CellValue::String(v.clone())
+            }
+            Cell::DynamicCellFormulaError { ei, .. } | Cell::CellFormulaError { ei, .. } => {
                 let v = ei.to_localized_error_string(language);
                 CellValue::String(v)
             }
+            Cell::SpillBooleanCell { v, .. } => CellValue::Boolean(*v),
+            Cell::SpillNumberCell { v, .. } => CellValue::Number(*v),
+            Cell::SpillStringCell { v, .. } => CellValue::String(v.clone()),
         }
     }
 

base/src/expressions/parser/static_analysis.rs

@@ -186,7 +186,8 @@ pub fn add_implicit_intersection(node: &mut Node, add: bool) {
     };
 }
 
-pub(crate) enum StaticResult {
+#[derive(Clone)]
+pub enum StaticResult {
     Scalar,
     Array(i32, i32),
     Range(i32, i32),
@@ -222,7 +223,7 @@ fn static_analysis_op_nodes(left: &Node, right: &Node) -> StaticResult {
 //  * Array(a, b) if we know it will be an a x b array.
 //  * Range(a, b) if we know it will be a a x b range.
 //  * Unknown if we cannot guaranty either
-fn run_static_analysis_on_node(node: &Node) -> StaticResult {
+pub(crate) fn run_static_analysis_on_node(node: &Node) -> StaticResult {
     match node {
         Node::BooleanKind(_)
         | Node::NumberKind(_)

base/src/functions/subtotal.rs

@@ -96,7 +96,7 @@ impl Model {
 
         match cell.get_formula() {
             Some(f) => {
-                let node = &self.parsed_formulas[sheet_index as usize][f as usize];
+                let node = &self.parsed_formulas[sheet_index as usize][f as usize].0;
                 matches!(
                     node,
                     Node::FunctionKind {

base/src/model.rs

@@ -11,8 +11,9 @@ use crate::{
         lexer::LexerMode,
         parser::{
             move_formula::{move_formula, MoveContext},
+            static_analysis::{run_static_analysis_on_node, StaticResult},
             stringify::{rename_defined_name_in_node, to_rc_format, to_string},
-            Node, Parser,
+            ArrayNode, Node, Parser,
         },
         token::{get_error_by_name, Error, OpCompare, OpProduct, OpSum, OpUnary},
         types::*,
@@ -83,6 +84,24 @@ pub(crate) enum ParsedDefinedName {
     InvalidDefinedNameFormula,
 }
 
+/// A support node is either a cell or a range of cells
+pub(crate) enum SupportNode {
+    /// (sheet, row, column)
+    Cell((u32, i32, i32)),
+    /// (sheet, row, column, height, width)
+    Range((u32, i32, i32, u32, u32))
+}
+
+/// The state of the computation
+pub(crate) enum EvaluationState {
+    /// the model is ready for a new evaluation
+    Ready,
+    /// the model is evaluating cells that might spill
+    EvaluatingSpills,
+    /// the model is evaluating cells normally
+    Evaluating
+}
+
 /// A dynamical IronCalc model.
 ///
 /// Its is composed of a `Workbook`. Everything else are dynamical quantities:
@@ -99,15 +118,13 @@ pub struct Model {
     /// A Rust internal representation of an Excel workbook
     pub workbook: Workbook,
     /// A list of parsed formulas
-    pub parsed_formulas: Vec<Vec<Node>>,
+    pub parsed_formulas: Vec<Vec<(Node, StaticResult)>>,
     /// A list of parsed defined names
     pub(crate) parsed_defined_names: HashMap<(Option<u32>, String), ParsedDefinedName>,
     /// An optimization to lookup strings faster
     pub(crate) shared_strings: HashMap<String, usize>,
     /// An instance of the parser
     pub(crate) parser: Parser,
-    /// The list of cells with formulas that are evaluated or being evaluated
-    pub(crate) cells: HashMap<(u32, i32, i32), CellState>,
     /// The locale of the model
     pub(crate) locale: Locale,
     /// The language used
@@ -116,6 +133,16 @@ pub struct Model {
     pub(crate) tz: Tz,
     /// The view id. A view consists of a selected sheet and ranges.
     pub(crate) view_id: u32,
+    /// ** Runtime ***
+    /// The list of cells with formulas that are evaluated or being evaluated
+    pub(crate) cells: HashMap<(u32, i32, i32), CellState>,
+    /// The support graph. For a given cell (sheet, row, column) the list of cells and ranges that were requested
+    pub(crate) support_graph: HashMap<(u32, i32, i32), Vec<SupportNode>>,
+    /// If the model is in a switch state then spill cells in the indices should be switched and recalculation redone
+    pub(crate) switch_cells: Option<(i32, i32)>,
+    /// Stack of cells being evaluated
+    pub(crate) stack: Vec<(u32, i32, i32)>,
+    pub(crate) state: EvaluationState,
 }
 
 // FIXME: Maybe this should be the same as CellReference
@@ -522,14 +549,203 @@ impl Model {
         }
         Ok(format!("{}!{}{}", sheet.name, column, cell_reference.row))
     }
+
+    /// Sets sheet, target_row, target_column, (width, height), &v
+    #[allow(clippy::too_many_arguments)]
+    fn set_spill_cell_with_formula_value(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        r: (i32, i32),
+        v: &CalcResult,
+        s: i32,
+        f: i32,
+    ) -> Result<(), String> {
+        let new_cell = match v {
+            CalcResult::EmptyCell => Cell::DynamicCellFormulaNumber {
+                f,
+                v: 0.0,
+                s,
+                r,
+                a: false,
+            },
+            CalcResult::String(v) => Cell::DynamicCellFormulaString {
+                f,
+                v: v.clone(),
+                s,
+                r,
+                a: false,
+            },
+            CalcResult::Number(v) => Cell::DynamicCellFormulaNumber {
+                v: *v,
+                s,
+                r,
+                f,
+                a: false,
+            },
+            CalcResult::Boolean(b) => Cell::DynamicCellFormulaBoolean {
+                v: *b,
+                s,
+                r,
+                f,
+                a: false,
+            },
+            CalcResult::Error { error, .. } => Cell::DynamicCellFormulaError {
+                ei: error.clone(),
+                s,
+                r,
+                f,
+                a: false,
+                o: "".to_string(),
+                m: "".to_string(),
+            },
+
+            // These cannot happen
+            // FIXME: Maybe the type of get_cell_value should be different
+            CalcResult::Range { .. } | CalcResult::EmptyArg | CalcResult::Array(_) => {
+                Cell::DynamicCellFormulaError {
+                    ei: Error::ERROR,
+                    s,
+                    r,
+                    f,
+                    a: false,
+                    o: "".to_string(),
+                    m: "".to_string(),
+                }
+            }
+        };
+        let sheet_data = &mut self.workbook.worksheet_mut(sheet)?.sheet_data;
+
+        match sheet_data.get_mut(&row) {
+            Some(column_data) => match column_data.get(&column) {
+                Some(_cell) => {
+                    column_data.insert(column, new_cell);
+                }
+                None => {
+                    column_data.insert(column, new_cell);
+                }
+            },
+            None => {
+                let mut column_data = HashMap::new();
+                column_data.insert(column, new_cell);
+                sheet_data.insert(row, column_data);
+            }
+        }
+        Ok(())
+    }
+
+    /// Sets a cell with a "spill" value
+    fn set_spill_cell_with_value(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        m: (i32, i32),
+        v: &CalcResult,
+    ) -> Result<(), String> {
+        let style_index = self.get_cell_style_index(sheet, row, column)?;
+        let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
+            self.workbook
+                .styles
+                .get_style_without_quote_prefix(style_index)?
+        } else {
+            style_index
+        };
+        let new_cell = match v {
+            CalcResult::EmptyCell => Cell::SpillNumberCell {
+                v: 0.0,
+                s: style_index,
+                m,
+            },
+            CalcResult::String(s) => Cell::SpillStringCell {
+                v: s.clone(),
+                s: new_style_index,
+                m,
+            },
+            CalcResult::Number(f) => Cell::SpillNumberCell {
+                v: *f,
+                s: new_style_index,
+                m,
+            },
+            CalcResult::Boolean(b) => Cell::SpillBooleanCell {
+                v: *b,
+                s: new_style_index,
+                m,
+            },
+            CalcResult::Error { error, .. } => Cell::SpillErrorCell {
+                ei: error.clone(),
+                s: style_index,
+                m,
+            },
+
+            // These cannot happen
+            // FIXME: Maybe the type of get_cell_value should be different
+            CalcResult::Range { .. } | CalcResult::EmptyArg | CalcResult::Array(_) => {
+                Cell::SpillErrorCell {
+                    ei: Error::ERROR,
+                    s: style_index,
+                    m,
+                }
+            }
+        };
+        let sheet_data = &mut self.workbook.worksheet_mut(sheet)?.sheet_data;
+
+        match sheet_data.get_mut(&row) {
+            Some(column_data) => match column_data.get(&column) {
+                Some(_cell) => {
+                    column_data.insert(column, new_cell);
+                }
+                None => {
+                    column_data.insert(column, new_cell);
+                }
+            },
+            None => {
+                let mut column_data = HashMap::new();
+                column_data.insert(column, new_cell);
+                sheet_data.insert(row, column_data);
+            }
+        }
+        Ok(())
+    }
+
+    /// Returns `None` if no cell has called this cell, otherwise returns the dependent cell
+    fn get_support_cell(&self, sheet: u32, row: i32, column: i32) -> Result<Option<&Cell>, String> {
+        self.workbook.supporting_cells.get(&(sheet, row, column)).map(|c| Some(c)).ok_or_else(|| "Cell not found".into())
+    }
+
     /// Sets `result` in the cell given by `sheet` sheet index, row and column
     /// Note that will panic if the cell does not exist
     /// It will do nothing if the cell does not have a formula
+    /// If the cell is an array or a range it will check if it is possible to spill to other cells
+    /// if it is not it will return an error.
+    /// Then it will check if any of the cells has been requested before.
     #[allow(clippy::expect_used)]
-    fn set_cell_value(&mut self, cell_reference: CellReferenceIndex, result: &CalcResult) {
+    fn set_cell_value(
+        &mut self,
+        cell_reference: CellReferenceIndex,
+        result: &CalcResult,
+    ) -> Result<(), String> {
         let CellReferenceIndex { sheet, column, row } = cell_reference;
-        let cell = &self.workbook.worksheets[sheet as usize].sheet_data[&row][&column];
+        let cell = self
+            .workbook
+            .worksheet(sheet)?
+            .cell(row, column)
+            .cloned()
+            .unwrap_or_default();
         let s = cell.get_style();
+        // If the cell is a dynamic cell we need to delete all the cells in the range
+        if let Some((width, height)) = cell.get_dynamic_range() {
+            for r in row..row + height {
+                for c in column..column + width {
+                    // skip the "mother" cell
+                    if r == row && c == column {
+                        continue;
+                    }
+                    self.cell_clear_contents(sheet, r, c)?;
+                }
+            }
+        }
         if let Some(f) = cell.get_formula() {
             match result {
                 CalcResult::Number(value) => {
@@ -594,19 +810,145 @@ impl Model {
                         ei: error.clone(),
                     };
                 }
+                CalcResult::EmptyCell | CalcResult::EmptyArg => {
+                    *self.workbook.worksheets[sheet as usize]
+                        .sheet_data
+                        .get_mut(&row)
+                        .expect("expected a row")
+                        .get_mut(&column)
+                        .expect("expected a column") = Cell::CellFormulaNumber { f, s, v: 0.0 };
+                }
                 CalcResult::Range { left, right } => {
                     if left.sheet == right.sheet
                         && left.row == right.row
                         && left.column == right.column
                     {
-                        let intersection_cell = CellReferenceIndex {
+                        // There is only one cell
+                        let single_cell = CellReferenceIndex {
                             sheet: left.sheet,
                             column: left.column,
                             row: left.row,
                         };
-                        let v = self.evaluate_cell(intersection_cell);
+                        let v = self.evaluate_cell(single_cell);
-                        self.set_cell_value(cell_reference, &v);
+                        self.set_cell_value(cell_reference, &v)?;
                     } else {
+                        // We need to check if all the cells are empty, otherwise we mark the cell as #SPILL!
+                        let mut all_empty = true;
+                        for r in row..=row + right.row - left.row {
+                            for c in column..=column + right.column - left.column {
+                                if r == row && c == column {
+                                    // skip the "mother" cell
+                                    continue;
+                                }
+                                if !self.is_empty_cell(sheet, r, c).unwrap_or(false) {
+                                    all_empty = false;
+                                    break;
+                                }
+                                if let Some(support) = self.get_support_cell(sheet, r, c) {
+                                    all_empty = false;
+                                }
+                            }
+                            if !all_empty {
+                                break;
+                            }
+                        }
+                        if !all_empty {
+                            let o = match self.cell_reference_to_string(&cell_reference) {
+                                Ok(s) => s,
+                                Err(_) => "".to_string(),
+                            };
+                            *self.workbook.worksheets[sheet as usize]
+                                .sheet_data
+                                .get_mut(&row)
+                                .expect("expected a row")
+                                .get_mut(&column)
+                                .expect("expected a column") = Cell::DynamicCellFormulaError {
+                                f,
+                                s,
+                                o,
+                                m: "Result would spill to non empty cells".to_string(),
+                                ei: Error::SPILL,
+                                r: (1, 1),
+                                a: false,
+                            };
+                            return Ok(());
+                        }
+                        // evaluate all the cells in that range
+                        for r in left.row..=right.row {
+                            for c in left.column..=right.column {
+                                let cell_reference = CellReferenceIndex {
+                                    sheet: left.sheet,
+                                    row: r,
+                                    column: c,
+                                };
+                                // FIXME: We ned to return an error
+                                self.evaluate_cell(cell_reference);
+                            }
+                        }
+                        // now write the result in the target
+                        for r in left.row..=right.row {
+                            let row_delta = r - left.row;
+                            for c in left.column..=right.column {
+                                let column_delta = c - left.column;
+                                // We need to put whatever is in (left.sheet, r, c) in
+                                // (sheet, row + row_delta, column + column_delta)
+                                // But we need to preserve the style
+                                let target_row = row + row_delta;
+                                let target_column = column + column_delta;
+                                let cell = self
+                                    .workbook
+                                    .worksheet(left.sheet)?
+                                    .cell(r, c)
+                                    .cloned()
+                                    .unwrap_or_default();
+                                let cell_reference = CellReferenceIndex {
+                                    sheet: left.sheet,
+                                    row: r,
+                                    column: c,
+                                };
+                                let v = self.get_cell_value(&cell, cell_reference);
+                                if row == target_row && column == target_column {
+                                    // let cell_reference = CellReferenceIndex { sheet, row, column };
+                                    // self.set_cell_value(cell_reference, &v);
+                                    self.set_spill_cell_with_formula_value(
+                                        sheet,
+                                        target_row,
+                                        target_column,
+                                        (right.column - left.column + 1, right.row - left.row + 1),
+                                        &v,
+                                        s,
+                                        f,
+                                    )?;
+                                    continue;
+                                }
+                                self.set_spill_cell_with_value(
+                                    sheet,
+                                    target_row,
+                                    target_column,
+                                    (row, column),
+                                    &v,
+                                )?;
+                            }
+                        }
+                    }
+                }
+                CalcResult::Array(array) => {
+                    let width = array[0].len() as i32;
+                    let height = array.len() as i32;
+                    // First we check that we don't spill:
+                    let mut all_empty = true;
+                    for r in row..row + height {
+                        for c in column..column + width {
+                            if r == row && c == column {
+                                continue;
+                            }
+                            if !self.is_empty_cell(sheet, r, c).unwrap_or(false) {
+                                all_empty = false;
+                                break;
+                            }
+                        }
+                    }
+                    if !all_empty {
                         let o = match self.cell_reference_to_string(&cell_reference) {
                             Ok(s) => s,
                             Err(_) => "".to_string(),
@@ -620,57 +962,65 @@ impl Model {
                             f,
                             s,
                             o,
-                            m: "Implicit Intersection not implemented".to_string(),
+                            m: "Result would spill to non empty cells".to_string(),
-                            ei: Error::NIMPL,
+                            ei: Error::SPILL,
                         };
+                        return Ok(());
+                    }
+                    let mut target_row = row;
+                    for data_row in array {
+                        let mut target_column = column;
+                        for value in data_row {
+                            if row == target_row && column == target_column {
+                                // This is the root cell of the dynamic array
+                                let cell_reference = CellReferenceIndex { sheet, row, column };
+                                let v = match value {
+                                    ArrayNode::Boolean(b) => CalcResult::Boolean(*b),
+                                    ArrayNode::Number(f) => CalcResult::Number(*f),
+                                    ArrayNode::String(s) => CalcResult::String(s.clone()),
+                                    ArrayNode::Error(error) => CalcResult::new_error(
+                                        error.clone(),
+                                        cell_reference,
+                                        error.to_localized_error_string(&self.language),
+                                    ),
+                                };
+                                self.set_spill_cell_with_formula_value(
+                                    sheet,
+                                    target_row,
+                                    target_column,
+                                    (width, height),
+                                    &v,
+                                    s,
+                                    f,
+                                )?;
+                                target_column += 1;
+                                continue;
+                            }
+                            let v = match value {
+                                ArrayNode::Boolean(b) => CalcResult::Boolean(*b),
+                                ArrayNode::Number(f) => CalcResult::Number(*f),
+                                ArrayNode::String(s) => CalcResult::String(s.clone()),
+                                ArrayNode::Error(error) => CalcResult::new_error(
+                                    error.clone(),
+                                    cell_reference,
+                                    error.to_localized_error_string(&self.language),
+                                ),
+                            };
+                            self.set_spill_cell_with_value(
+                                sheet,
+                                target_row,
+                                target_column,
+                                (row, column),
+                                &v,
+                            )?;
+                            target_column += 1;
+                        }
+                        target_row += 1;
                     }
-                    // if let Some(intersection_cell) = implicit_intersection(&cell_reference, &range)
-                    // {
-                    //     let v = self.evaluate_cell(intersection_cell);
-                    //     self.set_cell_value(cell_reference, &v);
-                    // } else {
-                    //     let o = match self.cell_reference_to_string(&cell_reference) {
-                    //         Ok(s) => s,
-                    //         Err(_) => "".to_string(),
-                    //     };
-                    //     *self.workbook.worksheets[sheet as usize]
-                    //         .sheet_data
-                    //         .get_mut(&row)
-                    //         .expect("expected a row")
-                    //         .get_mut(&column)
-                    //         .expect("expected a column") = Cell::CellFormulaError {
-                    //         f,
-                    //         s,
-                    //         o,
-                    //         m: "Invalid reference".to_string(),
-                    //         ei: Error::VALUE,
-                    //     };
-                    // }
-                }
-                CalcResult::EmptyCell | CalcResult::EmptyArg => {
-                    *self.workbook.worksheets[sheet as usize]
-                        .sheet_data
-                        .get_mut(&row)
-                        .expect("expected a row")
-                        .get_mut(&column)
-                        .expect("expected a column") = Cell::CellFormulaNumber { f, s, v: 0.0 };
-                }
-                CalcResult::Array(_) => {
-                    *self.workbook.worksheets[sheet as usize]
-                        .sheet_data
-                        .get_mut(&row)
-                        .expect("expected a row")
-                        .get_mut(&column)
-                        .expect("expected a column") = Cell::CellFormulaError {
-                        f,
-                        s,
-                        o: "".to_string(),
-                        m: "Arrays not supported yet".to_string(),
-                        ei: Error::NIMPL,
-                    };
                 }
             }
         }
+        Ok(())
     }
 
     /// Sets the color of the sheet tab.
@@ -714,16 +1064,18 @@ impl Model {
         Ok(())
     }
 
+    // EmptyCell, Boolean, Number, String, Error
     fn get_cell_value(&self, cell: &Cell, cell_reference: CellReferenceIndex) -> CalcResult {
         use Cell::*;
         match cell {
             EmptyCell { .. } => CalcResult::EmptyCell,
-            BooleanCell { v, .. } => CalcResult::Boolean(*v),
+            BooleanCell { v, .. } | SpillBooleanCell { v, .. } => CalcResult::Boolean(*v),
-            NumberCell { v, .. } => CalcResult::Number(*v),
+            NumberCell { v, .. } | SpillNumberCell { v, .. } => CalcResult::Number(*v),
-            ErrorCell { ei, .. } => {
+            ErrorCell { ei, .. } | SpillErrorCell { ei, .. } => {
                 let message = ei.to_localized_error_string(&self.language);
                 CalcResult::new_error(ei.clone(), cell_reference, message)
             }
+            SpillStringCell { v, .. } => CalcResult::String(v.clone()),
             SharedString { si, .. } => {
                 if let Some(s) = self.workbook.shared_strings.get(*si as usize) {
                     CalcResult::String(s.clone())
@@ -732,15 +1084,21 @@ impl Model {
                     CalcResult::new_error(Error::ERROR, cell_reference, message)
                 }
             }
-            CellFormula { .. } => CalcResult::Error {
+            DynamicCellFormula { .. } | CellFormula { .. } => CalcResult::Error {
                 error: Error::ERROR,
                 origin: cell_reference,
                 message: "Unevaluated formula".to_string(),
             },
-            CellFormulaBoolean { v, .. } => CalcResult::Boolean(*v),
+            DynamicCellFormulaBoolean { v, .. } | CellFormulaBoolean { v, .. } => {
-            CellFormulaNumber { v, .. } => CalcResult::Number(*v),
+                CalcResult::Boolean(*v)
-            CellFormulaString { v, .. } => CalcResult::String(v.clone()),
+            }
-            CellFormulaError { ei, o, m, .. } => {
+            DynamicCellFormulaNumber { v, .. } | CellFormulaNumber { v, .. } => {
+                CalcResult::Number(*v)
+            }
+            DynamicCellFormulaString { v, .. } | CellFormulaString { v, .. } => {
+                CalcResult::String(v.clone())
+            }
+            DynamicCellFormulaError { ei, o, m, .. } | CellFormulaError { ei, o, m, .. } => {
                 if let Some(cell_reference) = self.parse_reference(o) {
                     CalcResult::new_error(ei.clone(), cell_reference, m.clone())
                 } else {
@@ -772,6 +1130,8 @@ impl Model {
         self.workbook.worksheet(sheet)?.is_empty_cell(row, column)
     }
 
+    /// Evaluates the cell. After the evaluation is done puts the value in the cell and other cells if it spills.
+    /// If when writing a spill cell encounter a cell whose value has been requested marks the model as "dirty"
     pub(crate) fn evaluate_cell(&mut self, cell_reference: CellReferenceIndex) -> CalcResult {
         let row_data = match self.workbook.worksheets[cell_reference.sheet as usize]
             .sheet_data
@@ -810,9 +1170,10 @@ impl Model {
                         self.cells.insert(key, CellState::Evaluating);
                     }
                 }
-                let node = &self.parsed_formulas[cell_reference.sheet as usize][f as usize].clone();
+                let (node, _static_result) =
-                let result = self.evaluate_node_in_context(node, cell_reference);
+                    &self.parsed_formulas[cell_reference.sheet as usize][f as usize];
-                self.set_cell_value(cell_reference, &result);
+                let result = self.evaluate_node_in_context(&node.clone(), cell_reference);
+                let _ = self.set_cell_value(cell_reference, &result);
                 // mark cell as evaluated
                 self.cells.insert(key, CellState::Evaluated);
                 result
@@ -922,6 +1283,10 @@ impl Model {
             locale,
             tz,
             view_id: 0,
+            support_graph: HashMap::new(),
+            switch_cells: None,
+            stack: Vec::new(),
+            state: EvaluationState::Ready,
         };
 
         model.parse_formulas();
@@ -1100,7 +1465,8 @@ impl Model {
             Some(cell) => match cell.get_formula() {
                 None => cell.get_text(&self.workbook.shared_strings, &self.language),
                 Some(i) => {
-                    let formula = &self.parsed_formulas[sheet as usize][i as usize];
+                    let (formula, static_result) =
+                        &self.parsed_formulas[sheet as usize][i as usize];
                     let cell_ref = CellReferenceRC {
                         sheet: self.workbook.worksheets[sheet as usize].get_name(),
                         row: target_row,
@@ -1203,7 +1569,8 @@ impl Model {
                         .get(sheet as usize)
                         .ok_or("missing sheet")?
                         .get(formula_index as usize)
-                        .ok_or("missing formula")?;
+                        .ok_or("missing formula")?
+                        .0;
                     let cell_ref = CellReferenceRC {
                         sheet: worksheet.get_name(),
                         row,
@@ -1437,6 +1804,25 @@ impl Model {
         column: i32,
         value: String,
     ) -> Result<(), String> {
+        // We need to check if the cell is part of a dynamic array
+        let cell = self
+            .workbook
+            .worksheet(sheet)?
+            .cell(row, column)
+            .cloned()
+            .unwrap_or_default();
+        // If the cell is a dynamic cell we need to delete all the cells in the range
+        if let Some((width, height)) = cell.get_dynamic_range() {
+            for r in row..row + height {
+                for c in column..column + width {
+                    // skip the "mother" cell
+                    if r == row && c == column {
+                        continue;
+                    }
+                    self.cell_clear_contents(sheet, r, c)?;
+                }
+            }
+        }
         // If value starts with "'" then we force the style to be quote_prefix
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         if let Some(new_value) = value.strip_prefix('\'') {
@@ -1462,8 +1848,9 @@ impl Model {
                     self.set_cell_with_formula(sheet, row, column, formula, new_style_index)?;
                 // Update the style if needed
                 let cell = CellReferenceIndex { sheet, row, column };
-                let parsed_formula = &self.parsed_formulas[sheet as usize][formula_index as usize];
+                let (parsed_formula, static_result) =
-                if let Some(units) = self.compute_node_units(parsed_formula, &cell) {
+                    self.parsed_formulas[sheet as usize][formula_index as usize].clone();
+                if let Some(units) = self.compute_node_units(&parsed_formula, &cell) {
                     let new_style_index = self
                         .workbook
                         .styles
@@ -1471,6 +1858,14 @@ impl Model {
                     let style = self.workbook.styles.get_style(new_style_index)?;
                     self.set_cell_style(sheet, row, column, &style)?
                 }
+                match static_result {
+                    StaticResult::Scalar => {}
+                    StaticResult::Array(_, _)
+                    | StaticResult::Range(_, _)
+                    | StaticResult::Unknown => {
+                        self.workbook.spill_cells.push((sheet, row, column));
+                    }
+                }
             } else {
                 // The list of currencies is '$', '€' and the local currency
                 let mut currencies = vec!["$", "€"];
@@ -1544,6 +1939,7 @@ impl Model {
                 _ => parsed_formula = new_parsed_formula,
             }
         }
+        let static_result = run_static_analysis_on_node(&parsed_formula);
 
         let s = to_rc_format(&parsed_formula);
         let mut formula_index: i32 = -1;
@@ -1552,7 +1948,7 @@ impl Model {
         }
         if formula_index == -1 {
             shared_formulas.push(s);
-            self.parsed_formulas[sheet as usize].push(parsed_formula);
+            self.parsed_formulas[sheet as usize].push((parsed_formula, static_result));
             formula_index = (shared_formulas.len() as i32) - 1;
         }
         worksheet.set_cell_with_formula(row, column, formula_index, style)?;
@@ -1747,7 +2143,7 @@ impl Model {
         };
         match cell.get_formula() {
             Some(formula_index) => {
-                let formula = &self.parsed_formulas[sheet as usize][formula_index as usize];
+                let formula = &self.parsed_formulas[sheet as usize][formula_index as usize].0;
                 let cell_ref = CellReferenceRC {
                     sheet: worksheet.get_name(),
                     row,
@@ -1783,9 +2179,34 @@ impl Model {
 
     /// Evaluates the model with a top-down recursive algorithm
     pub fn evaluate(&mut self) {
-        // clear all computation artifacts
+        // We first evaluate all the cells that might spill to other cells
-        self.cells.clear();
+        let mut spills_computed = false;
+        self.state = EvaluationState::EvaluatingSpills;
+        while !spills_computed {
+            spills_computed = true;
+            // clear all computation artifacts
+            self.cells.clear();
+            // Evaluate all the cells that might spill
+            let spill_cells = self.workbook.spill_cells.clone();
+            for (sheet, row, column) in spill_cells {
+                self.evaluate_cell(CellReferenceIndex { sheet, row, column });
+                if self.switch_cells.is_some() {
+                    spills_computed = false;
+                    break;
+                }
+            }
+            if let Some((index1, index2)) = self.switch_cells {
+                spills_computed = false;
+                // switch the cells indices in the spill_cells
+                let cell1 = self.workbook.spill_cells[index1 as usize];
+                let cell2 = self.workbook.spill_cells[index2 as usize];
+                self.workbook.spill_cells[index1 as usize] = cell2;
+                self.workbook.spill_cells[index2 as usize] = cell1;
+            }
+        }
+        self.state = EvaluationState::Evaluating;
 
+        // Now we compute all the rest
         let cells = self.get_all_cells();
 
         for cell in cells {
@@ -1795,6 +2216,7 @@ impl Model {
                 column: cell.column,
             });
         }
+        self.state = EvaluationState::Ready;
     }
 
     /// Removes the content of the cell but leaves the style.
@@ -1818,9 +2240,22 @@ impl Model {
     /// # }
     /// ```
     pub fn cell_clear_contents(&mut self, sheet: u32, row: i32, column: i32) -> Result<(), String> {
-        self.workbook
+        // If it has a spill formula we need to delete the contents of all the spilled cells
-            .worksheet_mut(sheet)?
+        let worksheet = self.workbook.worksheet_mut(sheet)?;
-            .cell_clear_contents(row, column)?;
+        if let Some(cell) = worksheet.cell(row, column) {
+            if let Some((width, height)) = cell.get_dynamic_range() {
+                for r in row..row + height {
+                    for c in column..column + width {
+                        if row == r && column == c {
+                            // we skip the root cell
+                            continue;
+                        }
+                        worksheet.cell_clear_contents(r, c)?;
+                    }
+                }
+            }
+        }
+        worksheet.cell_clear_contents(row, column)?;
         Ok(())
     }
 
@@ -1845,6 +2280,18 @@ impl Model {
     /// # }
     pub fn cell_clear_all(&mut self, sheet: u32, row: i32, column: i32) -> Result<(), String> {
         let worksheet = self.workbook.worksheet_mut(sheet)?;
+        // Delete the contents of spilled cells if any
+        if let Some(cell) = worksheet.cell(row, column) {
+            if let Some((width, height)) = cell.get_dynamic_range() {
+                for r in row..row + height {
+                    for c in column..column + width {
+                        if row == r && c == column {
+                            worksheet.cell_clear_contents(r, c)?;
+                        }
+                    }
+                }
+            }
+        }
 
         let sheet_data = &mut worksheet.sheet_data;
         if let Some(row_data) = sheet_data.get_mut(&row) {

base/src/new_empty.rs

@@ -8,6 +8,7 @@ use crate::{
     expressions::{
         lexer::LexerMode,
         parser::{
+            static_analysis::run_static_analysis_on_node,
             stringify::{rename_sheet_in_node, to_rc_format, to_string},
             Parser,
         },
@@ -15,7 +16,7 @@ use crate::{
     },
     language::get_language,
     locale::get_locale,
-    model::{get_milliseconds_since_epoch, Model, ParsedDefinedName},
+    model::{get_milliseconds_since_epoch, EvaluationState, Model, ParsedDefinedName},
     types::{
         DefinedName, Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet,
         WorksheetView,
@@ -94,7 +95,8 @@ impl Model {
             let mut parse_formula = Vec::new();
             for formula in shared_formulas {
                 let t = self.parser.parse(formula, &cell_reference);
-                parse_formula.push(t);
+                let static_result = run_static_analysis_on_node(&t);
+                parse_formula.push((t, static_result));
             }
             self.parsed_formulas.push(parse_formula);
         }
@@ -405,6 +407,7 @@ impl Model {
             },
             tables: HashMap::new(),
             views,
+            spill_cells: Vec::new(),
         };
         let parsed_formulas = Vec::new();
         let worksheets = &workbook.worksheets;
@@ -427,6 +430,10 @@ impl Model {
             language,
             tz,
             view_id: 0,
+            support_graph: HashMap::new(),
+            switch_cells: None,
+            stack: Vec::new(),
+            state: EvaluationState::Ready,
         };
         model.parse_formulas();
         Ok(model)

base/src/test/mod.rs

@@ -52,6 +52,7 @@ mod test_fn_offset;
 mod test_number_format;
 
 mod test_arrays;
+mod test_dynamic_arrays;
 mod test_escape_quotes;
 mod test_extend;
 mod test_fn_fv;

base/src/test/test_dynamic_arrays.rs

@@ -0,0 +1,50 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn they_spill() {
+    let mut model = new_empty_model();
+    model._set("A1", "42");
+    model._set("A2", "5");
+    model._set("A3", "7");
+
+    model._set("B1", "=A1:A3");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"42");
+    assert_eq!(model._get_text("B2"), *"5");
+    assert_eq!(model._get_text("B3"), *"7");
+}
+
+#[test]
+fn spill_error() {
+    let mut model = new_empty_model();
+    model._set("A1", "42");
+    model._set("A2", "5");
+    model._set("A3", "7");
+
+    model._set("B1", "=A1:A3");
+    model._set("B2", "4");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#SPILL!");
+    assert_eq!(model._get_text("B2"), *"4");
+    assert_eq!(model._get_text("B3"), *"");
+}
+
+#[test]
+fn second_evaluation() {
+    let mut model = new_empty_model();
+    model._set("C3", "={1,2,3}");
+    model.evaluate();
+
+    assert_eq!(model._get_text("D3"), "2");
+
+    model._set("D8", "23");
+    model.evaluate();
+
+    assert_eq!(model._get_text("D3"), "2");
+}

base/src/test/test_fn_or_xor.rs

@@ -91,12 +91,12 @@ fn fn_or_xor() {
         model._set("A10", &format!("={func}(X99:Z99"));
 
         // Reference to cell with reference to empty range
-        model._set("B11", "=X99:Z99");
+        model._set("B11", "=@X99:Z99");
         model._set("A11", &format!("={func}(B11)"));
 
         // Reference to cell with non-empty range
         model._set("X12", "1");
-        model._set("B12", "=X12:Z12");
+        model._set("B12", "=@X12:Z12");
         model._set("A12", &format!("={func}(B12)"));
 
         // Reference to text cell

base/src/test/test_implicit_intersection.rs

@@ -3,7 +3,7 @@
 use crate::test::util::new_empty_model;
 
 #[test]
-fn simple_colum() {
+fn simple_column() {
     let mut model = new_empty_model();
     // We populate cells A1 to A3
     model._set("A1", "1");
@@ -30,7 +30,7 @@ fn return_of_array_is_n_impl() {
 
     model.evaluate();
 
-    assert_eq!(model._get_text("C2"), "#N/IMPL!".to_string());
+    assert_eq!(model._get_text("C2"), "1".to_string());
     assert_eq!(model._get_text("D2"), "1.89188842".to_string());
 }
 

base/src/test/user_model/mod.rs

@@ -6,8 +6,10 @@ mod test_border;
 mod test_clear_cells;
 mod test_column_style;
 mod test_defined_names;
+mod test_delete_evaluates;
 mod test_delete_row_column_formatting;
 mod test_diff_queue;
+mod test_dynamic_array;
 mod test_evaluation;
 mod test_general;
 mod test_grid_lines;

base/src/test/user_model/test_delete_evaluates.rs

@@ -0,0 +1,47 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{expressions::types::Area, UserModel};
+
+#[test]
+fn clear_cell_contents_evaluates() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+    model.set_user_input(0, 1, 2, "=A1").unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("42".to_string())
+    );
+    model
+        .range_clear_contents(&Area {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            width: 1,
+            height: 1,
+        })
+        .unwrap();
+
+    assert_eq!(model.get_formatted_cell_value(0, 1, 2), Ok("0".to_string()));
+}
+
+#[test]
+fn clear_cell_all_evaluates() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+    model.set_user_input(0, 1, 2, "=A1").unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("42".to_string())
+    );
+    model
+        .range_clear_all(&Area {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            width: 1,
+            height: 1,
+        })
+        .unwrap();
+
+    assert_eq!(model.get_formatted_cell_value(0, 1, 2), Ok("0".to_string()));
+}

base/src/test/user_model/test_dynamic_array.rs

@@ -0,0 +1,130 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{expressions::types::Area, UserModel};
+
+// Tests basic behavour.
+#[test]
+fn basic() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    // We put a value by the dynamic array to check the border conditions
+    model.set_user_input(0, 2, 1, "22").unwrap();
+    model.set_user_input(0, 1, 1, "={34,35,3}").unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 1),
+        Ok("34".to_string())
+    );
+}
+
+// Test that overwriting a dynamic array with a single value dissolves the array
+#[test]
+fn sett_user_input_mother() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "={34,35,3}").unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("35".to_string())
+    );
+    model.set_user_input(0, 1, 1, "123").unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 1, 2), Ok("".to_string()));
+}
+
+#[test]
+fn set_user_input_sibling() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "={43,55,34}").unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("55".to_string())
+    );
+    // This does nothing
+    model.set_user_input(0, 1, 2, "123").unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("55".to_string())
+    );
+}
+
+#[test]
+fn basic_undo_redo() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "={34,35,3}").unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("35".to_string())
+    );
+    model.undo().unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 1, 2), Ok("".to_string()));
+    model.redo().unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("35".to_string())
+    );
+}
+
+#[test]
+fn mixed_spills() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    // D9 => ={1,2,3}
+    model.set_user_input(0, 9, 4, "={34,35,3}").unwrap();
+    // F6 => ={1;2;3;4}
+    model.set_user_input(0, 6, 6, "={1;2;3;4}").unwrap();
+
+    // F6 should be #SPILL!
+    assert_eq!(
+        model.get_formatted_cell_value(0, 6, 6),
+        Ok("#SPILL!".to_string())
+    );
+
+    // We delete D9
+    model
+        .range_clear_contents(&Area {
+            sheet: 0,
+            row: 9,
+            column: 4,
+            width: 1,
+            height: 1,
+        })
+        .unwrap();
+
+    // F6 should be 1
+    assert_eq!(model.get_formatted_cell_value(0, 6, 6), Ok("1".to_string()));
+
+    // Now we undo that
+    model.undo().unwrap();
+    // F6 should be #SPILL!
+    assert_eq!(
+        model.get_formatted_cell_value(0, 6, 6),
+        Ok("#SPILL!".to_string())
+    );
+}
+
+#[test]
+fn spill_order_d9_f6() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    // D9 => ={1,2,3}
+    model.set_user_input(0, 9, 4, "={34,35,3}").unwrap();
+    // F6 => ={1;2;3;4}
+    model.set_user_input(0, 6, 6, "={1;2;3;4}").unwrap();
+
+    // F6 should be #SPILL!
+    assert_eq!(
+        model.get_formatted_cell_value(0, 6, 6),
+        Ok("#SPILL!".to_string())
+    );
+}
+
+#[test]
+fn spill_order_f6_d9() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    // F6 => ={1;2;3;4}
+    model.set_user_input(0, 6, 6, "={1;2;3;4}").unwrap();
+    // D9 => ={1,2,3}
+    model.set_user_input(0, 9, 4, "={34,35,3}").unwrap();
+
+    // D9 should be #SPILL!
+    assert_eq!(
+        model.get_formatted_cell_value(0, 9, 4),
+        Ok("#SPILL!".to_string())
+    );
+}

base/src/types.rs

@@ -51,6 +51,8 @@ pub struct Workbook {
     pub metadata: Metadata,
     pub tables: HashMap<String, Table>,
     pub views: HashMap<u32, WorkbookView>,
+    /// The list of cells that spill in the order of evaluation
+    pub spill_cells: Vec<(u32, i32, i32)>,
 }
 
 /// A defined name. The `sheet_id` is the sheet index in case the name is local
@@ -159,17 +161,17 @@ pub enum CellType {
     CompoundData = 128,
 }
 
+/// Cell types
+/// s is always the style index of the cell
 #[derive(Encode, Decode, Debug, Clone, PartialEq)]
 pub enum Cell {
     EmptyCell {
         s: i32,
     },
-
     BooleanCell {
         v: bool,
         s: i32,
     },
-
     NumberCell {
         v: f64,
         s: i32,
@@ -181,6 +183,7 @@ pub enum Cell {
     },
     // Always a shared string
     SharedString {
+        // string index
         si: i32,
         s: i32,
     },
@@ -189,13 +192,11 @@ pub enum Cell {
         f: i32,
         s: i32,
     },
-
     CellFormulaBoolean {
         f: i32,
         v: bool,
         s: i32,
     },
-
     CellFormulaNumber {
         f: i32,
         v: f64,
@@ -207,9 +208,9 @@ pub enum Cell {
         v: String,
         s: i32,
     },
-
     CellFormulaError {
         f: i32,
+        // error index
         ei: Error,
         s: i32,
         // Origin: Sheet3!C4
@@ -217,7 +218,81 @@ pub enum Cell {
         // Error Message: "Not implemented function"
         m: String,
     },
-    // TODO: Array formulas
+    // All Spill/dynamic cells have a boolean, a for array, if true it is an array formula
+    // Spill cells point to a mother cell (row, column)
+    SpillNumberCell {
+        v: f64,
+        s: i32,
+        // mother cell (row, column)
+        m: (i32, i32),
+    },
+    SpillBooleanCell {
+        v: bool,
+        s: i32,
+        // mother cell (row, column)
+        m: (i32, i32),
+    },
+    SpillErrorCell {
+        ei: Error,
+        s: i32,
+        // mother cell (row, column)
+        m: (i32, i32),
+    },
+    SpillStringCell {
+        v: String,
+        s: i32,
+        // mother cell (row, column)
+        m: (i32, i32),
+    },
+    // Dynamic cell formulas have a range (width, height)
+    DynamicCellFormula {
+        f: i32,
+        s: i32,
+        // range of the formula (width, height)
+        r: (i32, i32),
+        // true if the formula is a CSE formula
+        a: bool,
+    },
+    DynamicCellFormulaBoolean {
+        f: i32,
+        v: bool,
+        s: i32,
+        // range of the formula (width, height)
+        r: (i32, i32),
+        // true if the formula is a CSE formula
+        a: bool,
+    },
+    DynamicCellFormulaNumber {
+        f: i32,
+        v: f64,
+        s: i32,
+        // range of the formula (width, height)
+        r: (i32, i32),
+        // true if the formula is a CSE formula
+        a: bool,
+    },
+    DynamicCellFormulaString {
+        f: i32,
+        v: String,
+        s: i32,
+        // range of the formula (width, height)
+        r: (i32, i32),
+        // true if the formula is a CSE formula
+        a: bool,
+    },
+    DynamicCellFormulaError {
+        f: i32,
+        ei: Error,
+        s: i32,
+        // Cell origin of the error
+        o: String,
+        // Error message in text
+        m: String,
+        // range of the formula (width, height)
+        r: (i32, i32),
+        // true if the formula is a CSE formula
+        a: bool,
+    },
 }
 
 impl Default for Cell {

base/src/user_model/common.rs

@@ -24,6 +24,18 @@ use crate::user_model::history::{
 };
 
 use super::border_utils::is_max_border;
+
+#[derive(Serialize, Deserialize)]
+pub enum CellArrayStructure {
+    // It s just a single cell
+    SingleCell,
+    // It is part o a dynamic array
+    // (mother_row, mother_column, width, height)
+    DynamicChild(i32, i32, i32, i32),
+    // Mother of a dynamic array (width, height)
+    DynamicMother(i32, i32),
+}
+
 /// Data for the clipboard
 pub type ClipboardData = HashMap<i32, HashMap<i32, ClipboardCell>>;
 
@@ -627,6 +639,7 @@ impl UserModel {
             }
         }
         self.push_diff_list(diff_list);
+        self.evaluate_if_not_paused();
         Ok(())
     }
 
@@ -656,6 +669,7 @@ impl UserModel {
             }
         }
         self.push_diff_list(diff_list);
+        self.evaluate_if_not_paused();
         Ok(())
     }
 
@@ -1741,6 +1755,65 @@ impl UserModel {
         Ok(None)
     }
 
+    /// Returns the geometric structure of a cell
+    pub fn get_cell_array_structure(
+        &self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+    ) -> Result<CellArrayStructure, String> {
+        let cell = self
+            .model
+            .workbook
+            .worksheet(sheet)?
+            .cell(row, column)
+            .cloned()
+            .unwrap_or_default();
+        match cell {
+            Cell::EmptyCell { .. }
+            | Cell::BooleanCell { .. }
+            | Cell::NumberCell { .. }
+            | Cell::ErrorCell { .. }
+            | Cell::SharedString { .. }
+            | Cell::CellFormula { .. }
+            | Cell::CellFormulaBoolean { .. }
+            | Cell::CellFormulaNumber { .. }
+            | Cell::CellFormulaString { .. }
+            | Cell::CellFormulaError { .. } => Ok(CellArrayStructure::SingleCell),
+            Cell::SpillNumberCell { m, .. }
+            | Cell::SpillBooleanCell { m, .. }
+            | Cell::SpillErrorCell { m, .. }
+            | Cell::SpillStringCell { m, .. } => {
+                let (m_row, m_column) = m;
+                let m_cell = self
+                    .model
+                    .workbook
+                    .worksheet(sheet)?
+                    .cell(m_row, m_column)
+                    .cloned()
+                    .unwrap_or_default();
+                let (width, height) = match m_cell {
+                    Cell::DynamicCellFormula { r, .. }
+                    | Cell::DynamicCellFormulaBoolean { r, .. }
+                    | Cell::DynamicCellFormulaNumber { r, .. }
+                    | Cell::DynamicCellFormulaString { r, .. }
+                    | Cell::DynamicCellFormulaError { r, .. } => (r.0, r.1),
+                    _ => return Err("Invalid structure".to_string()),
+                };
+                Ok(CellArrayStructure::DynamicChild(
+                    m_row, m_column, width, height,
+                ))
+            }
+            Cell::DynamicCellFormula { r, .. }
+            | Cell::DynamicCellFormulaBoolean { r, .. }
+            | Cell::DynamicCellFormulaNumber { r, .. }
+            | Cell::DynamicCellFormulaString { r, .. }
+            | Cell::DynamicCellFormulaError { r, .. } => {
+                Ok(CellArrayStructure::DynamicMother(r.0, r.1))
+            }
+        }
+    }
+
     /// Returns a copy of the selected area
     pub fn copy_to_clipboard(&self) -> Result<Clipboard, String> {
         let selected_area = self.get_selected_view();
@@ -2043,6 +2116,24 @@ impl UserModel {
                     old_value,
                 } => {
                     needs_evaluation = true;
+                    let cell = self
+                        .model
+                        .workbook
+                        .worksheet(*sheet)?
+                        .cell(*row, *column)
+                        .cloned()
+                        .unwrap_or_default();
+                    if let Some((width, height)) = cell.get_dynamic_range() {
+                        for r in *row..*row + height {
+                            for c in *column..*column + width {
+                                // skip the "mother" cell
+                                if r == *row && c == *column {
+                                    continue;
+                                }
+                                self.model.cell_clear_contents(*sheet, r, c)?;
+                            }
+                        }
+                    }
                     match *old_value.clone() {
                         Some(value) => {
                             self.model

base/src/user_model/history.rs

@@ -5,18 +5,21 @@ use bitcode::{Decode, Encode};
 use crate::types::{Cell, Col, Row, SheetState, Style, Worksheet};
 
 #[derive(Clone, Encode, Decode)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) struct RowData {
     pub(crate) row: Option<Row>,
     pub(crate) data: HashMap<i32, Cell>,
 }
 
 #[derive(Clone, Encode, Decode)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) struct ColumnData {
     pub(crate) column: Option<Col>,
     pub(crate) data: HashMap<i32, Cell>,
 }
 
 #[derive(Clone, Encode, Decode)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) enum Diff {
     // Cell diffs
     SetCellValue {

bindings/wasm/src/lib.rs

@@ -766,4 +766,21 @@ impl Model {
             .get_first_non_empty_in_row_after_column(sheet, row, column)
             .map_err(to_js_error)
     }
+
+    #[wasm_bindgen(
+        js_name = "getCellArrayStructure",
+        unchecked_return_type = "CellArrayStructure"
+    )]
+    pub fn get_cell_array_structure(
+        &self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+    ) -> Result<JsValue, JsError> {
+        let cell_structure = self
+            .model
+            .get_cell_array_structure(sheet, row, column)
+            .map_err(|e| to_js_error(e.to_string()))?;
+        serde_wasm_bindgen::to_value(&cell_structure).map_err(JsError::from)
+    }
 }

bindings/wasm/types.ts

@@ -109,6 +109,11 @@ export interface MarkedToken {
   end: number;
 }
 
+export type CellArrayStructure =
+  | "SingleCell"
+  | { DynamicChild: [number, number, number, number] }
+  | { DynamicMother: [number, number] };
+
 export interface WorksheetProperties {
   name: string;
   color: string;
@@ -216,7 +221,7 @@ export interface SelectedView {
 // };
 
 // type ClipboardData = Record<string, Record <string, ClipboardCell>>;
-type ClipboardData = Map<number, Map <number, ClipboardCell>>;
+type ClipboardData = Map<number, Map<number, ClipboardCell>>;
 
 export interface ClipboardCell {
   text: string;

webapp/IronCalc/src/components/FormulaBar/FormulaBar.tsx

@@ -13,6 +13,7 @@ import type { WorkbookState } from "../workbookState";
 type FormulaBarProps = {
   cellAddress: string;
   formulaValue: string;
+  isPartOfArray: boolean;
   model: Model;
   workbookState: WorkbookState;
   onChange: () => void;
@@ -23,6 +24,7 @@ function FormulaBar(properties: FormulaBarProps) {
   const {
     cellAddress,
     formulaValue,
+    isPartOfArray,
     model,
     onChange,
     onTextUpdated,
@@ -62,6 +64,9 @@ function FormulaBar(properties: FormulaBarProps) {
             event.stopPropagation();
             event.preventDefault();
           }}
+          sx={{
+            color: isPartOfArray ? "grey" : "black",
+          }}
         >
           <Editor
             originalText={formulaValue}
@@ -99,9 +104,10 @@ const FormulaSymbolButton = styled(StyledButton)`
 
 const Divider = styled("div")`
   background-color: ${theme.palette.grey["300"]};
-  min-width: 1px;
+  width: 1px;
-  height: 16px;
+  height: 20px;
-  margin: 0px 16px;
+  margin-left: 16px;
+  margin-right: 16px;
 `;
 
 const FormulaContainer = styled("div")`

webapp/IronCalc/src/components/Workbook/Workbook.tsx

@@ -22,7 +22,6 @@ import {
   CLIPBOARD_ID_SESSION_STORAGE_KEY,
   getNewClipboardId,
 } from "../clipboard";
-import { TOOLBAR_HEIGHT } from "../constants";
 import {
   type NavigationKey,
   getCellAddress,
@@ -42,8 +41,6 @@ const Workbook = (props: { model: Model; workbookState: WorkbookState }) => {
   // This is needed because `model` or `workbookState` can change without React being aware of it
   const setRedrawId = useState(0)[1];
 
-  const [isDrawerOpen, setDrawerOpen] = useState(false);
-
   const worksheets = model.getWorksheetsProperties();
   const info = worksheets.map(
     ({ name, color, sheet_id, state }: WorksheetProperties) => {
@@ -365,6 +362,19 @@ const Workbook = (props: { model: Model; workbookState: WorkbookState }) => {
     return model.getCellContent(sheet, row, column);
   };
 
+  // returns true if it is either single cell or the root cell of an array
+  const isRootCellOfArray = () => {
+    const { sheet, row, column } = model.getSelectedView();
+    const r = model.getCellArrayStructure(sheet, row, column);
+    if (r === "SingleCell") {
+      return false;
+    }
+    if ("DynamicMother" in r) {
+      return false;
+    }
+    return true;
+  };
+
   const getCellStyle = useCallback(() => {
     const { sheet, row, column } = model.getSelectedView();
     return model.getCellStyle(sheet, row, column);
@@ -695,119 +705,78 @@ const Workbook = (props: { model: Model; workbookState: WorkbookState }) => {
           worksheets,
           definedNameList: model.getDefinedNameList(),
         }}
-        openDrawer={() => {
+      />
-          setDrawerOpen(true);
+      <FormulaBar
+        cellAddress={cellAddress()}
+        formulaValue={formulaValue()}
+        onChange={() => {
+          setRedrawId((id) => id + 1);
+          focusWorkbook();
+        }}
+        onTextUpdated={() => {
+          setRedrawId((id) => id + 1);
+        }}
+        model={model}
+        workbookState={workbookState}
+        isPartOfArray={isRootCellOfArray()}
+      />
+      <Worksheet
+        model={model}
+        workbookState={workbookState}
+        refresh={(): void => {
+          setRedrawId((id) => id + 1);
+        }}
+        ref={worksheetRef}
+      />
+
+      <SheetTabBar
+        sheets={info}
+        selectedIndex={model.getSelectedSheet()}
+        workbookState={workbookState}
+        onSheetSelected={(sheet: number): void => {
+          if (info[sheet].state !== "visible") {
+            model.unhideSheet(sheet);
+          }
+          model.setSelectedSheet(sheet);
+          setRedrawId((value) => value + 1);
+        }}
+        onAddBlankSheet={(): void => {
+          model.newSheet();
+          setRedrawId((value) => value + 1);
+        }}
+        onSheetColorChanged={(hex: string): void => {
+          try {
+            model.setSheetColor(model.getSelectedSheet(), hex);
+            setRedrawId((value) => value + 1);
+          } catch (e) {
+            // TODO: Show a proper modal dialog
+            alert(`${e}`);
+          }
+        }}
+        onSheetRenamed={(name: string): void => {
+          try {
+            model.renameSheet(model.getSelectedSheet(), name);
+            setRedrawId((value) => value + 1);
+          } catch (e) {
+            // TODO: Show a proper modal dialog
+            alert(`${e}`);
+          }
+        }}
+        onSheetDeleted={(): void => {
+          const selectedSheet = model.getSelectedSheet();
+          model.deleteSheet(selectedSheet);
+          setRedrawId((value) => value + 1);
+        }}
+        onHideSheet={(): void => {
+          const selectedSheet = model.getSelectedSheet();
+          model.hideSheet(selectedSheet);
+          setRedrawId((value) => value + 1);
         }}
       />
-      <WorksheetAreaLeft $drawerWidth={isDrawerOpen ? DRAWER_WIDTH : 0}>
-        <FormulaBar
-          cellAddress={cellAddress()}
-          formulaValue={formulaValue()}
-          onChange={() => {
-            setRedrawId((id) => id + 1);
-            focusWorkbook();
-          }}
-          onTextUpdated={() => {
-            setRedrawId((id) => id + 1);
-          }}
-          model={model}
-          workbookState={workbookState}
-        />
-        <Worksheet
-          model={model}
-          workbookState={workbookState}
-          refresh={(): void => {
-            setRedrawId((id) => id + 1);
-          }}
-          ref={worksheetRef}
-        />
-
-        <SheetTabBar
-          sheets={info}
-          selectedIndex={model.getSelectedSheet()}
-          workbookState={workbookState}
-          onSheetSelected={(sheet: number): void => {
-            if (info[sheet].state !== "visible") {
-              model.unhideSheet(sheet);
-            }
-            model.setSelectedSheet(sheet);
-            setRedrawId((value) => value + 1);
-          }}
-          onAddBlankSheet={(): void => {
-            model.newSheet();
-            setRedrawId((value) => value + 1);
-          }}
-          onSheetColorChanged={(hex: string): void => {
-            try {
-              model.setSheetColor(model.getSelectedSheet(), hex);
-              setRedrawId((value) => value + 1);
-            } catch (e) {
-              // TODO: Show a proper modal dialog
-              alert(`${e}`);
-            }
-          }}
-          onSheetRenamed={(name: string): void => {
-            try {
-              model.renameSheet(model.getSelectedSheet(), name);
-              setRedrawId((value) => value + 1);
-            } catch (e) {
-              // TODO: Show a proper modal dialog
-              alert(`${e}`);
-            }
-          }}
-          onSheetDeleted={(): void => {
-            const selectedSheet = model.getSelectedSheet();
-            model.deleteSheet(selectedSheet);
-            setRedrawId((value) => value + 1);
-          }}
-          onHideSheet={(): void => {
-            const selectedSheet = model.getSelectedSheet();
-            model.hideSheet(selectedSheet);
-            setRedrawId((value) => value + 1);
-          }}
-        />
-      </WorksheetAreaLeft>
-      <WorksheetAreaRight $drawerWidth={isDrawerOpen ? DRAWER_WIDTH : 0}>
-        <span
-          onClick={() => setDrawerOpen(false)}
-          onKeyDown={(e) => {
-            if (e.key === "Enter" || e.key === " ") {
-              setDrawerOpen(false);
-            }
-          }}
-          aria-label="Close drawer"
-        >
-          x
-        </span>
-      </WorksheetAreaRight>
     </Container>
   );
 };
 
-const DRAWER_WIDTH = 300;
-
-type WorksheetAreaLeftProps = { $drawerWidth: number };
-const WorksheetAreaLeft = styled("div")<WorksheetAreaLeftProps>(
-  ({ $drawerWidth }) => ({
-    position: "absolute",
-    top: `${TOOLBAR_HEIGHT + 1}px`,
-    width: `calc(100% - ${$drawerWidth}px)`,
-    height: `calc(100% - ${TOOLBAR_HEIGHT + 1}px)`,
-  }),
-);
-
-const WorksheetAreaRight = styled("div")<WorksheetAreaLeftProps>(
-  ({ $drawerWidth }) => ({
-    position: "absolute",
-    overflow: "hidden",
-    backgroundColor: "red",
-    right: 0,
-    top: `${TOOLBAR_HEIGHT + 1}px`,
-    bottom: 0,
-    width: `${$drawerWidth}px`,
-  }),
-);
-
 const Container = styled("div")`
   display: flex;
   flex-direction: column;

webapp/IronCalc/src/components/Worksheet/Worksheet.tsx

@@ -14,11 +14,16 @@ import {
   LAST_COLUMN,
   LAST_ROW,
   ROW_HEIGH_SCALE,
+  cellArrayStructureColor,
   outlineBackgroundColor,
   outlineColor,
 } from "../WorksheetCanvas/constants";
 import WorksheetCanvas from "../WorksheetCanvas/worksheetCanvas";
-import { FORMULA_BAR_HEIGHT, NAVIGATION_HEIGHT } from "../constants";
+import {
+  FORMULA_BAR_HEIGHT,
+  NAVIGATION_HEIGHT,
+  TOOLBAR_HEIGHT,
+} from "../constants";
 import type { Cell } from "../types";
 import type { WorkbookState } from "../workbookState";
 import CellContextMenu from "./CellContextMenu";
@@ -55,6 +60,7 @@ const Worksheet = forwardRef(
     const spacerElement = useRef<HTMLDivElement>(null);
     const cellOutline = useRef<HTMLDivElement>(null);
     const areaOutline = useRef<HTMLDivElement>(null);
+    const cellArrayStructure = useRef<HTMLDivElement>(null);
     const extendToOutline = useRef<HTMLDivElement>(null);
     const columnResizeGuide = useRef<HTMLDivElement>(null);
     const rowResizeGuide = useRef<HTMLDivElement>(null);
@@ -81,6 +87,7 @@ const Worksheet = forwardRef(
 
       const outline = cellOutline.current;
       const area = areaOutline.current;
+      const arrayStructure = cellArrayStructure.current;
       const extendTo = extendToOutline.current;
       const editor = editorElement.current;
 
@@ -94,7 +101,8 @@ const Worksheet = forwardRef(
         !area ||
         !extendTo ||
         !scrollElement.current ||
-        !editor
+        !editor ||
+        !arrayStructure
       )
         return;
       // FIXME: This two need to be computed.
@@ -111,6 +119,7 @@ const Worksheet = forwardRef(
           rowGuide: rowGuideRef,
           columnHeaders: columnHeadersRef,
           cellOutline: outline,
+          cellArrayStructure: arrayStructure,
           areaOutline: area,
           extendToOutline: extendTo,
           editor: editor,
@@ -325,6 +334,7 @@ const Worksheet = forwardRef(
             />
           </EditorWrapper>
           <AreaOutline ref={areaOutline} />
+          <CellArrayStructure ref={cellArrayStructure} />
           <ExtendToOutline ref={extendToOutline} />
           <ColumnResizeGuide ref={columnResizeGuide} />
           <RowResizeGuide ref={rowResizeGuide} />
@@ -455,7 +465,7 @@ const SheetContainer = styled("div")`
 const Wrapper = styled("div")({
   position: "absolute",
   overflow: "scroll",
-  top: FORMULA_BAR_HEIGHT + 1,
+  top: TOOLBAR_HEIGHT + FORMULA_BAR_HEIGHT + 1,
   left: 0,
   right: 0,
   bottom: NAVIGATION_HEIGHT + 1,
@@ -510,6 +520,12 @@ const AreaOutline = styled("div")`
   background-color: ${outlineBackgroundColor};
 `;
 
+const CellArrayStructure = styled("div")`
+  position: absolute;
+  border: 1px solid ${cellArrayStructureColor};
+  border-radius: 3px;
+`;
+
 const CellOutline = styled("div")`
   position: absolute;
   border: 2px solid ${outlineColor};

webapp/IronCalc/src/components/WorksheetCanvas/constants.ts

@@ -13,6 +13,7 @@ export const defaultTextColor = "#2E414D";
 
 export const outlineColor = "#F2994A";
 export const outlineBackgroundColor = "#F2994A1A";
+export const cellArrayStructureColor = "#64BDFDA1";
 
 export const LAST_COLUMN = 16_384;
 export const LAST_ROW = 1_048_576;

webapp/IronCalc/src/components/WorksheetCanvas/worksheetCanvas.ts

@@ -31,6 +31,7 @@ export interface CanvasSettings {
     canvas: HTMLCanvasElement;
     cellOutline: HTMLDivElement;
     areaOutline: HTMLDivElement;
+    cellArrayStructure: HTMLDivElement;
     extendToOutline: HTMLDivElement;
     columnGuide: HTMLDivElement;
     rowGuide: HTMLDivElement;
@@ -90,6 +91,8 @@ export default class WorksheetCanvas {
 
   cellOutlineHandle: HTMLDivElement;
 
+  cellArrayStructure: HTMLDivElement;
+
   extendToOutline: HTMLDivElement;
 
   workbookState: WorkbookState;
@@ -124,6 +127,7 @@ export default class WorksheetCanvas {
     this.refresh = options.refresh;
 
     this.cellOutline = options.elements.cellOutline;
+    this.cellArrayStructure = options.elements.cellArrayStructure;
     this.areaOutline = options.elements.areaOutline;
     this.extendToOutline = options.elements.extendToOutline;
     this.rowGuide = options.elements.rowGuide;
@@ -1515,16 +1519,20 @@ export default class WorksheetCanvas {
   }
 
   private drawCellOutline(): void {
-    const { cellOutline, areaOutline, cellOutlineHandle } = this;
+    const { cellArrayStructure, cellOutline, areaOutline, cellOutlineHandle } =
+      this;
     if (this.workbookState.getEditingCell()) {
       cellOutline.style.visibility = "hidden";
       cellOutlineHandle.style.visibility = "hidden";
       areaOutline.style.visibility = "hidden";
+      cellArrayStructure.style.visibility = "hidden";
       return;
     }
     cellOutline.style.visibility = "visible";
     cellOutlineHandle.style.visibility = "visible";
     areaOutline.style.visibility = "visible";
+    // This one is hidden by default
+    cellArrayStructure.style.visibility = "hidden";
 
     const [selectedSheet, selectedRow, selectedColumn] =
       this.model.getSelectedCell();
@@ -1580,6 +1588,34 @@ export default class WorksheetCanvas {
       [handleX, handleY] = this.getCoordinatesByCell(rowStart, columnStart);
       handleX += this.getColumnWidth(selectedSheet, columnStart);
       handleY += this.getRowHeight(selectedSheet, rowStart);
+      // we draw the array structure if needed only in this case
+      const arrayStructure = this.model.getCellArrayStructure(
+        selectedSheet,
+        selectedRow,
+        selectedColumn,
+      );
+      let array = null;
+      if (arrayStructure === "SingleCell") {
+        // nothing to see here
+      } else if ("DynamicMother" in arrayStructure) {
+        cellArrayStructure.style.visibility = "visible";
+        const [arrayWidth, arrayHeight] = arrayStructure.DynamicMother;
+        array = [selectedRow, selectedColumn, arrayWidth, arrayHeight];
+      } else {
+        cellArrayStructure.style.visibility = "visible";
+        array = arrayStructure.DynamicChild;
+      }
+      if (array !== null) {
+        const [arrayX, arrayY] = this.getCoordinatesByCell(array[0], array[1]);
+        const [arrayX1, arrayY1] = this.getCoordinatesByCell(
+          array[0] + array[3],
+          array[1] + array[2],
+        );
+        cellArrayStructure.style.left = `${arrayX}px`;
+        cellArrayStructure.style.top = `${arrayY}px`;
+        cellArrayStructure.style.width = `${arrayX1 - arrayX}px`;
+        cellArrayStructure.style.height = `${arrayY1 - arrayY}px`;
+      }
     } else {
       areaOutline.style.visibility = "visible";
       cellOutlineHandle.style.visibility = "visible";

webapp/IronCalc/src/components/constants.tsx

@@ -1,3 +1,3 @@
-export const TOOLBAR_HEIGHT = 40;
+export const TOOLBAR_HEIGHT = 48;
 export const FORMULA_BAR_HEIGHT = 40;
 export const NAVIGATION_HEIGHT = 40;

webapp/IronCalc/src/icons/index.ts

@@ -18,7 +18,6 @@ import InsertRowAboveIcon from "./insert-row-above.svg?react";
 import InsertRowBelow from "./insert-row-below.svg?react";
 
 import IronCalcIcon from "./ironcalc_icon.svg?react";
-import IronCalcIconWhite from "./ironcalc_icon_white.svg?react";
 import IronCalcLogo from "./orange+black.svg?react";
 
 import Fx from "./fx.svg?react";
@@ -42,7 +41,6 @@ export {
   InsertRowAboveIcon,
   InsertRowBelow,
   IronCalcIcon,
-  IronCalcIconWhite,
   IronCalcLogo,
   Fx,
 };

webapp/IronCalc/src/icons/ironcalc_icon_white.svg

@@ -1,7 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path opacity="0.8" d="M9.95898 8.08594C9.60893 8.35318 9.27389 8.64313 8.95898 8.95801C7.09126 10.8257 6.042 13.3586 6.04199 16H6.04102V7.91406C6.39142 7.64662 6.72781 7.35715 7.04297 7.04199C8.90157 5.18307 9.9492 2.6648 9.95898 0.0371094V8.08594Z" fill="white"/>
-<path opacity="0.8" d="M6.04102 7.91406C4.31493 9.23162 2.19571 9.95898 0 9.95898V6.04102C1.60208 6.04102 3.13861 5.40429 4.27148 4.27148C5.40436 3.13861 6.04101 1.60213 6.04102 0L6.04102 7.91406Z" fill="white"/>
-<path opacity="0.8" d="M9.95947 8.08594C11.6856 6.76838 13.8048 6.04102 16.0005 6.04102V9.95898C14.3984 9.95898 12.8619 10.5957 11.729 11.7285C10.5961 12.8614 9.95948 14.3979 9.95947 16L9.95947 8.08594Z" fill="white"/>
-<path d="M9.95898 0C9.95898 2.64126 8.90957 5.17429 7.04199 7.04199C6.727 7.35698 6.39119 7.64674 6.04102 7.91406L6.04102 0H9.95898Z" fill="white"/>
-<path d="M6.04102 16C6.04102 13.3587 7.09042 10.8257 8.95801 8.95801C9.273 8.64302 9.60881 8.35326 9.95898 8.08594V16H6.04102Z" fill="white"/>
-</svg>

webapp/IronCalc/src/index.ts

@@ -1,5 +1,5 @@
 import init, { Model } from "@ironcalc/wasm";
 import IronCalc from "./IronCalc";
-import { IronCalcIcon, IronCalcIconWhite, IronCalcLogo } from "./icons";
+import { IronCalcIcon, IronCalcLogo } from "./icons";
 
-export { init, Model, IronCalc, IronCalcIcon, IronCalcIconWhite, IronCalcLogo };
+export { init, Model, IronCalc, IronCalcIcon, IronCalcLogo };

webapp/IronCalc/src/locale/en_us.json

@@ -27,15 +27,13 @@
     "vertical_align_top": "Align top",
     "selected_png": "Export Selected area as PNG",
     "wrap_text": "Wrap text",
-    "scroll_left": "Scroll left",
-    "scroll_right": "Scroll right",
     "format_menu": {
       "auto": "Auto",
       "number": "Number",
       "percentage": "Percentage",
       "currency_eur": "Euro (EUR)",
       "currency_usd": "Dollar (USD)",
-      "currency_gbp": "British Pound (GBP)",
+      "currency_gbp": "British Pound (GBD)",
       "date_short": "Short date",
       "date_long": "Long date",
       "custom": "Custom",

webapp/app.ironcalc.com/frontend/src/App.tsx

@@ -2,7 +2,6 @@ import "./App.css";
 import styled from "@emotion/styled";
 import { useEffect, useState } from "react";
 import { FileBar } from "./components/FileBar";
-import WelcomeDialog from "./components/WelcomeDialog/WelcomeDialog";
 import {
   get_documentation_model,
   get_model,
@@ -11,8 +10,7 @@ import {
 import {
   createNewModel,
   deleteSelectedModel,
-  isStorageEmpty,
+  loadModelFromStorageOrCreate,
-  loadSelectedModelFromStorage,
   saveModelToStorage,
   saveSelectedModelInStorage,
   selectModelFromStorage,
@@ -20,13 +18,9 @@ import {
 
 // From IronCalc
 import { IronCalc, IronCalcIcon, Model, init } from "@ironcalc/workbook";
-import { Modal } from "@mui/material";
-import TemplatesDialog from "./components/WelcomeDialog/TemplatesDialog";
 
 function App() {
   const [model, setModel] = useState<Model | null>(null);
-  const [showWelcomeDialog, setShowWelcomeDialog] = useState(false);
-  const [isTemplatesDialogOpen, setTemplatesDialogOpen] = useState(false);
 
   useEffect(() => {
     async function start() {
@@ -58,14 +52,8 @@ function App() {
         }
       } else {
         // try to load from local storage
-        const newModel = loadSelectedModelFromStorage();
+        const newModel = loadModelFromStorageOrCreate();
-        if (!newModel) {
+        setModel(newModel);
-          setShowWelcomeDialog(true);
-          const createdModel = new Model("template", "en", "UTC");
-          setModel(createdModel);
-        } else {
-          setModel(newModel);
-        }
       }
     }
     start();
@@ -105,11 +93,7 @@ function App() {
           setModel(newModel);
         }}
         newModel={() => {
-          const createdModel = createNewModel();
+          setModel(createNewModel());
-          setModel(createdModel);
-        }}
-        newModelFromTemplate={() => {
-          setTemplatesDialogOpen(true);
         }}
         setModel={(uuid: string) => {
           const newModel = selectModelFromStorage(uuid);
@@ -125,51 +109,6 @@ function App() {
         }}
       />
       <IronCalc model={model} />
-      {showWelcomeDialog && (
-        <WelcomeDialog
-          onClose={() => {
-            if (isStorageEmpty()) {
-              const createdModel = createNewModel();
-              setModel(createdModel);
-            }
-            setShowWelcomeDialog(false);
-          }}
-          onSelectTemplate={async (templateId) => {
-            switch (templateId) {
-              case "blank": {
-                const createdModel = createNewModel();
-                setModel(createdModel);
-                break;
-              }
-              default: {
-                const model_bytes = await get_documentation_model(templateId);
-                const importedModel = Model.from_bytes(model_bytes);
-                saveModelToStorage(importedModel);
-                setModel(importedModel);
-                break;
-              }
-            }
-            setShowWelcomeDialog(false);
-          }}
-        />
-      )}
-      <Modal
-        open={isTemplatesDialogOpen}
-        onClose={() => setTemplatesDialogOpen(false)}
-        aria-labelledby="templates-dialog-title"
-        aria-describedby="templates-dialog-description"
-      >
-        <TemplatesDialog
-          onClose={() => setTemplatesDialogOpen(false)}
-          onSelectTemplate={async (fileName) => {
-            const model_bytes = await get_documentation_model(fileName);
-            const importedModel = Model.from_bytes(model_bytes);
-            saveModelToStorage(importedModel);
-            setModel(importedModel);
-            setTemplatesDialogOpen(false);
-          }}
-        />
-      </Modal>
     </Wrapper>
   );
 }

webapp/app.ironcalc.com/frontend/src/components/FileBar.tsx

@@ -27,7 +27,6 @@ function useWindowWidth() {
 export function FileBar(properties: {
   model: Model;
   newModel: () => void;
-  newModelFromTemplate: () => void;
   setModel: (key: string) => void;
   onModelUpload: (blob: ArrayBuffer, fileName: string) => Promise<void>;
   onDelete: () => void;
@@ -53,7 +52,6 @@ export function FileBar(properties: {
       <Divider />
       <FileMenu
         newModel={properties.newModel}
-        newModelFromTemplate={properties.newModelFromTemplate}
         setModel={properties.setModel}
         onModelUpload={properties.onModelUpload}
         onDownload={async () => {

webapp/app.ironcalc.com/frontend/src/components/FileMenu.tsx

@@ -1,15 +1,13 @@
 import styled from "@emotion/styled";
 import { Menu, MenuItem, Modal } from "@mui/material";
-import { Check, FileDown, FileUp, Plus, Table2, Trash2 } from "lucide-react";
+import { Check, FileDown, FileUp, Plus, Trash2 } from "lucide-react";
 import { useRef, useState } from "react";
 import DeleteWorkbookDialog from "./DeleteWorkbookDialog";
 import UploadFileDialog from "./UploadFileDialog";
-// import TemplatesDialog from "./WelcomeDialog/TemplatesDialog";
 import { getModelsMetadata, getSelectedUuid } from "./storage";
 
 export function FileMenu(props: {
   newModel: () => void;
-  newModelFromTemplate: () => void;
   setModel: (key: string) => void;
   onDownload: () => void;
   onModelUpload: (blob: ArrayBuffer, fileName: string) => Promise<void>;
@@ -22,6 +20,7 @@ export function FileMenu(props: {
   const uuids = Object.keys(models);
   const selectedUuid = getSelectedUuid();
   const [isDeleteDialogOpen, setDeleteDialogOpen] = useState(false);
+
   const elements = [];
   for (const uuid of uuids) {
     elements.push(
@@ -93,18 +92,7 @@ export function FileMenu(props: {
           <StyledIcon>
             <Plus />
           </StyledIcon>
-          <MenuItemText>New blank workbook</MenuItemText>
+          <MenuItemText>New</MenuItemText>
-        </MenuItemWrapper>
-        <MenuItemWrapper
-          onClick={() => {
-            props.newModelFromTemplate();
-            setMenuOpen(false);
-          }}
-        >
-          <StyledIcon>
-            <Table2 />
-          </StyledIcon>
-          <MenuItemText>New from template</MenuItemText>
         </MenuItemWrapper>
         <MenuItemWrapper
           onClick={() => {
@@ -117,7 +105,6 @@ export function FileMenu(props: {
           </StyledIcon>
           <MenuItemText>Import</MenuItemText>
         </MenuItemWrapper>
-        <MenuDivider />
         <MenuItemWrapper onClick={props.onDownload}>
           <StyledIcon>
             <FileDown />

webapp/app.ironcalc.com/frontend/src/components/WelcomeDialog/TemplatesDialog.tsx

@@ -1,79 +0,0 @@
-import { Dialog, styled } from "@mui/material";
-import { X } from "lucide-react";
-import { useState } from "react";
-import TemplatesList, {
-  Cross,
-  DialogContent,
-  DialogFooter,
-  DialogFooterButton,
-} from "./TemplatesList";
-
-function TemplatesDialog(properties: {
-  onClose: () => void;
-  onSelectTemplate: (templateId: string) => void;
-}) {
-  const [selectedTemplate, setSelectedTemplate] = useState<string>("");
-
-  const handleClose = () => {
-    properties.onClose();
-  };
-
-  const handleTemplateSelect = (templateId: string) => {
-    setSelectedTemplate(templateId);
-  };
-
-  return (
-    <DialogWrapper open={true} onClose={() => {}}>
-      <DialogTemplateHeader>
-        <span style={{ flexGrow: 2, marginLeft: 12 }}>Choose a template</span>
-        <Cross
-          style={{ marginRight: 12 }}
-          onClick={handleClose}
-          title="Close Dialog"
-          tabIndex={0}
-          onKeyDown={(event) => event.key === "Enter" && properties.onClose()}
-        >
-          <X />
-        </Cross>
-      </DialogTemplateHeader>
-      <DialogContent>
-        <TemplatesList
-          selectedTemplate={selectedTemplate}
-          handleTemplateSelect={handleTemplateSelect}
-        />
-      </DialogContent>
-      <DialogFooter>
-        <DialogFooterButton
-          onClick={() => properties.onSelectTemplate(selectedTemplate)}
-        >
-          Create workbook
-        </DialogFooterButton>
-      </DialogFooter>
-    </DialogWrapper>
-  );
-}
-
-export const DialogWrapper = styled(Dialog)`
-  font-family: Inter;
-  .MuiDialog-paper {
-    width: 440px;
-    border-radius: 12px;
-    margin: 16px;
-    border: 1px solid #e0e0e0;
-  }
-  .MuiBackdrop-root {
-    background-color: rgba(0, 0, 0, 0.4);
-  }
-`;
-
-const DialogTemplateHeader = styled("div")`
-  display: flex;
-  align-items: center;
-  border-bottom: 1px solid #e0e0e0;
-  height: 44px;
-  font-size: 14px;
-  font-weight: 500;
-  font-family: Inter;
-`;
-
-export default TemplatesDialog;

webapp/app.ironcalc.com/frontend/src/components/WelcomeDialog/TemplatesList.tsx

@@ -1,103 +0,0 @@
-import { Dialog, styled } from "@mui/material";
-import { House, TicketsPlane } from "lucide-react";
-import TemplatesListItem from "./TemplatesListItem";
-
-function TemplatesList(props: {
-  selectedTemplate: string;
-  handleTemplateSelect: (templateId: string) => void;
-}) {
-  const { selectedTemplate, handleTemplateSelect } = props;
-  return (
-    <TemplatesListWrapper>
-      <TemplatesListItem
-        title="Mortgage calculator"
-        description="Estimate payments, interest, and overall cost."
-        icon={<House />}
-        iconColor="#2F80ED"
-        active={selectedTemplate === "mortgage_calculator"}
-        onClick={() => handleTemplateSelect("mortgage_calculator")}
-      />
-      <TemplatesListItem
-        title="Travel expenses tracker"
-        description="Track trip costs and stay on budget."
-        icon={<TicketsPlane />}
-        iconColor="#EB5757"
-        active={selectedTemplate === "travel_expenses_tracker"}
-        onClick={() => handleTemplateSelect("travel_expenses_tracker")}
-      />
-    </TemplatesListWrapper>
-  );
-}
-
-export const DialogWrapper = styled(Dialog)`
-  font-family: Inter;
-  .MuiDialog-paper {
-    width: 440px;
-    border-radius: 12px;
-    margin: 16px;
-    border: 1px solid #e0e0e0;
-  }
-  .MuiBackdrop-root {
-    background-color: rgba(0, 0, 0, 0.4);
-  }
-`;
-
-export const Cross = styled("div")`
-  &:hover {
-    background-color: #f5f5f5;
-  }
-  display: flex;
-  border-radius: 4px;
-  min-height: 24px;
-  min-width: 24px;
-  cursor: pointer;
-  align-items: center;
-  justify-content: center;
-  svg {
-    width: 16px;
-    height: 16px;
-    stroke-width: 1.5;
-  }
-`;
-
-export const DialogContent = styled("div")`
-  display: flex;
-  flex-direction: column;
-  gap: 12px;
-  padding: 16px;
-  max-height: 300px;
-  overflow: hidden;
-  overflow-y: auto;
-`;
-
-export const TemplatesListWrapper = styled("div")`
-  display: flex;
-  flex-direction: column;
-  gap: 10px;
-`;
-
-export const DialogFooter = styled("div")`
-  border-top: 1px solid #e0e0e0;
-  padding: 16px;
-`;
-
-export const DialogFooterButton = styled("button")`
-  background-color: #f2994a;
-  border: none;
-  color: #fff;
-  padding: 12px;
-  border-radius: 4px;
-  cursor: pointer;
-  width: 100%;
-  font-size: 12px;
-  font-family: Inter;
-  &:hover {
-    background-color: #d68742;
-  }
-  &:active {
-    background-color: #d68742;
-  }
-`;
-
-// export default TemplatesDialog;
-export default TemplatesList;

webapp/app.ironcalc.com/frontend/src/components/WelcomeDialog/TemplatesListItem.tsx

@@ -1,107 +0,0 @@
-import { styled } from "@mui/material";
-import type { ReactNode } from "react";
-
-interface TemplatesListItemProps {
-  title: string;
-  description: string;
-  icon: ReactNode;
-  iconColor: string;
-  active: boolean;
-  onClick: () => void;
-}
-
-function TemplatesListItem({
-  title,
-  description,
-  icon,
-  iconColor,
-  active,
-  onClick,
-}: TemplatesListItemProps) {
-  return (
-    <ListItemWrapper active={active} iconColor={iconColor} onClick={onClick}>
-      <StyledIcon iconColor={iconColor}>{icon}</StyledIcon>
-      <TemplatesListItemTitle>
-        <Title>{title}</Title>
-        <Subtitle>{description}</Subtitle>
-      </TemplatesListItemTitle>
-      <RadioButton active={active}>
-        <RadioButtonDot />
-      </RadioButton>
-    </ListItemWrapper>
-  );
-}
-
-const ListItemWrapper = styled("div")<{ active?: boolean; iconColor?: string }>`
-  display: flex;
-  flex-direction: row;
-  align-items: flex-start;
-  gap: 8px;
-  font-size: 12px;
-  color: #424242;
-  border: 1px solid ${(props) => (props.active ? props.iconColor || "#424242" : "rgba(224, 224, 224, 0.60)")};
-  background-color: #FFFFFF;
-  padding: 16px;
-  border-radius: 8px;
-  box-shadow: 0 1px 1px rgba(0, 0, 0, 0.1);
-  cursor: pointer;
-  outline: ${(props) => (props.active ? `4px solid ${props.iconColor || "#424242"}24` : "none")};
-  transition: border 0.1s ease-in-out;
-  user-select: none;
-  &:hover {
-    border: 1px solid ${(props) => props.iconColor};
-    transition: border 0.1s ease-in-out;
-  }
-`;
-
-const TemplatesListItemTitle = styled("div")`
-  display: flex;
-  flex-direction: column;
-  color: #424242;
-  width: 100%;
-  gap: 2px;
-`;
-
-const Title = styled("div")`
-  font-weight: 600;
-  color: #424242;
-  line-height: 16px;
-`;
-
-const Subtitle = styled("div")`
-  color: #757575;
-`;
-
-const StyledIcon = styled("div")<{ iconColor?: string }>`
-  display: flex;
-  align-items: center;
-  margin-top: -1px;
-  svg {
-    width: 18px;
-    height: 100%;
-    color: ${(props) => props.iconColor || "#424242"};
-  }
-`;
-
-const RadioButton = styled("div")<{ active?: boolean }>`
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  width: 16px;
-  min-width: 16px;
-  height: 16px;
-  border-radius: 16px;
-  margin-top: -4px;
-  margin-right: -4px;
-  background-color: ${(props) => (props.active ? "#F2994A" : "#FFFFFF")};
-  border: ${(props) => (props.active ? "none" : "1px solid #E0E0E0")};
-`;
-
-const RadioButtonDot = styled("div")`
-  width: 6px;
-  height: 6px;
-  border-radius: 6px;
-  background-color: #FFF;
-`;
-
-export default TemplatesListItem;

webapp/app.ironcalc.com/frontend/src/components/WelcomeDialog/WelcomeDialog.tsx

@@ -1,136 +0,0 @@
-import { IronCalcIconWhite as IronCalcIcon } from "@ironcalc/workbook";
-import { styled } from "@mui/material";
-import { Table, X } from "lucide-react";
-import { useState } from "react";
-import TemplatesListItem from "./TemplatesListItem";
-
-import TemplatesList, {
-  Cross,
-  DialogContent,
-  DialogFooter,
-  DialogFooterButton,
-  DialogWrapper,
-  TemplatesListWrapper,
-} from "./TemplatesList";
-
-function WelcomeDialog(properties: {
-  onClose: () => void;
-  onSelectTemplate: (templateId: string) => void;
-}) {
-  const [selectedTemplate, setSelectedTemplate] = useState<string>("blank");
-
-  const handleClose = () => {
-    properties.onClose();
-  };
-
-  const handleTemplateSelect = (templateId: string) => {
-    setSelectedTemplate(templateId);
-  };
-
-  return (
-    <DialogWrapper open={true} onClose={() => {}}>
-      <DialogWelcomeHeader>
-        <DialogHeaderTitleWrapper>
-          <DialogHeaderLogoWrapper>
-            <IronCalcIcon />
-          </DialogHeaderLogoWrapper>
-          <DialogHeaderTitle>Welcome to IronCalc</DialogHeaderTitle>
-          <DialogHeaderTitleSubtitle>
-            Start with a blank workbook or a ready-made template.
-          </DialogHeaderTitleSubtitle>
-        </DialogHeaderTitleWrapper>
-        <Cross
-          onClick={handleClose}
-          title="Close Dialog"
-          tabIndex={0}
-          onKeyDown={(event) => event.key === "Enter" && properties.onClose()}
-        >
-          <X />
-        </Cross>
-      </DialogWelcomeHeader>
-      <DialogContent>
-        <ListTitle>New</ListTitle>
-        <TemplatesListWrapper>
-          <TemplatesListItem
-            title="Blank workbook"
-            description="Create from scratch or upload your own file."
-            icon={<Table />}
-            iconColor="#F2994A"
-            active={selectedTemplate === "blank"}
-            onClick={() => handleTemplateSelect("blank")}
-          />
-        </TemplatesListWrapper>
-        <ListTitle>Templates</ListTitle>
-        <TemplatesList
-          selectedTemplate={selectedTemplate}
-          handleTemplateSelect={handleTemplateSelect}
-        />
-      </DialogContent>
-      <DialogFooter>
-        <DialogFooterButton
-          onClick={() => properties.onSelectTemplate(selectedTemplate)}
-        >
-          Create workbook
-        </DialogFooterButton>
-      </DialogFooter>
-    </DialogWrapper>
-  );
-}
-
-const DialogWelcomeHeader = styled("div")`
-  display: flex;
-  flex-direction: row;
-  align-items: flex-start;
-  border-bottom: 1px solid #e0e0e0;
-  padding: 16px;
-  font-family: Inter;
-`;
-
-const DialogHeaderTitleWrapper = styled("span")`
-  display: flex;
-  flex-direction: column;
-  align-items: flex-start;
-  font-size: 14px;
-  font-weight: 500;
-  padding: 4px 0px;
-  gap: 4px;
-  width: 100%;
-`;
-
-const DialogHeaderTitle = styled("span")`
-  font-weight: 700;
-`;
-
-const DialogHeaderTitleSubtitle = styled("span")`
-  font-size: 12px;
-  color: #757575;
-`;
-
-const DialogHeaderLogoWrapper = styled("div")`
-  display: flex;
-  flex-direction: row;
-  align-items: center;
-  justify-content: center;
-  max-width: 20px;
-  max-height: 20px;
-  background-color: #f2994a;
-  padding: 10px;
-  margin-bottom: 12px;
-  border-radius: 6px;
-  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-  transform: rotate(-8deg);
-  user-select: none;
-
-  svg {
-    width: 18px;
-    height: 18px;
-  }
-`;
-
-const ListTitle = styled("div")`
-  font-size: 12px;
-  font-weight: 600;
-  color: #424242;
-`;
-
-export default WelcomeDialog;

webapp/app.ironcalc.com/frontend/src/components/storage.ts

@@ -60,7 +60,7 @@ export function createNewModel(): Model {
   return model;
 }
 
-export function loadSelectedModelFromStorage(): Model | null {
+export function loadModelFromStorageOrCreate(): Model {
   const uuid = localStorage.getItem("selected");
   if (uuid) {
     // We try to load the selected model
@@ -68,22 +68,14 @@ export function loadSelectedModelFromStorage(): Model | null {
     if (modelBytesString) {
       return Model.from_bytes(base64ToBytes(modelBytesString));
     }
+    // If it doesn't exist we create one at that uuid
+    const newModel = new Model("Workbook1", "en", "UTC");
+    localStorage.setItem("selected", uuid);
+    localStorage.setItem(uuid, bytesToBase64(newModel.toBytes()));
+    return newModel;
   }
-  return null;
+  // If there was no selected model we create a new one
-}
+  return createNewModel();
-
-// check if storage is empty
-export function isStorageEmpty(): boolean {
-  const modelsJson = localStorage.getItem("models");
-  if (!modelsJson) {
-    return true;
-  }
-  try {
-    const models = JSON.parse(modelsJson);
-    return Object.keys(models).length === 0;
-  } catch (e) {
-    return true;
-  }
 }
 
 export function saveSelectedModelInStorage(model: Model) {

xlsx/src/export/worksheets.rs

@@ -22,7 +22,7 @@ use itertools::Itertools;
 
 use ironcalc_base::{
     expressions::{
-        parser::{stringify::to_excel_string, Node},
+        parser::{static_analysis::StaticResult, stringify::to_excel_string, Node},
         types::CellReferenceRC,
         utils::number_to_column,
     },
@@ -56,7 +56,7 @@ fn get_formula_attribute(
 
 pub(crate) fn get_worksheet_xml(
     worksheet: &Worksheet,
-    parsed_formulas: &[Node],
+    parsed_formulas: &[(Node, StaticResult)],
     dimension: &str,
     is_sheet_selected: bool,
 ) -> String {
@@ -104,7 +104,7 @@ pub(crate) fn get_worksheet_xml(
                     let style = get_cell_style_attribute(*s);
                     row_data_str.push(format!("<c r=\"{cell_name}\"{style}/>"));
                 }
-                Cell::BooleanCell { v, s } => {
+                Cell::SpillBooleanCell { v, s, .. } | Cell::BooleanCell { v, s } => {
                     // <c r="A8" t="b" s="1">
                     //     <v>1</v>
                     // </c>
@@ -114,7 +114,7 @@ pub(crate) fn get_worksheet_xml(
                         "<c r=\"{cell_name}\" t=\"b\"{style}><v>{b}</v></c>"
                     ));
                 }
-                Cell::NumberCell { v, s } => {
+                Cell::SpillNumberCell { v, s, .. } | Cell::NumberCell { v, s } => {
                     // Normally the type number is left out. Example:
                     // <c r="C6" s="1">
                     //     <v>3</v>
@@ -122,7 +122,7 @@ pub(crate) fn get_worksheet_xml(
                     let style = get_cell_style_attribute(*s);
                     row_data_str.push(format!("<c r=\"{cell_name}\"{style}><v>{v}</v></c>"));
                 }
-                Cell::ErrorCell { ei, s } => {
+                Cell::SpillErrorCell { ei, s, .. } | Cell::ErrorCell { ei, s } => {
                     let style = get_cell_style_attribute(*s);
                     row_data_str.push(format!(
                         "<c r=\"{cell_name}\" t=\"e\"{style}><v>{ei}</v></c>"
@@ -153,7 +153,7 @@ pub(crate) fn get_worksheet_xml(
                         worksheet.get_name(),
                         *row_index,
                         *column_index,
-                        &parsed_formulas[*f as usize],
+                        &parsed_formulas[*f as usize].0,
                     );
 
                     let b = i32::from(*v);
@@ -172,7 +172,7 @@ pub(crate) fn get_worksheet_xml(
                         worksheet.get_name(),
                         *row_index,
                         *column_index,
-                        &parsed_formulas[*f as usize],
+                        &parsed_formulas[*f as usize].0,
                     );
                     let style = get_cell_style_attribute(*s);
 
@@ -189,14 +189,14 @@ pub(crate) fn get_worksheet_xml(
                         worksheet.get_name(),
                         *row_index,
                         *column_index,
-                        &parsed_formulas[*f as usize],
+                        &parsed_formulas[*f as usize].0,
                     );
                     let style = get_cell_style_attribute(*s);
                     let escaped_v = escape_xml(v);
 
                     row_data_str.push(format!(
-                        "<c r=\"{cell_name}\" t=\"str\"{style}><f>{formula}</f><v>{escaped_v}</v></c>"
+                                    "<c r=\"{cell_name}\" t=\"str\"{style}><f>{formula}</f><v>{escaped_v}</v></c>"
-                    ));
+                                ));
                 }
                 Cell::CellFormulaError {
                     f,
@@ -213,13 +213,135 @@ pub(crate) fn get_worksheet_xml(
                         worksheet.get_name(),
                         *row_index,
                         *column_index,
-                        &parsed_formulas[*f as usize],
+                        &parsed_formulas[*f as usize].0,
                     );
                     let style = get_cell_style_attribute(*s);
                     row_data_str.push(format!(
                         "<c r=\"{cell_name}\" t=\"e\"{style}><f>{formula}</f><v>{ei}</v></c>"
                     ));
                 }
+                Cell::SpillStringCell { v, s, .. } => {
+                    // inline string
+                    // <c r="A1" t="str">
+                    let style = get_cell_style_attribute(*s);
+                    let escaped_v = escape_xml(v);
+                    row_data_str.push(format!(
+                        "<c r=\"{cell_name}\" t=\"str\"{style}><v>{escaped_v}</v></c>"
+                    ));
+                }
+                Cell::DynamicCellFormula { .. } => {
+                    panic!("Model needs to be evaluated before saving!");
+                }
+                Cell::DynamicCellFormulaBoolean { f, v, s, r, a: _ } => {
+                    // <c r="A1" s="3" cm="1">
+                    //   <f t="array" ref="A1:A10">A1:A10</f>
+                    //   <v>1</v>
+                    // </c>
+                    let style = get_cell_style_attribute(*s);
+                    let range = format!(
+                        "{}{}:{}{}",
+                        column_name,
+                        row_index,
+                        number_to_column(r.0 + column_index).unwrap(),
+                        r.1 + row_index
+                    );
+
+                    let formula = get_formula_attribute(
+                        worksheet.get_name(),
+                        *row_index,
+                        *column_index,
+                        &parsed_formulas[*f as usize].0,
+                    );
+
+                    let b = i32::from(*v);
+                    row_data_str.push(format!(
+                        r#"<c r="{cell_name}" t="b" s="{style}" cm="1"><f t="array" ref="{range}">{formula}</f><v>{b}</v></c>"#
+                    ));
+                }
+                Cell::DynamicCellFormulaNumber { f, v, s, r, a: _ } => {
+                    // <c r="C4" s="3" cm="1">
+                    //   <f t="array" ref="C4:C10">C4:C10</f>
+                    //   <v>123</v>
+                    // </c>
+                    let style = get_cell_style_attribute(*s);
+                    let range = format!(
+                        "{}{}:{}{}",
+                        column_name,
+                        row_index,
+                        number_to_column(r.0 + column_index).unwrap(),
+                        r.1 + row_index
+                    );
+
+                    let formula = get_formula_attribute(
+                        worksheet.get_name(),
+                        *row_index,
+                        *column_index,
+                        &parsed_formulas[*f as usize].0,
+                    );
+
+                    row_data_str.push(format!(
+                        r#"<c r="{cell_name}" s="{style}" cm="1"><f t="array" ref="{range}">{formula}</f><v>{v}</v></c>"#
+                    ));
+                }
+                Cell::DynamicCellFormulaString { f, v, s, r, a: _ } => {
+                    // <c r="C6" t="str" s="5" cm="1">
+                    //   <f t="array" ref="C6:C10">C6:C10</f>
+                    //   <v>Hello world!</v>
+                    // </c>
+                    let style = get_cell_style_attribute(*s);
+                    let range = format!(
+                        "{}{}:{}{}",
+                        column_name,
+                        row_index,
+                        number_to_column(r.0 + column_index).unwrap(),
+                        r.1 + row_index
+                    );
+
+                    let formula = get_formula_attribute(
+                        worksheet.get_name(),
+                        *row_index,
+                        *column_index,
+                        &parsed_formulas[*f as usize].0,
+                    );
+                    let escaped_v = escape_xml(v);
+
+                    row_data_str.push(format!(
+                                    r#"<c r="{cell_name}" t="str" s="{style}" cm="1"><f t="array" ref="{range}">{formula}</f><v>{escaped_v}</v></c>"#
+                                ));
+                }
+                Cell::DynamicCellFormulaError {
+                    f,
+                    ei,
+                    s,
+                    o: _,
+                    m: _,
+                    r,
+                    a: _,
+                } => {
+                    // <c r="C6" t="e" s="4" cm="1">
+                    //   <f t="array" ref="C6:C10">C6:C10</f>
+                    //   <v>#DIV/0!</v>
+                    // </c>
+                    let style = get_cell_style_attribute(*s);
+                    let range = format!(
+                        "{}{}:{}{}",
+                        column_name,
+                        row_index,
+                        number_to_column(r.0 + column_index).unwrap(),
+                        r.1 + row_index
+                    );
+
+                    let formula = get_formula_attribute(
+                        worksheet.get_name(),
+                        *row_index,
+                        *column_index,
+                        &parsed_formulas[*f as usize].0,
+                    );
+
+                    row_data_str.push(format!(
+                        r#"<c r="{cell_name}" t="e" s="{style}" cm="1"><f t="array" ref="{range}">{formula}</f><v>{ei}</v></c>"#
+                    ));
+                }
             }
         }
         let row_style_str = match row_style_dict.get(row_index) {

xlsx/src/import/worksheets.rs

@@ -303,13 +303,15 @@ fn from_a1_to_rc(
     context: String,
     tables: HashMap<String, Table>,
     defined_names: Vec<DefinedNameS>,
+    is_array: bool,
 ) -> Result<String, XlsxError> {
     let mut parser = Parser::new(worksheets.to_owned(), defined_names, tables);
     let cell_reference =
         parse_reference(&context).map_err(|error| XlsxError::Xml(error.to_string()))?;
     let mut t = parser.parse(&formula, &cell_reference);
-    add_implicit_intersection(&mut t, true);
+    if !is_array {
-
+        add_implicit_intersection(&mut t, true);
+    }
     Ok(to_rc_format(&t))
 }
 
@@ -837,6 +839,7 @@ pub(super) fn load_sheet<R: Read + std::io::Seek>(
             };
 
             let cell_metadata = cell.attribute("cm");
+            let is_dynamic_array = cell_metadata == Some("1");
 
             // type, the default type being "n" for number
             // If the cell does not have a value is an empty cell
@@ -903,6 +906,7 @@ pub(super) fn load_sheet<R: Read + std::io::Seek>(
                                     context,
                                     tables.clone(),
                                     defined_names.clone(),
+                                    is_dynamic_array,
                                 )?;
                                 match index_map.get(&si) {
                                     Some(index) => {
@@ -951,7 +955,6 @@ pub(super) fn load_sheet<R: Read + std::io::Seek>(
                         return Err(XlsxError::NotImplemented("data table formulas".to_string()));
                     }
                     "array" | "normal" => {
-                        let is_dynamic_array = cell_metadata == Some("1");
                         if formula_type == "array" && !is_dynamic_array {
                             // Dynamic formulas in Excel are formulas of type array with the cm=1, those we support.
                             // On the other hand the old CSE formulas or array formulas are not supported in IronCalc for the time being
@@ -966,6 +969,7 @@ pub(super) fn load_sheet<R: Read + std::io::Seek>(
                             context,
                             tables.clone(),
                             defined_names.clone(),
+                            is_dynamic_array,
                         )?;
 
                         match get_formula_index(&formula, &shared_formulas) {