@omegagrid/grid-core 0.10.2 → 0.10.4

package/dist/model/gridModel.js

@@ -0,0 +1,797 @@
+import { tree } from "@omegagrid/core";
+import { log } from "@omegagrid/core";
+import { CalculationModel } from "./calculationModel";
+import { CellRange } from "../common/range";
+import { ConditionalFormats } from "./conditionalFormats";
+import { Sparklines } from "../sparklines/sparklines";
+import { ColumnModel } from "./columnModel";
+import { CommentModel } from "./commentModel";
+import { IterableAxisRange, IterableRange } from "./iterableRange";
+import { NamingModel } from "./namingModel";
+import { initOptions } from "./options";
+import { RowModel } from "./rowModel";
+import { StyleModel } from "./styleModel";
+import { applyCellTheme, applyRowTheme, applyTheme } from "./tableTheme";
+import { SortingModel } from "./sortingModel";
+import { Merges } from "./merges";
+import { FilterModel } from "./filterModel";
+const DEFAULT_SOURCE_KEYS = [
+    'index', 'name', 'rows', 'columns', 'cells', 'options', 'sparklines',
+    'rules', 'comments', 'styles', 'names', 'props', 'tab', 'theme'
+];
+export class GridModel {
+    get mergedHeaders() { return this._mergedHeaders; }
+    get hasFilter() { return this._filter; }
+    get hasRowTree() { return this._maxRowLevel > 0; }
+    get hasRowTreeEnabled() { return this.hasRowTree && this.options.rowTree.enabled; }
+    get maxRowLevel() { return this._maxRowLevel; }
+    get hasColumnTree() { return this._maxColumnLevel > 0; }
+    get hasColumnTreeEnabled() { return this.hasColumnTree && this.options.columnTree.enabled; }
+    get maxColumnLevel() { return this._maxColumnLevel; }
+    get headerCount() { return this._headerCount; }
+    get columnHeaderCount() { return this.headerCount + (this.hasColumnTreeEnabled ? 1 : 0) + (this.hasFilter ? 1 : 0); }
+    get properties() { return this._properties; }
+    set properties(v) { this._properties = v; }
+    get theme() { return this._theme; }
+    set theme(v) { this._theme = v; }
+    constructor(source, options, logger) {
+        this.otherModels = {};
+        this.autofitColumns = new Set();
+        this.autofitRows = new Set();
+        this.merges = new Merges(this);
+        this.styles = new StyleModel(this);
+        this.comments = new CommentModel(this);
+        this.calculations = new CalculationModel(this);
+        this.names = new NamingModel(this);
+        this.sorting = new SortingModel(this);
+        this.filter = new FilterModel(this);
+        this.sparklines = new Sparklines(this);
+        this.conditionalFormats = new ConditionalFormats(this);
+        this._filter = false;
+        this._maxRowLevel = 0;
+        this._maxColumnLevel = 0;
+        this._headerCount = 0;
+        this._levelBasedRowTree = true;
+        this._levelBasedColTree = true;
+        this.clearRows = () => {
+            this.rowRoot.clearChildren();
+            this.rows = [];
+            return this.rows;
+        };
+        this.clearColumns = () => this.columns = [];
+        this.logger = logger;
+        this.options = options ?? initOptions(source.options);
+        this.populate(source);
+    }
+    getConnectedModel(name) {
+        return this.group ? this.group.get(name) : null;
+    }
+    getModelByRange(range) {
+        return range.sheet ? this.getConnectedModel(range.sheet) : this;
+    }
+    getCellByA1(a1) {
+        return this.getCellByRange(CellRange.fromA1(a1));
+    }
+    getCellByRange(r) {
+        return this.getCellByCoords(r.r1, r.c1);
+    }
+    getCellByCoords(r, c) {
+        return this.rows[r]?.cell(c);
+    }
+    cell(coord1, coord2) {
+        if (!isNaN(coord1))
+            return this.getCellByCoords(coord1, coord2 || 0);
+        if (coord1 instanceof CellRange)
+            return this.getCellByRange(coord1);
+        if (typeof coord1 === 'string')
+            return this.getCellByA1(coord1);
+        return null;
+    }
+    createRows(source, root = new RowModel(this, { l: -1 }), indexOffset = 0) {
+        let hasRowLevelBasedTree = false;
+        let hasRowParentBasedTree = false;
+        this.autofitRows.clear();
+        const rows = source.map((rowSource, r) => {
+            if (!rowSource)
+                rowSource = {};
+            if (!isNaN(rowSource.l))
+                hasRowLevelBasedTree = true;
+            if (rowSource.p != null)
+                hasRowParentBasedTree = true;
+            if (rowSource.h == 'auto')
+                this.autofitRows.add(r);
+            const rowModel = new RowModel(this, rowSource);
+            rowModel.origIndex = r + indexOffset;
+            if (rowModel.name)
+                this.names.set(rowModel.name, CellRange.fullRow(r));
+            return rowModel;
+        });
+        let maxRowLevel = -1;
+        if (hasRowLevelBasedTree)
+            maxRowLevel = tree.buildLevelBasedTree(rows, root, {
+                reverse: this.options.rowTree.reversed
+            });
+        else if (hasRowParentBasedTree)
+            maxRowLevel = tree.buildParentBasedTree(rows, root);
+        else
+            root.children = rows;
+        if (!hasRowParentBasedTree)
+            hasRowLevelBasedTree = true; // default to level based tree
+        return [root, rows, maxRowLevel, hasRowLevelBasedTree];
+    }
+    insertRowData(parent, offset, source) {
+        const res = this.createRows(source, new RowModel(this, { l: parent.level }), offset);
+        this._maxRowLevel = Math.max(this._maxRowLevel, res[2]);
+        parent.insertChildren(res[0].children, offset);
+        this.indexRowsByTree();
+        if (this.theme) {
+            const newRows = res[1];
+            applyRowTheme(this.theme, this, newRows);
+            applyCellTheme(this.theme, this, new CellRange(0, newRows[0].index, Infinity, newRows[newRows.length - 1].index));
+        }
+    }
+    applyTheme(theme, invalidateCellStyles) {
+        if (invalidateCellStyles) {
+            for (const cell of this.getInitializedCellIterator()) {
+                cell.invalidateStyle();
+            }
+        }
+        applyTheme(theme, this);
+    }
+    populate(source) {
+        this.index = source.index;
+        this.name = source.name ?? this.name;
+        this.tab = source.tab;
+        let hasColLevelBasedTree = false;
+        let hasColParentBasedTree = false;
+        if (!source.columns)
+            source.columns = new Array(this.options.columns).fill({});
+        if (!source.rows)
+            source.rows = new Array(this.options.rows).fill({});
+        // styles
+        if (source.styles)
+            this.styles.populate(source.styles);
+        // columns
+        this.autofitColumns.clear();
+        this.columns = source.columns.map((columnSource, c) => {
+            if (!columnSource)
+                columnSource = {};
+            if (columnSource.l > 0)
+                hasColLevelBasedTree = true;
+            if (columnSource.p != null)
+                hasColParentBasedTree = true;
+            if (columnSource.w == 'auto')
+                this.autofitColumns.add(c);
+            const colModel = new ColumnModel(this, columnSource);
+            this._filter = colModel.hasFilter || this._filter;
+            if (colModel.name)
+                this.names.set(colModel.name, CellRange.fullColumn(c));
+            return colModel;
+        });
+        this._levelBasedColTree = hasColLevelBasedTree;
+        this._maxColumnLevel = -1;
+        this.colRoot = new ColumnModel(this, { l: -1 });
+        if (hasColLevelBasedTree)
+            this._maxColumnLevel = tree.buildLevelBasedTree(this.columns, this.colRoot, {
+                reverse: this.options.columnTree.reversed
+            });
+        else if (hasColParentBasedTree)
+            this._maxColumnLevel = tree.buildParentBasedTree(this.columns, this.colRoot);
+        else
+            this.colRoot.children = this.columns;
+        if (!hasColParentBasedTree)
+            this._levelBasedColTree = true; // default to level based tree
+        this.indexColumns();
+        this.indexVisibleColumns();
+        // rows
+        [this.rowRoot, this.rows, this._maxRowLevel, this._levelBasedRowTree] = this.createRows(source.rows);
+        this.indexRows();
+        this.indexVisibleRows();
+        if (this.options.pageSize && this.options.pageSize <= this.rows.length)
+            this.rowRoot.count = Infinity;
+        // cells
+        this.merges.clear();
+        source.comments = source.comments || [];
+        source.cells?.forEach((cellSource, i) => {
+            const cell = this.rows[cellSource.r] ? this.rows[cellSource.r].cell(cellSource.c, cellSource) : null;
+            if (!cell) {
+                this.logger?.error(`invalid cell definition (index ${i}): ${JSON.stringify(cellSource)}`);
+            }
+            else if (cellSource.cs > 1 || cellSource.rs > 1) {
+                this.merges.add({ r: cell.r, c: cell.c, rs: cellSource.rs || 1, cs: cellSource.cs || 1 });
+            }
+            if (cell && cellSource.comment) {
+                source.comments.push(Object.assign(cellSource.comment, { c: cellSource.c, r: cellSource.r }));
+            }
+        });
+        // sparklines
+        if (source.sparklines) {
+            try {
+                this.sparklines.populate(source.sparklines);
+            }
+            catch (error) {
+                log.getLogger().error(`Sparkline init error: ${error}`);
+            }
+        }
+        // names
+        if (source.names) {
+            try {
+                this.names.populate(source.names);
+            }
+            catch (error) {
+                log.getLogger().error(`Named range init error: ${error}`);
+            }
+        }
+        // conditional formats
+        if (source.rules) {
+            try {
+                this.conditionalFormats.populate(source.rules);
+            }
+            catch (error) {
+                log.getLogger().error(`Conditional formats init error: ${error}`);
+            }
+        }
+        // theme
+        if (source.theme) {
+            try {
+                this.applyTheme(source.theme);
+                this._theme = source.theme;
+            }
+            catch (error) {
+                log.getLogger().error(`Theme init error: ${error}`);
+            }
+        }
+        // comments
+        if (source.comments) {
+            try {
+                this.comments.populate(source.comments);
+            }
+            catch (error) {
+                log.getLogger().error(`Comment init error: ${error}`);
+            }
+        }
+        // custom properties
+        this._properties = source.props;
+        // additional properties
+        this.otherSourceData = {};
+        const defaultKeys = new Set(DEFAULT_SOURCE_KEYS);
+        const keys = Object.keys(source).filter(k => !defaultKeys.has(k));
+        keys.forEach(k => this.otherSourceData[k] = source[k]);
+        // default sort
+        if (this.options.sorting?.defaultSettings) {
+            this.sorting.settings = this.options.sorting.defaultSettings;
+        }
+        // default filter
+        if (this.options.filters?.defaultSettings) {
+            this.filter.settings = this.options.filters.defaultSettings;
+        }
+        this.calcHeaderHeights();
+    }
+    getSourceData() {
+        const data = {
+            index: this.index,
+            name: this.name,
+            tab: this.tab,
+            columns: this.columns.map(col => col.getSourceData()),
+            rows: this.rows.map(row => row.getSourceData()),
+            styles: this.styles.getSourceData(),
+            rules: this.conditionalFormats.getSourceData(),
+            sparklines: this.sparklines.getSourceData(),
+            names: this.names.getSourceData(),
+            options: this.options,
+        };
+        if (this._properties)
+            data.props = this._properties;
+        const cells = [];
+        let cellData;
+        for (let r = 0; r < this.rows.length; r++) {
+            for (let c = 0; c < this.columns.length; c++) {
+                cellData = this.rows[r].cell(c).getSourceData();
+                if (Object.keys(cellData).length > 0) {
+                    cellData.r = r;
+                    cellData.c = c;
+                    cells.push(cellData);
+                }
+            }
+        }
+        if (cells.length > 0)
+            data.cells = cells;
+        const styles = [];
+        this.styles.clean();
+        this.styles.map.forEach(style => styles.push(style));
+        if (styles.length > 0)
+            data.styles = styles;
+        const otherModelKeys = new Set([
+            ...Object.keys(this.otherModels ?? {}),
+            ...Object.keys(this.otherSourceData ?? {})
+        ]);
+        otherModelKeys.forEach(k => data[k] = this.otherModels[k]
+            ? Array.from(this.otherModels[k]).map(m => m.getSourceData())
+            : this.otherSourceData[k]);
+        return data;
+    }
+    calcHeaderHeights() {
+        this._headerCount = 0;
+        this._headerHeights = [];
+        this.columns.forEach((column) => {
+            this._headerCount = column.header ? column.header.length : this._headerCount;
+            if (this._headerHeights.length < this._headerCount) {
+                this._headerHeights.push(...Array(this._headerCount - this._headerHeights.length).fill(0));
+            }
+            column.header?.forEach((h, r) => {
+                if (r >= this._headerHeights.length) {
+                    this._headerHeights.push(0);
+                }
+                this._headerHeights[r] = Math.max(this._headerHeights[r], h.height ?? 0);
+            });
+        });
+    }
+    indexRows() {
+        this.visibleRows = [];
+        this.rows.forEach((row, r) => {
+            row.index = r;
+            if (!row.isLoaded)
+                row.collapsed = true;
+            if (!row.hidden && row.filterState != tree.FilterState.Filtered) {
+                row.visibleIndex = this.visibleRows.length;
+                this.visibleRows.push(row);
+            }
+        });
+    }
+    indexVisibleRows() {
+        this.visibleRows = [];
+        let r = 0;
+        if (this._levelBasedRowTree) {
+            this.rowRoot.walkVisible((node) => {
+                node.visibleIndex = r++;
+                this.visibleRows.push(node);
+            });
+            // reverse order of row index
+            if (this.options.rowTree.reversed) {
+                const reversedVisibleRows = new Array(this.visibleRows.length);
+                this.visibleRows.forEach((row, i) => {
+                    r = this.visibleRows.length - i - 1;
+                    row.visibleIndex = r;
+                    reversedVisibleRows[r] = row;
+                });
+                this.visibleRows = reversedVisibleRows;
+            }
+        }
+        else {
+            // in parent based node rows do not have to respect tree order
+            this.rowRoot.walkVisible((node) => this.visibleRows[node.index] = node);
+            this.visibleRows = this.visibleRows.filter(row => {
+                if (row) {
+                    row.visibleIndex = r++;
+                    return true;
+                }
+                return false;
+            });
+        }
+    }
+    indexRowsByTree() {
+        this.rows = [];
+        let r = 0;
+        this.rowRoot.walk((row) => {
+            row.index = r++;
+            this.rows.push(row);
+        });
+        if (this.options.rowTree.reversed)
+            this.rows.reverse();
+        this.indexVisibleRows();
+    }
+    indexColumns() {
+        this.visibleColumns = [];
+        this.columns.forEach((column, c) => {
+            column.index = c;
+            if (!column.hidden)
+                this.visibleColumns.push(column);
+        });
+    }
+    indexVisibleColumns() {
+        this.visibleColumns = [];
+        this.visibleColumnIndex = {};
+        let c = 0;
+        this.colRoot.walkVisible((node) => {
+            node.visibleIndex = c;
+            this.visibleColumnIndex[node.index] = c++;
+            this.visibleColumns.push(node);
+        });
+        // reverse order of column index
+        if (this.options.columnTree.reversed) {
+            this.visibleColumnIndex = {};
+            const reversedVisibleColumns = new Array(this.visibleColumns.length);
+            this.visibleColumns.forEach((column, i) => {
+                c = this.visibleColumns.length - i - 1;
+                column.visibleIndex = c;
+                this.visibleColumnIndex[column.index] = c;
+                reversedVisibleColumns[c] = column;
+            });
+            this.visibleColumns = reversedVisibleColumns;
+        }
+        this.indexHeaders();
+    }
+    indexHeaders() {
+        this._mergedHeaders = [];
+        this._headerCount = 0;
+        this.colRoot.walkVisible((column) => {
+            this._headerCount = Math.max(column.header ? column.header.length : 0, this._headerCount);
+            column.mergedHeaders.forEach(h => this._mergedHeaders.push({
+                h: h,
+                c: column.index,
+                r: h.r,
+                cs: column.calculateRealColspan(h.cs ?? 1),
+                rs: h.rs ?? 1
+            }));
+        });
+        // hidden header cells
+        this._mergedHeaders.forEach(h => {
+            if (h.h.hidden)
+                return;
+            for (let c = h.c; c < h.c + h.cs; c++) {
+                for (let r = h.r; r < h.r + h.rs; r++) {
+                    if ((r > h.r || c > h.c) && this.columns[c] && this.columns[c].header[r]) {
+                        this.columns[c].header[r].hidden = true;
+                    }
+                }
+            }
+        });
+        this.calcHeaderHeights();
+    }
+    removeHeader(r) {
+        this.columns.forEach(column => {
+            if (r < column.header.length)
+                column.header.splice(r, 1);
+        });
+        this.indexHeaders();
+    }
+    clear() {
+        this.clearRows();
+        this.clearColumns();
+        this.resetViewport();
+    }
+    resetViewport() {
+        this._viewport = null;
+        return this;
+    }
+    getViewport(offset, viewportSize, freeze) {
+        const viewportRows = [];
+        const viewportColumns = [];
+        let row;
+        let remainingHeight = viewportSize.h;
+        let r = 0;
+        // top rows
+        for (r = 0; r < freeze.t; r++) {
+            row = this.visibleRows[r];
+            remainingHeight -= row.height;
+            viewportRows.push(row);
+        }
+        // bottom rows
+        for (r = this.visibleRows.length - freeze.b; r < this.visibleRows.length; r++) {
+            row = this.visibleRows[r];
+            remainingHeight -= row.height;
+        }
+        // center rows
+        r = freeze.t + offset.r;
+        while (remainingHeight > 0 && r < this.visibleRows.length) {
+            row = this.visibleRows[r++];
+            remainingHeight -= row.height;
+            viewportRows.push(row);
+        }
+        // bottom rows again
+        for (r = this.visibleRows.length - freeze.b; r < this.visibleRows.length; r++) {
+            viewportRows.push(this.visibleRows[r]);
+        }
+        let column;
+        let remainingWidth = viewportSize.w;
+        let c = 0;
+        // left columns
+        for (c = 0; c < freeze.l; c++) {
+            column = this.visibleColumns[c];
+            remainingWidth -= column.width;
+            viewportColumns.push(column);
+        }
+        // right columns
+        for (c = this.visibleColumns.length - freeze.r; c < this.visibleColumns.length; c++) {
+            column = this.visibleColumns[c];
+            remainingWidth -= column.width;
+        }
+        // center columns
+        c = freeze.l + offset.c;
+        while (remainingWidth > 0 && c < this.visibleColumns.length) {
+            column = this.visibleColumns[c++];
+            remainingWidth -= column.width;
+            viewportColumns.push(column);
+        }
+        // right columns again
+        for (c = this.visibleColumns.length - freeze.r; c < this.visibleColumns.length; c++) {
+            viewportColumns.push(this.visibleColumns[c]);
+        }
+        return (this._viewport = { rows: viewportRows, columns: viewportColumns });
+    }
+    calculateViewport() {
+        return this._viewport ? this.calculations.calculateViewport(this._viewport) : [];
+    }
+    getValuesInRange(range, formattedValues = false) {
+        range = range.intersect(this.gridRange);
+        if (!range)
+            return [];
+        const { columns, rows } = range.size;
+        const values = new Array(rows);
+        let i = 0, j = 0;
+        let row;
+        for (let r = range.r1; r <= range.r2; r++) {
+            values[i] = new Array(columns);
+            j = 0;
+            row = this.rows[r];
+            for (let c = range.c1; c <= range.c2; c++) {
+                values[i][j++] = formattedValues ? row.cell(c).formattedValue : row.cell(c).value;
+            }
+            ++i;
+        }
+        return values;
+    }
+    setRowExpandLevel(level) {
+        this.rows.forEach(row => {
+            row.collapsed = (!row.isLoaded && !row.isPartialyLoaded) || row.level >= level;
+            if (row.level <= level)
+                row.hidden = false; // remove hidden flag for visible rows
+        });
+        this.indexVisibleRows();
+    }
+    setColumnExpandLevel(level) {
+        this.columns.forEach(column => column.collapsed = column.level >= level);
+        this.indexVisibleColumns();
+    }
+    getViewportRange() {
+        return this._viewport ? new CellRange(this._viewport.columns[0].index, this._viewport.rows[0].index, this._viewport.columns[this._viewport.columns.length - 1].index, this._viewport.rows[this._viewport.rows.length - 1].index) : null;
+    }
+    get gridRange() {
+        return new CellRange(0, 0, this.columns.length - 1, this.rows.length - 1);
+    }
+    getRangeIterator(range, withinViewport = false) {
+        return new IterableRange(this, withinViewport && this._viewport
+            ? range.intersect(this.getViewportRange())
+            : range.intersect(this.gridRange));
+    }
+    getInitializedCellIterator() {
+        return new IterableRange(this, this.gridRange, true);
+    }
+    getRowIterator(range, withinViewport = false) {
+        range = withinViewport && this._viewport
+            ? range.intersect(this.getViewportRange())
+            : range.intersect(this.gridRange);
+        return new IterableAxisRange(this, range, 'rows');
+    }
+    getColumnIterator(range, withinViewport = false) {
+        range = withinViewport && this._viewport
+            ? range.intersect(this.getViewportRange())
+            : range.intersect(this.gridRange);
+        return new IterableAxisRange(this, range, 'columns');
+    }
+    getCellArray(range) {
+        const cells = [];
+        for (const cell of this.getRangeIterator(range)) {
+            cells.push(cell);
+        }
+        return cells;
+    }
+    transformRangeToMatrix(range, transform) {
+        let row, cell, rowValues;
+        range = range.intersect(this.gridRange);
+        const cells = [];
+        for (let r = range.r1; r <= range.r2; r++) {
+            row = this.rows[r];
+            if (!row)
+                continue;
+            rowValues = [];
+            for (let c = range.c1; c <= range.c2; c++) {
+                cell = row.cell(c);
+                if (cell)
+                    rowValues.push(transform(cell));
+            }
+            cells.push(rowValues);
+        }
+        return cells;
+    }
+    getCellMatrix(range) {
+        return this.getModelByRange(range)?.transformRangeToMatrix(range, c => c);
+    }
+    getValueMatrix(range) {
+        return this.getModelByRange(range)?.transformRangeToMatrix(range, c => c.value);
+    }
+    shift(options) {
+        options.sheet = this.name;
+        this.merges.shift(options);
+        this.calculations.shift(options);
+        this.names.shift(options);
+        this.comments.shift(options);
+        this.sparklines.shift(options);
+    }
+    clearCalculations(all = false) {
+        if (all && this.group)
+            this.group.models.forEach(m => m.calculations.refresh());
+        else
+            this.calculations.refresh();
+    }
+    refreshSparklines() {
+        this.sparklines.updateRangeMaps();
+        for (const cell of this.getInitializedCellIterator()) {
+            cell.invalidateStyle();
+        }
+    }
+    clearCalculatedStyles() {
+        this.conditionalFormats.refresh();
+        const cells = [];
+        for (const cell of this.getInitializedCellIterator()) {
+            cells.push(cell);
+            cell.invalidateStyle();
+        }
+    }
+    insertColumns(index, count, after = false) {
+        const parent = this.columns[Math.min(this.columns.length - 1, index)].parent;
+        if (after)
+            ++index;
+        this.shift({ index: index, offset: count, direction: 'right' });
+        for (let r = 0; r < this.rows.length; r++)
+            this.rows[r].insertColumns(index, count, false);
+        const newColumns = (new Array(count)).fill(null).map(() => new ColumnModel(this));
+        this.columns.splice(index, 0, ...newColumns);
+        if (this.maxColumnLevel > 0)
+            parent.insertChildren(newColumns, index - (parent.index || -1) - 1);
+        this.indexColumns();
+        this.clearCalculations(true);
+        return newColumns;
+    }
+    deleteColumns(index, count) {
+        const parent = this.columns[index].parent;
+        this.shift({ index: index, offset: count, direction: 'left' });
+        const deletedCells = [];
+        for (let r = 0; r < this.rows.length; r++)
+            deletedCells.push(this.rows[r].deleteColumns(index, count, false));
+        // const deletedColumns: [ColumnModel, CellModel[]][] = this.columns.splice(index, count)
+        // 	.map((column, i) => [column, deletedCells[i]]);
+        const deletedColumns = this.columns.splice(index, count);
+        parent?.deleteChildren(deletedColumns);
+        this.indexColumns();
+        this.clearCalculations(true);
+        return deletedColumns;
+    }
+    insertRows(index, rows, after = false) {
+        const parentIndex = Math.min(this.rows.length - 1, index);
+        const parent = parentIndex < 0 ? this.rowRoot : this.rows[parentIndex].parent;
+        if (after)
+            ++index;
+        const count = isNaN(rows) ? rows.length : rows;
+        this.shift({ index: index, offset: count, direction: 'down' });
+        const newRows = isNaN(rows) ? rows : (new Array(count)).fill(null).map(() => new RowModel(this));
+        this.rows.splice(index, 0, ...newRows);
+        if (this.maxRowLevel > 0)
+            parent.insertChildren(newRows, index - (parent.index || -1) - 1);
+        this.indexRows();
+        if (this.theme) {
+            applyRowTheme(this.theme, this, newRows);
+            applyCellTheme(this.theme, this, new CellRange(0, newRows[0].index, Infinity, newRows[newRows.length - 1].index));
+        }
+        this.clearCalculations(true);
+        return newRows;
+    }
+    deleteRows(index, count) {
+        const parent = this.rows[index].parent;
+        this.shift({ index: index, offset: count, direction: 'up' });
+        const deletedRows = this.rows.splice(index, count);
+        parent?.deleteChildren(deletedRows);
+        this.indexRows();
+        this.clearCalculations(true);
+        return deletedRows;
+    }
+    moveRows(index, count, targetIndex) {
+        const movingRows = this.rows.splice(index, count);
+        this.rows.splice(targetIndex, 0, ...movingRows);
+        this.shift({ index: index, offset: targetIndex - index, direction: 'down', maxIndex: index + count - 1 });
+        this.indexRows();
+        this.clearCalculations(true);
+        return movingRows;
+    }
+    moveColumns(index, count, targetIndex) {
+        const movingColumns = this.columns.splice(index, count);
+        this.columns.splice(targetIndex, 0, ...movingColumns);
+        this.shift({ index: index, offset: targetIndex - index, direction: 'right', maxIndex: index + count - 1 });
+        this.indexColumns();
+        this.clearCalculations(true);
+        return movingColumns;
+    }
+    spillValues(opt) {
+        const { cell, values, displayValues, propertyCell } = opt;
+        const cells = [];
+        const oldValues = [];
+        const empty = values.length === 0 || values[0].length === 0;
+        let row, spillCell;
+        const range = empty ? null : new CellRange(cell.c, cell.r, cell.c + values[0].length - 1, cell.r + values.length - 1);
+        if (cell.spillRange) {
+            // clear values from previous evaluations not contained in the new spill range
+            this.getRangeIterator(cell.spillRange, true).forEach(c => {
+                if (cell != c && !range?.contains(c.range))
+                    c.clearSpilledValue();
+            });
+        }
+        cell.spillRange = range;
+        if (empty)
+            return { cells, oldValues, range: null };
+        for (let r = range.r1; r <= range.r2; r++) {
+            row = this.rows[r];
+            if (!row)
+                continue;
+            const r2 = r - range.r1;
+            for (let c = range.c1; c <= range.c2; c++) {
+                const c2 = c - range.c1;
+                spillCell = row.cell(c);
+                if (spillCell.editable) {
+                    oldValues.push(spillCell.value2);
+                    spillCell.spillValue(values[r2][c2], cell);
+                    if (propertyCell) {
+                        spillCell.format = propertyCell.format;
+                        spillCell.type = propertyCell.type;
+                    }
+                    if (displayValues && displayValues[r2][c2] != null)
+                        spillCell.displayValue = displayValues[r2][c2];
+                    cells.push(spillCell);
+                }
+            }
+        }
+        return { cells, oldValues, range };
+    }
+    getCellByName(name, contextRange, searchGroup = true) {
+        const cell = this.names.getCellByName(name, contextRange);
+        if (cell)
+            return cell;
+        else if (this.group && searchGroup)
+            return this.group.getCellByName(name, contextRange);
+        return null;
+    }
+    getRangeByName(name, searchGroup = true) {
+        const range = this.names.getRangeByName(name);
+        if (range)
+            return range;
+        else if (this.group && searchGroup)
+            return this.group.getRangeByName(name);
+        return null;
+    }
+    getValueMatrixByName(name, searchGroup = true) {
+        const matrix = this.names.getRangeByName(name);
+        if (matrix)
+            return this.getValueMatrix(matrix);
+        else if (this.group && searchGroup)
+            return this.group.getValueMatrixByName(name);
+        return null;
+    }
+    rebuildRowTree() {
+        const buildFunction = this._levelBasedRowTree ? tree.buildLevelBasedTree : tree.buildParentBasedTree;
+        this._maxRowLevel = buildFunction(this.rows, this.rowRoot, {
+            reverse: this.options.rowTree.reversed
+        });
+        this.indexRowsByTree();
+    }
+    rebuildColumnTree() {
+        const buildFunction = this._levelBasedColTree ? tree.buildLevelBasedTree : tree.buildParentBasedTree;
+        this._maxColumnLevel = buildFunction(this.columns, this.colRoot, {
+            reverse: this.options.columnTree.reversed
+        });
+        this.indexColumns();
+    }
+    calculateCellOffset(cell) {
+        let x = 0, y = 0;
+        for (let c = 0; c < cell.c1; c++) {
+            if (!this.columns[c])
+                break;
+            x += this.columns[c].width;
+        }
+        for (let r = 0; r < cell.r1; r++) {
+            if (!this.rows[r])
+                break;
+            y += this.rows[r].height;
+        }
+        return { x, y };
+    }
+}
+//# sourceMappingURL=gridModel.js.map