@revolist/revogrid 4.0.2-next → 4.0.2

package/dist/collection/components/data/revogr-data.js

@@ -1,313 +1,638 @@
-import { Component, Element, Event, Prop, h } from '@stencil/core';
-import { Watch } from '@stencil/core/internal';
-import ColumnService from './columnService';
-import { DATA_COL, DATA_ROW } from '../../utils/consts';
-import { getSourceItem } from '../../store/dataSource/data.store';
-import CellRenderer from './cellRenderer';
-import RowRenderer, { PADDING_DEPTH } from './rowRenderer';
-import GroupingRowRenderer from '../../plugins/groupingRow/grouping.row.renderer';
-import { isGrouping } from '../../plugins/groupingRow/grouping.service';
-const DRAG_START_EVENT = 'dragStartCell';
+/*!
+ * Built by Revolist OU ❤️
+ */
+import { Host, h, } from "@stencil/core";
+import ColumnService from "./column.service";
+import { DATA_COL, DATA_ROW, ROW_FOCUSED_CLASS, } from "../../utils/consts";
+import { getSourceItem } from "../../store/dataSource/data.store";
+import RowRenderer, { PADDING_DEPTH } from "./row-renderer";
+import GroupingRowRenderer from "../../plugins/groupingRow/grouping.row.renderer";
+import { isGrouping } from "../../plugins/groupingRow/grouping.service";
+import { RowHighlightPlugin } from "./row-highlight.plugin";
+import { convertVNodeToHTML } from "../vnode/vnode.utils";
+import { CellRenderer } from "./cell-renderer";
+/**
+ * This component is responsible for rendering data
+ * Rows, columns, groups and cells
+ */
 export class RevogrData {
-  onStoreChange() {
-    var _a;
-    (_a = this.columnService) === null || _a === void 0 ? void 0 : _a.destroy();
-    this.columnService = new ColumnService(this.dataStore, this.colData);
-  }
-  connectedCallback() {
-    this.onStoreChange();
-  }
-  disconnectedCallback() {
-    var _a;
-    (_a = this.columnService) === null || _a === void 0 ? void 0 : _a.destroy();
-  }
-  render() {
-    var _a;
-    const rows = this.viewportRow.get('items');
-    const cols = this.viewportCol.get('items');
-    if (!this.columnService.columns.length || !rows.length || !cols.length) {
-      return '';
+    constructor() {
+        /**
+         * Rendered rows - virtual index vs vnode
+         */
+        this.renderedRows = new Map();
+        this.readonly = undefined;
+        this.range = undefined;
+        this.rowClass = undefined;
+        this.additionalData = undefined;
+        this.rowSelectionStore = undefined;
+        this.viewportRow = undefined;
+        this.viewportCol = undefined;
+        this.dimensionRow = undefined;
+        this.colData = undefined;
+        this.dataStore = undefined;
+        this.type = undefined;
+        this.colType = undefined;
+        this.jobsBeforeRender = [];
+        this.providers = undefined;
     }
-    const range = (_a = this.rowSelectionStore) === null || _a === void 0 ? void 0 : _a.get('range');
-    const rowsEls = [];
-    const depth = this.dataStore.get('groupingDepth');
-    for (let rgRow of rows) {
-      const dataRow = getSourceItem(this.dataStore, rgRow.itemIndex);
-      /** grouping */
-      if (isGrouping(dataRow)) {
-        rowsEls.push(h(GroupingRowRenderer, Object.assign({}, rgRow, { model: dataRow, hasExpand: this.columnService.hasGrouping })));
-        continue;
-      }
-      /** grouping end */
-      const cells = [];
-      let rowClass = this.rowClass ? this.columnService.getRowClass(rgRow.itemIndex, this.rowClass) : '';
-      if (range && rgRow.itemIndex >= range.y && rgRow.itemIndex <= range.y1) {
-        rowClass += ' focused-rgRow';
-      }
-      for (let rgCol of cols) {
-        cells.push(this.getCellRenderer(rgRow, rgCol, /** grouping apply*/ this.columnService.hasGrouping ? depth : 0));
-      }
-      rowsEls.push(h(RowRenderer, { rowClass: rowClass, size: rgRow.size, start: rgRow.start }, cells));
+    /**
+     * Pointed cell update.
+     */
+    async updateCell(e) {
+        var _a, _b, _c;
+        // Stencil tweak to update cell content
+        const cell = (_b = (_a = this.renderedRows.get(e.row)) === null || _a === void 0 ? void 0 : _a.$children$) === null || _b === void 0 ? void 0 : _b[e.col];
+        if ((_c = cell === null || cell === void 0 ? void 0 : cell.$attrs$) === null || _c === void 0 ? void 0 : _c.redraw) {
+            const children = await convertVNodeToHTML(this.element, cell.$attrs$.redraw);
+            cell.$elm$.innerHTML = children.html;
+            cell.$key$ = Math.random();
+        }
     }
-    return rowsEls;
-  }
-  getCellRenderer(rgRow, rgCol, depth = 0) {
-    const model = this.columnService.rowDataModel(rgRow.itemIndex, rgCol.itemIndex);
-    const defaultProps = {
-      [DATA_COL]: rgCol.itemIndex,
-      [DATA_ROW]: rgRow.itemIndex,
-      style: {
-        width: `${rgCol.size}px`,
-        transform: `translateX(${rgCol.start}px)`,
-      },
-    };
-    if (depth && !rgCol.itemIndex) {
-      defaultProps.style.paddingLeft = `${PADDING_DEPTH * depth}px`;
+    onDataStoreChange() {
+        this.onStoreChange();
     }
-    const props = this.columnService.mergeProperties(rgRow.itemIndex, rgCol.itemIndex, defaultProps);
-    const custom = this.columnService.customRenderer(rgRow.itemIndex, rgCol.itemIndex, model, this.providers);
-    // if custom render
-    if (typeof custom !== 'undefined') {
-      return h("div", Object.assign({}, props), custom);
+    onColDataChange() {
+        this.onStoreChange();
     }
-    // something is wrong with data
-    if (!model.column) {
-      console.error('Investigate column problem');
-      return;
+    onStoreChange() {
+        var _a, _b;
+        (_a = this.columnService) === null || _a === void 0 ? void 0 : _a.destroy();
+        this.columnService = new ColumnService(this.dataStore, this.colData);
+        // make sure we have correct data, before render
+        this.providers = {
+            type: this.type,
+            readonly: this.readonly,
+            data: this.dataStore,
+            viewport: this.viewportCol,
+            dimension: this.dimensionRow,
+            selection: this.rowSelectionStore,
+        };
+        (_b = this.rangeUnsubscribe) === null || _b === void 0 ? void 0 : _b.call(this);
+        this.rangeUnsubscribe = this.rowSelectionStore.onChange('range', (e) => this.rowHighlightPlugin.selectionChange(e, this.renderedRows));
     }
-    // if regular render
-    return (h("div", Object.assign({}, props),
-      h(CellRenderer, { model: model, onDragStart: e => this.dragStartCell.emit(e) })));
-  }
-  get providers() {
-    return {
-      viewport: this.viewportCol,
-      dimension: this.dimensionRow,
-      selection: this.rowSelectionStore
-    };
-  }
-  static get is() { return "revogr-data"; }
-  static get originalStyleUrls() { return {
-    "$": ["revogr-data-style.scss"]
-  }; }
-  static get styleUrls() { return {
-    "$": ["revogr-data-style.css"]
-  }; }
-  static get properties() { return {
-    "readonly": {
-      "type": "boolean",
-      "mutable": false,
-      "complexType": {
-        "original": "boolean",
-        "resolved": "boolean",
-        "references": {}
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "attribute": "readonly",
-      "reflect": false
-    },
-    "range": {
-      "type": "boolean",
-      "mutable": false,
-      "complexType": {
-        "original": "boolean",
-        "resolved": "boolean",
-        "references": {}
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "attribute": "range",
-      "reflect": false
-    },
-    "rowClass": {
-      "type": "string",
-      "mutable": false,
-      "complexType": {
-        "original": "string",
-        "resolved": "string",
-        "references": {}
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "attribute": "row-class",
-      "reflect": false
-    },
-    "rowSelectionStore": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "Observable<Selection.SelectionStoreState>",
-        "resolved": "ObservableMap<SelectionStoreState>",
-        "references": {
-          "Observable": {
-            "location": "import",
-            "path": "../../interfaces"
-          },
-          "Selection": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
-        }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      }
-    },
-    "viewportRow": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "Observable<RevoGrid.ViewportState>",
-        "resolved": "ObservableMap<ViewportState>",
-        "references": {
-          "Observable": {
-            "location": "import",
-            "path": "../../interfaces"
-          },
-          "RevoGrid": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
-        }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      }
-    },
-    "viewportCol": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "Observable<RevoGrid.ViewportState>",
-        "resolved": "ObservableMap<ViewportState>",
-        "references": {
-          "Observable": {
-            "location": "import",
-            "path": "../../interfaces"
-          },
-          "RevoGrid": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+    connectedCallback() {
+        this.rowHighlightPlugin = new RowHighlightPlugin();
+        this.onStoreChange();
+    }
+    disconnectedCallback() {
+        var _a, _b;
+        (_a = this.columnService) === null || _a === void 0 ? void 0 : _a.destroy();
+        (_b = this.rangeUnsubscribe) === null || _b === void 0 ? void 0 : _b.call(this);
+    }
+    async componentWillRender() {
+        return Promise.all(this.jobsBeforeRender);
+    }
+    componentDidRender() {
+        this.afterrender.emit({ type: this.type });
+    }
+    render() {
+        var _a, _b;
+        this.renderedRows = new Map();
+        const columnsData = this.columnService.columns;
+        if (!columnsData.length) {
+            return;
         }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      }
-    },
-    "dimensionRow": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "Observable<RevoGrid.DimensionSettingsState>",
-        "resolved": "ObservableMap<DimensionSettingsState>",
-        "references": {
-          "Observable": {
-            "location": "import",
-            "path": "../../interfaces"
-          },
-          "RevoGrid": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+        const rows = this.viewportRow.get('items');
+        if (!rows.length) {
+            return;
         }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      }
-    },
-    "colData": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "ColumnSource",
-        "resolved": "ObservableMap<DataSourceState<ColumnRegular, DimensionCols>>",
-        "references": {
-          "ColumnSource": {
-            "location": "import",
-            "path": "./columnService"
-          }
+        const cols = this.viewportCol.get('items');
+        if (!cols.length) {
+            return;
         }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": "Static stores, not expected to change during component lifetime"
-      }
-    },
-    "dataStore": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "RowSource",
-        "resolved": "ObservableMap<DataSourceState<DataType, DimensionRows>>",
-        "references": {
-          "RowSource": {
-            "location": "import",
-            "path": "./columnService"
-          }
+        const rowsEls = [];
+        const depth = this.dataStore.get('groupingDepth');
+        const groupingCustomRenderer = this.dataStore.get('groupingCustomRenderer');
+        const groupDepth = this.columnService.hasGrouping ? depth : 0;
+        for (let rgRow of rows) {
+            const dataItem = getSourceItem(this.dataStore, rgRow.itemIndex);
+            // #region Grouping
+            if (isGrouping(dataItem)) {
+                rowsEls.push(h(GroupingRowRenderer, Object.assign({}, rgRow, { index: rgRow.itemIndex, model: dataItem, groupingCustomRenderer: groupingCustomRenderer, hasExpand: this.columnService.hasGrouping })));
+                continue;
+            }
+            // #endregion
+            const cells = [];
+            // #region Cells
+            for (let rgCol of cols) {
+                const model = this.columnService.rowDataModel(rgRow.itemIndex, rgCol.itemIndex);
+                // call before cell render
+                const cellEvent = this.triggerBeforeCellRender(model, rgRow, rgCol);
+                // if event was prevented
+                if (cellEvent.defaultPrevented) {
+                    continue;
+                }
+                const { detail: { column: columnProps, row: rowProps }, } = cellEvent;
+                const defaultProps = {
+                    [DATA_COL]: columnProps.itemIndex,
+                    [DATA_ROW]: rowProps.itemIndex,
+                    style: {
+                        width: `${columnProps.size}px`,
+                        transform: `translateX(${columnProps.start}px)`,
+                        height: rowProps.size ? `${rowProps.size}px` : undefined,
+                    },
+                };
+                /**
+                 * For grouping, can be removed in the future and replaced with event
+                 */
+                if (groupDepth && !columnProps.itemIndex) {
+                    defaultProps.style.paddingLeft = `${PADDING_DEPTH * groupDepth}px`;
+                }
+                const props = this.columnService.mergeProperties(rowProps.itemIndex, columnProps.itemIndex, defaultProps, model, (_a = columnsData[columnProps.itemIndex]) === null || _a === void 0 ? void 0 : _a.cellProperties);
+                // Never use webcomponent for cell render
+                // It's very slow because of webcomponent initialization takes time
+                cells.push(h(CellRenderer, { renderProps: {
+                        model,
+                        providers: this.providers,
+                        template: (_b = columnsData[columnProps.itemIndex]) === null || _b === void 0 ? void 0 : _b.cellTemplate,
+                        additionalData: this.additionalData,
+                        dragStartCell: this.dragStartCell,
+                    }, cellProps: props }));
+            }
+            // #endregion
+            // #region Rows
+            let rowClass = this.rowClass
+                ? this.columnService.getRowClass(rgRow.itemIndex, this.rowClass)
+                : '';
+            if (this.rowHighlightPlugin.isRowFocused(rgRow.itemIndex)) {
+                rowClass += ` ${ROW_FOCUSED_CLASS}`;
+            }
+            const row = (h(RowRenderer, { index: rgRow.itemIndex, rowClass: rowClass, size: rgRow.size, start: rgRow.start }, cells));
+            this.beforerowrender.emit({
+                node: row,
+                item: rgRow,
+                dataItem,
+                colType: this.columnService.type,
+                rowType: this.type,
+            });
+            rowsEls.push(row);
+            this.renderedRows.set(rgRow.itemIndex, row);
+            // #endregion
         }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      }
+        return (h(Host, null, h("slot", null), rowsEls));
+    }
+    triggerBeforeCellRender(model, row, column) {
+        return this.beforeCellRender.emit({
+            column: Object.assign({}, column),
+            row: Object.assign({}, row),
+            model,
+            rowType: model.type,
+            colType: model.colType,
+        });
+    }
+    static get is() { return "revogr-data"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["revogr-data-style.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["revogr-data-style.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "readonly": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Readonly mode"
+                },
+                "attribute": "readonly",
+                "reflect": false
+            },
+            "range": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Range allowed"
+                },
+                "attribute": "range",
+                "reflect": false
+            },
+            "rowClass": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Defines property from which to read row class"
+                },
+                "attribute": "row-class",
+                "reflect": false
+            },
+            "additionalData": {
+                "type": "any",
+                "mutable": false,
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Additional data to pass to renderer\nUsed in plugins such as vue or react to pass root app entity to cells"
+                },
+                "attribute": "additional-data",
+                "reflect": false
+            },
+            "rowSelectionStore": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<SelectionStoreState>",
+                    "resolved": "ObservableMap<SelectionStoreState>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::Observable"
+                        },
+                        "SelectionStoreState": {
+                            "location": "import",
+                            "path": "../../types/selection",
+                            "id": "src/types/selection.ts::SelectionStoreState"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Selection, range, focus for row selection"
+                }
+            },
+            "viewportRow": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<ViewportState>",
+                    "resolved": "ObservableMap<ViewportState>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::Observable"
+                        },
+                        "ViewportState": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::ViewportState"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Viewport Y"
+                }
+            },
+            "viewportCol": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<ViewportState>",
+                    "resolved": "ObservableMap<ViewportState>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::Observable"
+                        },
+                        "ViewportState": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::ViewportState"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Viewport X"
+                }
+            },
+            "dimensionRow": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<DimensionSettingsState>",
+                    "resolved": "ObservableMap<DimensionSettingsState>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::Observable"
+                        },
+                        "DimensionSettingsState": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::DimensionSettingsState"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Dimension settings Y"
+                }
+            },
+            "colData": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<DSourceState<ColumnRegular, DimensionCols>>",
+                    "resolved": "ObservableMap<DSourceState<ColumnRegular, DimensionCols>>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::Observable"
+                        },
+                        "DSourceState": {
+                            "location": "import",
+                            "path": "../../store/dataSource/data.store",
+                            "id": "src/store/dataSource/data.store.ts::DSourceState"
+                        },
+                        "ColumnRegular": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::ColumnRegular"
+                        },
+                        "DimensionCols": {
+                            "location": "import",
+                            "path": "../../types/dimension",
+                            "id": "src/types/dimension.ts::DimensionCols"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Column source"
+                }
+            },
+            "dataStore": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<DSourceState<DataType, DimensionRows>>",
+                    "resolved": "ObservableMap<DSourceState<DataType, DimensionRows>>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::Observable"
+                        },
+                        "DSourceState": {
+                            "location": "import",
+                            "path": "../../store/dataSource/data.store",
+                            "id": "src/store/dataSource/data.store.ts::DSourceState"
+                        },
+                        "DataType": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::DataType"
+                        },
+                        "DimensionRows": {
+                            "location": "import",
+                            "path": "../../types/dimension",
+                            "id": "src/types/dimension.ts::DimensionRows"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Data rows source"
+                }
+            },
+            "type": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "DimensionRows",
+                    "resolved": "\"rgRow\" | \"rowPinEnd\" | \"rowPinStart\"",
+                    "references": {
+                        "DimensionRows": {
+                            "location": "import",
+                            "path": "../../types/dimension",
+                            "id": "src/types/dimension.ts::DimensionRows"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Row data type"
+                },
+                "attribute": "type",
+                "reflect": true
+            },
+            "colType": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "DimensionCols | 'rowHeaders'",
+                    "resolved": "\"colPinEnd\" | \"colPinStart\" | \"rgCol\" | \"rowHeaders\"",
+                    "references": {
+                        "DimensionCols": {
+                            "location": "import",
+                            "path": "../../types/dimension",
+                            "id": "src/types/dimension.ts::DimensionCols"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Column data type"
+                },
+                "attribute": "col-type",
+                "reflect": true
+            },
+            "jobsBeforeRender": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Promise<any>[]",
+                    "resolved": "Promise<any>[]",
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Prevent rendering until job is done.\nCan be used for initial rendering performance improvement.\nWhen several plugins require initial rendering this will prevent double initial rendering."
+                },
+                "defaultValue": "[]"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "providers": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "beforerowrender",
+                "name": "beforerowrender",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before each row render"
+                },
+                "complexType": {
+                    "original": "BeforeRowRenderEvent",
+                    "resolved": "BeforeRowRenderEvent<any>",
+                    "references": {
+                        "BeforeRowRenderEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::BeforeRowRenderEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "afterrender",
+                "name": "afterrender",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "When data render finished for the designated type"
+                },
+                "complexType": {
+                    "original": "{ type: DimensionRows }",
+                    "resolved": "{ type: DimensionRows; }",
+                    "references": {
+                        "DimensionRows": {
+                            "location": "import",
+                            "path": "../../types/dimension",
+                            "id": "src/types/dimension.ts::DimensionRows"
+                        }
+                    }
+                }
+            }, {
+                "method": "beforeCellRender",
+                "name": "beforecellrender",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before each cell render function. Allows to override cell properties"
+                },
+                "complexType": {
+                    "original": "BeforeCellRenderEvent",
+                    "resolved": "BeforeCellRenderEvent<any>",
+                    "references": {
+                        "BeforeCellRenderEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::BeforeCellRenderEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "dragStartCell",
+                "name": "dragstartcell",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Event emitted on cell drag start"
+                },
+                "complexType": {
+                    "original": "DragStartEvent",
+                    "resolved": "{ originalEvent: MouseEvent; model: ColumnDataSchemaModel; }",
+                    "references": {
+                        "DragStartEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::DragStartEvent"
+                        }
+                    }
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "updateCell": {
+                "complexType": {
+                    "signature": "(e: { row: number; col: number; }) => Promise<void>",
+                    "parameters": [{
+                            "name": "e",
+                            "type": "{ row: number; col: number; }",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Pointed cell update.",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "element"; }
+    static get watchers() {
+        return [{
+                "propName": "dataStore",
+                "methodName": "onDataStoreChange"
+            }, {
+                "propName": "colData",
+                "methodName": "onColDataChange"
+            }];
     }
-  }; }
-  static get events() { return [{
-      "method": "dragStartCell",
-      "name": "dragStartCell",
-      "bubbles": true,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "complexType": {
-        "original": "MouseEvent",
-        "resolved": "MouseEvent",
-        "references": {
-          "MouseEvent": {
-            "location": "global"
-          }
-        }
-      }
-    }]; }
-  static get elementRef() { return "element"; }
-  static get watchers() { return [{
-      "propName": "dataStore",
-      "methodName": "onStoreChange"
-    }, {
-      "propName": "colData",
-      "methodName": "onStoreChange"
-    }]; }
 }
+//# sourceMappingURL=revogr-data.js.map