@omegagrid/grid-core 0.2.5

package/dist/model/gridModel.js

@@ -0,0 +1,639 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridModel = void 0;
+const core_1 = require("@omegagrid/core");
+const calculationModel_1 = require("../calculations/calculationModel");
+const comments_1 = require("../comments");
+const range_1 = require("../common/range");
+const formatting_1 = require("../formatting");
+const sparklines_1 = require("../sparklines/sparklines");
+const columnModel_1 = require("./columnModel");
+const iterableRange_1 = require("./iterableRange");
+const namingModel_1 = require("./namingModel");
+const options_1 = require("./options");
+const rowModel_1 = require("./rowModel");
+const styleModel_1 = require("./styleModel");
+class GridModel {
+    get comments() { return this._comments; }
+    get calculations() { return this._calculations; }
+    get names() { return this._names; }
+    get sparklines() { return this._sparklines; }
+    get conditionalFormats() { return this._conditionalFormats; }
+    get mergedHeaders() { return this._mergedHeaders; }
+    get mergedCells() { return this._mergedCells; }
+    get hiddenCells() { return this._hiddenCells; }
+    get hasFilter() { return this._filter; }
+    get hasRowTree() { return this._maxRowLevel > 0 && this.options.rowTree !== false; }
+    get maxRowLevel() { return this._maxRowLevel; }
+    get hasColumnTree() { return this._maxColumnLevel > 0; }
+    get maxColumnLevel() { return this._maxColumnLevel; }
+    get headerCount() { return this._headerCount; }
+    get columnHeaderCount() { return this.headerCount + (this.hasColumnTree ? 1 : 0) + (this.hasFilter ? 1 : 0); }
+    get properties() { return this._properties; }
+    set properties(v) { this._properties = v; }
+    constructor(source, options, logger) {
+        this.styles = new styleModel_1.StyleModel(this);
+        this._comments = new comments_1.Comments(this);
+        this._calculations = new calculationModel_1.CalculationModel(this);
+        this._names = new namingModel_1.NamingModel(this);
+        this._sparklines = new sparklines_1.Sparklines(this);
+        this._conditionalFormats = new formatting_1.ConditionalFormats(this);
+        this._hiddenCells = new Map();
+        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 !== null && options !== void 0 ? options : (0, options_1.initOptions)(source.options);
+        this.populate(source);
+    }
+    getConnectedModel(name) {
+        return this.group ? this.group.get(name) : null;
+    }
+    getCellByA1(a1) {
+        return this.getCellByRange(range_1.CellRange.fromA1(a1));
+    }
+    getCellByRange(r) {
+        return this.rows[r.r1].cell(r.c1);
+    }
+    createRows(source, root = new rowModel_1.RowModel(this, { l: -1 }), indexOffset = 0) {
+        let hasRowLevelBasedTree = false;
+        let hasRowParentBasedTree = false;
+        const rows = source.map((rowSource, r) => {
+            if (!rowSource)
+                rowSource = {};
+            if (!isNaN(rowSource.l))
+                hasRowLevelBasedTree = true;
+            if (rowSource.p != null)
+                hasRowParentBasedTree = true;
+            const rowModel = new rowModel_1.RowModel(this, rowSource);
+            rowModel.origIndex = r + indexOffset;
+            if (rowModel.name)
+                this.names.set(rowModel.name, range_1.CellRange.fullRow(r));
+            return rowModel;
+        });
+        let maxRowLevel = -1;
+        if (hasRowLevelBasedTree)
+            maxRowLevel = core_1.tree.buildLevelBasedTree(rows, root);
+        else if (hasRowParentBasedTree)
+            maxRowLevel = core_1.tree.buildParentBasedTree(rows, root);
+        else
+            root.children = rows;
+        return [root, rows, maxRowLevel, hasRowLevelBasedTree];
+    }
+    insertRowData(parent, offset, source) {
+        const res = this.createRows(source, new rowModel_1.RowModel(this, { l: parent.level }), offset);
+        this._maxRowLevel = Math.max(this._maxRowLevel, res[2]);
+        parent.insertChildren(res[0].children, offset);
+        this.indexRowsByTree();
+    }
+    updateHeaders() {
+        this._mergedHeaders = [];
+        this.columns.forEach(column => {
+            column.mergedHeaders.forEach(h => { var _a, _b; return this._mergedHeaders.push({ h: h, c: column.index, r: h.r, cs: (_a = h.cs) !== null && _a !== void 0 ? _a : 1, rs: (_b = h.rs) !== null && _b !== void 0 ? _b : 1 }); });
+        });
+        this.calcHeaderHeights();
+    }
+    removeHeader(r) {
+        this.columns.forEach(column => {
+            if (r < column.header.length)
+                column.header.splice(r, 1);
+        });
+        this.updateHeaders();
+    }
+    populate(source) {
+        var _a, _b;
+        this.index = source.index;
+        this.name = (_a = source.name) !== null && _a !== void 0 ? _a : this.name;
+        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._mergedHeaders = [];
+        this.columns = source.columns.map((columnSource, c) => {
+            if (!columnSource)
+                columnSource = {};
+            if (columnSource.l > 0)
+                hasColLevelBasedTree = true;
+            if (columnSource.p != null)
+                hasColParentBasedTree = true;
+            const colModel = new columnModel_1.ColumnModel(this, columnSource);
+            colModel.mergedHeaders.forEach(h => { var _a, _b; return this._mergedHeaders.push({ h: h, c: c, r: h.r, cs: (_a = h.cs) !== null && _a !== void 0 ? _a : 1, rs: (_b = h.rs) !== null && _b !== void 0 ? _b : 1 }); });
+            this._filter = colModel.filter || this._filter;
+            if (colModel.name)
+                this.names.set(colModel.name, range_1.CellRange.fullColumn(c));
+            return colModel;
+        });
+        this._levelBasedColTree = hasColLevelBasedTree;
+        // 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._maxColumnLevel = -1;
+        this.colRoot = new columnModel_1.ColumnModel(this, { l: -1 });
+        if (hasColLevelBasedTree)
+            this._maxColumnLevel = core_1.tree.buildLevelBasedTree(this.columns, this.colRoot);
+        else if (hasColParentBasedTree)
+            this._maxColumnLevel = core_1.tree.buildParentBasedTree(this.columns, this.colRoot);
+        else
+            this.colRoot.children = this.columns;
+        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._mergedCells = [];
+        (_b = source.cells) === null || _b === void 0 ? void 0 : _b.forEach((cellSource, i) => {
+            var _a;
+            const cell = this.rows[cellSource.r].cell(cellSource.c, cellSource);
+            if (!cell) {
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error(`invalid cell definition (index ${i}): ${JSON.stringify(cellSource)}`);
+            }
+            else if (cell.colspan > 1 || cell.rowspan > 1) {
+                this._mergedCells.push({ r: cell.r, c: cell.c, rs: cell.rowspan, cs: cell.colspan });
+            }
+        });
+        this.indexHiddenCells();
+        // sparklines
+        if (source.sparklines)
+            this.sparklines.populate(source.sparklines);
+        // conditional formats
+        if (source.rules)
+            this.conditionalFormats.populate(source.rules);
+        // comments
+        if (source.comments)
+            this.comments.populate(source.comments);
+        // names
+        if (source.names)
+            this.names.populate(source.names);
+        this.calcHeaderHeights();
+    }
+    getSourceData() {
+        const data = {
+            index: this.index,
+            name: this.name,
+            tabColor: this.tabColor,
+            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()
+        };
+        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;
+        return data;
+    }
+    calcHeaderHeights() {
+        this._headerCount = 0;
+        this._headerHeights = [];
+        this.columns.forEach((column) => {
+            var _a;
+            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));
+            }
+            (_a = column.header) === null || _a === void 0 ? void 0 : _a.forEach((h, r) => {
+                var _a;
+                if (r >= this._headerHeights.length) {
+                    this._headerHeights.push(0);
+                }
+                this._headerHeights[r] = Math.max(this._headerHeights[r], (_a = h.height) !== null && _a !== void 0 ? _a : 0);
+            });
+        });
+    }
+    indexRows() {
+        this.visibleRows = [];
+        this.rows.forEach((row, r) => {
+            row.index = r;
+            if (!row.isLoaded)
+                row.collapsed = true;
+            if (!row.hidden && row.filterState != core_1.tree.FilterState.Filtered)
+                this.visibleRows.push(row);
+        });
+    }
+    indexVisibleRows() {
+        this.visibleRows = [];
+        let r = 0;
+        if (this._levelBasedRowTree) {
+            this.rowRoot.walkVisible((node) => {
+                node.visibleIndex = r++;
+                this.visibleRows.push(node);
+            });
+        }
+        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);
+        });
+        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 r = 0;
+        this.colRoot.walkVisible((node) => {
+            node.visibleIndex = r;
+            this.visibleColumnIndex[node.index] = r++;
+            this.visibleColumns.push(node);
+        });
+    }
+    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, evaluate = true) {
+        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++] = evaluate ? this.calculations.evaluate(row.cell(c)) : row.cell(c).value;
+            }
+            ++i;
+        }
+        return values;
+    }
+    setRowExpandLevel(level) {
+        this.rows.forEach(row => row.collapsed = (!row.isLoaded && !row.isPartialyLoaded) || row.level >= level);
+        this.indexVisibleRows();
+    }
+    setColumnExpandLevel(level) {
+        this.columns.forEach(column => column.collapsed = column.level >= level);
+        this.indexVisibleColumns();
+    }
+    getViewportRange() {
+        return this._viewport ? new range_1.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 range_1.CellRange(0, 0, this.columns.length - 1, this.rows.length - 1);
+    }
+    getRangeIterator(range, withinViewport = false) {
+        return new iterableRange_1.IterableRange(this, withinViewport && this._viewport
+            ? range.intersect(this.getViewportRange())
+            : range.intersect(this.gridRange));
+    }
+    getInitializedCellIterator() {
+        return new iterableRange_1.IterableRange(this, this.gridRange, true);
+    }
+    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.transformRangeToMatrix(range, c => c);
+    }
+    getValueMatrix(range) {
+        return this.transformRangeToMatrix(range, c => this.calculations.evaluate(c));
+    }
+    shiftMerges(index, offset, direction, _maxIndex = null) {
+        const fn = {
+            'down': m => {
+                if (index <= m.r)
+                    m.r += offset;
+                else if (index > m.r && index < m.r + m.rs) // && m.r + m.rs < maxIndex)
+                    this.rows[m.r].cell(m.c).rowspan = (m.rs += offset);
+            },
+            'up': m => {
+                if (index <= m.r)
+                    m.r -= offset;
+                else if (index > m.r && index < m.r + m.rs) // && m.r + m.rs < maxIndex)
+                    this.rows[m.r].cell(m.c).rowspan = (m.rs -= offset);
+            },
+            'right': m => {
+                if (index <= m.c)
+                    m.c += offset;
+                else if (index > m.c && index < m.c + m.cs)
+                    this.rows[m.r].cell(m.c).colspan = (m.cs += offset);
+            },
+            'left': m => {
+                if (index <= m.c)
+                    m.c -= offset;
+                else if (index > m.c && index < m.c + m.cs) // && m.r + m.rs < maxIndex)
+                    this.rows[m.r].cell(m.c).colspan = (m.cs -= offset);
+            }
+        };
+        this.mergedCells.forEach(fn[direction]);
+        this.indexHiddenCells();
+    }
+    indexHiddenCells() {
+        this._hiddenCells.clear();
+        this.mergedCells.forEach(m => {
+            if (m.r > 0)
+                return;
+            if ((this._hiddenCells.has(m.r) && this._hiddenCells.get(m.r).has(m.c)))
+                return;
+            for (let r = m.r; r < m.r + m.rs; r++) {
+                for (let c = m.c; c < m.c + m.cs; c++) {
+                    if (r > m.r || c > m.c) {
+                        if (!this._hiddenCells.has(r))
+                            this._hiddenCells.set(r, new Map());
+                        this._hiddenCells.get(r).set(c, m);
+                    }
+                }
+            }
+        });
+    }
+    shift(index, offset, direction, maxIndex = null) {
+        this.shiftMerges(index, offset, direction, maxIndex);
+        this.calculations.shift(index, offset, direction, maxIndex);
+        this.names.shift(index, offset, direction, maxIndex);
+        this.comments.shift(index, offset, direction);
+        this.sparklines.shift(index, offset, direction);
+    }
+    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, count, '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_1.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, count, '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 === null || parent === void 0 ? void 0 : 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, count, 'down');
+        const newRows = isNaN(rows) ? rows : (new Array(count)).fill(null).map(() => new rowModel_1.RowModel(this));
+        this.rows.splice(index, 0, ...newRows);
+        if (this.maxRowLevel > 0)
+            parent.insertChildren(newRows, index - (parent.index || -1) - 1);
+        this.indexRows();
+        this.clearCalculations(true);
+        return newRows;
+    }
+    deleteRows(index, count) {
+        const parent = this.rows[index].parent;
+        this.shift(index, count, 'up');
+        const deletedRows = this.rows.splice(index, count);
+        parent === null || parent === void 0 ? void 0 : 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, targetIndex - index, 'down', 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, targetIndex - index, 'right', index + count - 1);
+        this.indexColumns();
+        this.clearCalculations(true);
+        return movingColumns;
+    }
+    spillValues(cell, values, propertyCell, displayValues) {
+        const cells = [];
+        const oldValues = [];
+        let row, cell2;
+        for (let r = 0; r < values.length; r++) {
+            row = this.rows[cell.r + r];
+            if (row) {
+                for (let c = 0; c < values[r].length; c++) {
+                    cell2 = row.cell(cell.c + c);
+                    if (cell2 && cell2.editable) {
+                        oldValues.push(cell2.value2);
+                        cell2.value = values[r][c];
+                        if (propertyCell) {
+                            cell2.format = propertyCell.format;
+                            cell2.type = propertyCell.type;
+                        }
+                        if (displayValues && displayValues[r][c] != null)
+                            cell2.displayValue = displayValues[r][c];
+                        cells.push(cell2);
+                    }
+                }
+            }
+        }
+        return [cells, oldValues];
+    }
+    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;
+    }
+}
+exports.GridModel = GridModel;
+//# sourceMappingURL=gridModel.js.map