balala-revogrid 1.0.0

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

@@ -0,0 +1,939 @@
+/*!
+ * 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/index";
+import RowRenderer from "./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 {
+    constructor() {
+        /**
+         * Prevent rendering until job is done.
+         * Can be used for initial rendering performance improvement.
+         * When several plugins require initial rendering this will prevent double initial rendering.
+         */
+        this.jobsBeforeRender = [];
+        /**
+         * Rendered rows - virtual index vs vnode
+         */
+        this.renderedRows = new Map();
+        this.lastMismatchKey = null;
+        this.lastStableRows = [];
+        this.lastStableCols = [];
+        this.lastStableColumns = [];
+        this.lastRenderStateKey = null;
+    }
+    /**
+     * 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();
+        }
+    }
+    onDataStoreChange() {
+        this.onStoreChange();
+    }
+    onColDataChange() {
+        this.onStoreChange();
+    }
+    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,
+            colType: this.colType,
+            readonly: this.readonly,
+            data: this.dataStore,
+            columns: this.colData,
+            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));
+    }
+    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() {
+        var _a;
+        this.beforeDataRender.emit({
+            rowType: this.type,
+            colType: this.colType,
+        });
+        const grid = (_a = this.element) === null || _a === void 0 ? void 0 : _a.closest('revo-grid');
+        const waitForColumnsUpdate = () => {
+            if (!grid)
+                return null;
+            if (!grid.hasAttribute('data-columns-updating'))
+                return null;
+            // console.log('[data] wait columns update', {
+            //   colType: this.colType,
+            //   time: performance.now(),
+            // });
+            return new Promise(resolve => {
+                grid.addEventListener('columnsupdateend', () => {
+                    // console.log('[data] columns update end', {
+                    //   colType: this.colType,
+                    //   time: performance.now(),
+                    // });
+                    resolve();
+                }, { once: true });
+            });
+        };
+        const waitForDataUpdate = () => {
+            if (!grid)
+                return null;
+            if (!grid.hasAttribute('data-rows-updating'))
+                return null;
+            // console.log('[data] wait rows update', {
+            //   colType: this.colType,
+            //   time: performance.now(),
+            // });
+            return new Promise(resolve => {
+                grid.addEventListener('dataupdateend', () => {
+                    // console.log('[data] rows update end', {
+                    //   colType: this.colType,
+                    //   time: performance.now(),
+                    // });
+                    resolve();
+                }, { once: true });
+            });
+        };
+        const pending = [waitForColumnsUpdate(), waitForDataUpdate(), ...this.jobsBeforeRender.map(p => typeof p === 'function' ? p() : p)].filter(Boolean);
+        return Promise.all(pending);
+    }
+    componentDidRender() {
+        this.afterrender.emit({ type: this.type, colType: this.colType });
+    }
+    render() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        this.renderedRows = new Map();
+        // always start from live columns, override only when fallback is needed
+        this.columnService.setOverrideColumns(null);
+        const colVersion = (_a = this.colData) === null || _a === void 0 ? void 0 : _a.get('version');
+        const viewportVersion = (_b = this.viewportCol) === null || _b === void 0 ? void 0 : _b.get('version');
+        const isSynced = colVersion === undefined ||
+            viewportVersion === undefined ||
+            colVersion === viewportVersion;
+        const columnsData = this.columnService.columns;
+        const rows = this.viewportRow.get('items');
+        const cols = this.viewportCol.get('items');
+        const hasInvalidColIndex = cols.some(col => !columnsData[col.itemIndex]);
+        if (hasInvalidColIndex) {
+            const colSource = ((_c = this.colData) === null || _c === void 0 ? void 0 : _c.get('source')) || [];
+            const colItems = ((_d = this.colData) === null || _d === void 0 ? void 0 : _d.get('items')) || [];
+            const missingIndexes = cols
+                .filter(col => !columnsData[col.itemIndex])
+                .map(col => col.itemIndex);
+            const mismatchKey = JSON.stringify({
+                colType: this.colType,
+                missing: missingIndexes.slice(0, 10),
+                cols: cols.length,
+                columnsData: columnsData.length,
+                colItems: colItems.length,
+                colSource: colSource.length,
+            });
+            if (mismatchKey !== this.lastMismatchKey) {
+                this.lastMismatchKey = mismatchKey;
+                console.warn('[data] column index mismatch', {
+                    colType: this.colType,
+                    type: this.type,
+                    missingIndexes: missingIndexes.slice(0, 10),
+                    colsLength: cols.length,
+                    columnsDataLength: columnsData.length,
+                    colItemsLength: colItems.length,
+                    colSourceLength: colSource.length,
+                    colItemsHead: colItems.slice(0, 10),
+                    colPropsHead: columnsData
+                        .slice(0, 10)
+                        .map(col => col === null || col === void 0 ? void 0 : col.prop),
+                    viewportItemsHead: cols.slice(0, 10).map(col => col.itemIndex),
+                });
+            }
+        }
+        const hasColumns = columnsData.length > 0;
+        const hasCols = cols.length > 0;
+        const isEmptyColumns = !hasColumns && !hasCols;
+        const gridElement = (_e = this.element) === null || _e === void 0 ? void 0 : _e.closest('revo-grid');
+        const isUpdating = !!(gridElement === null || gridElement === void 0 ? void 0 : gridElement.hasAttribute('data-columns-updating')) ||
+            !!(gridElement === null || gridElement === void 0 ? void 0 : gridElement.hasAttribute('data-rows-updating'));
+        // 主区域在更新中不允许空列，避免取消冻结时主视口短暂清空导致闪烁
+        const allowEmptyColumns = this.colType !== 'rgCol' || !isUpdating;
+        const canUseCurrent = isSynced &&
+            rows.length > 0 &&
+            ((hasColumns && hasCols) || (isEmptyColumns && allowEmptyColumns)) &&
+            !hasInvalidColIndex;
+        const usingFallback = !canUseCurrent;
+        if (this.colType === 'rgCol' && this.type === 'rgRow' && (isUpdating || usingFallback || hasInvalidColIndex)) {
+            const renderStateKey = JSON.stringify({
+                isUpdating,
+                isSynced,
+                colVersion,
+                viewportVersion,
+                rows: rows.length,
+                cols: cols.length,
+                columns: columnsData.length,
+                hasInvalidColIndex,
+                usingFallback,
+                rowRealCount: this.viewportRow.get('realCount'),
+                rowVirtualSize: this.viewportRow.get('virtualSize'),
+                rowClientSize: this.viewportRow.get('clientSize'),
+            });
+            if (renderStateKey !== this.lastRenderStateKey) {
+                this.lastRenderStateKey = renderStateKey;
+                // console.log('[data] render state', {
+                //   colType: this.colType,
+                //   rowType: this.type,
+                //   isUpdating,
+                //   isSynced,
+                //   colVersion,
+                //   viewportVersion,
+                //   rowsLength: rows.length,
+                //   colsLength: cols.length,
+                //   columnsLength: columnsData.length,
+                //   hasInvalidColIndex,
+                //   usingFallback,
+                //   rowRealCount: this.viewportRow.get('realCount'),
+                //   rowVirtualSize: this.viewportRow.get('virtualSize'),
+                //   rowClientSize: this.viewportRow.get('clientSize'),
+                // });
+            }
+        }
+        const activeColumns = canUseCurrent ? columnsData : this.lastStableColumns;
+        const activeRows = canUseCurrent ? rows : this.lastStableRows;
+        const activeCols = canUseCurrent ? cols : this.lastStableCols;
+        if (canUseCurrent) {
+            this.lastStableColumns = [...columnsData];
+            this.lastStableRows = [...rows];
+            this.lastStableCols = [...cols];
+        }
+        if (!canUseCurrent && activeColumns.length) {
+            this.columnService.setOverrideColumns(activeColumns);
+        }
+        if (!activeColumns.length || !activeRows.length || !activeCols.length) {
+            return;
+        }
+        const rowsEls = [];
+        for (let rgRow of activeRows) {
+            const dataItem = getSourceItem(this.dataStore, rgRow.itemIndex);
+            // #region Grouping
+            // Render empty grouping rows (for borders) - content is in the overlay
+            if (isGrouping(dataItem)) {
+                const emptyRow = (h(RowRenderer, { index: rgRow.itemIndex, rowClass: "groupingRow", size: rgRow.size, start: rgRow.start }));
+                this.beforerowrender.emit({
+                    node: emptyRow,
+                    item: rgRow,
+                    model: dataItem,
+                    colType: this.columnService.type,
+                    rowType: this.type,
+                });
+                rowsEls.push(emptyRow);
+                this.renderedRows.set(rgRow.itemIndex, emptyRow);
+                continue;
+            }
+            // #endregion
+            const cells = [];
+            // #region Cells
+            // 判断是否需要给最后一列添加类名
+            const lastColIndex = activeCols.length > 0 ? activeCols[activeCols.length - 1].itemIndex : -1;
+            // 使用传入的 hasColPinEnd prop，如果没有传入则默认为 false
+            const hasColPinEnd = (_f = this.hasColPinEnd) !== null && _f !== void 0 ? _f : false;
+            const hasRgCol = (_g = this.hasRgCol) !== null && _g !== void 0 ? _g : false;
+            for (let rgCol of activeCols) {
+                const smodel = Object.assign(Object.assign({}, this.columnService.rowDataModel(rgRow.itemIndex, rgCol.itemIndex)), { providers: this.providers });
+                // call before cell render
+                const cellEvent = this.triggerBeforeCellRender(smodel, rgRow, rgCol);
+                // if event was prevented
+                if (cellEvent.defaultPrevented) {
+                    continue;
+                }
+                const { detail: { column: columnProps, row: rowProps, model: schemaModel }, } = 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,
+                    },
+                };
+                // 判断是否是最后一列并添加类名
+                const isLastColumn = rgCol.itemIndex === lastColIndex;
+                if (isLastColumn) {
+                    // 只在以下情况添加类名：
+                    // 1. 有右侧冻结列时，只给 colPinEnd 类型的最后一列加
+                    // 2. 没有右侧冻结列但有主区域时，只给 rgCol 类型的最后一列加
+                    // 3. 没有右侧冻结列也没有主区域时（全左冻结），给 colPinStart 类型的最后一列加
+                    const shouldAddClass = (hasColPinEnd && this.colType === 'colPinEnd') ||
+                        (!hasColPinEnd && hasRgCol && this.colType === 'rgCol') ||
+                        (!hasColPinEnd && !hasRgCol && this.colType === 'colPinStart');
+                    if (shouldAddClass) {
+                        defaultProps.class = { 'last-column': true };
+                    }
+                }
+                const props = this.columnService.mergeProperties(rowProps.itemIndex, columnProps.itemIndex, defaultProps, schemaModel);
+                // Never use webcomponent for cell render
+                // It's very slow because of webcomponent initialization takes time
+                const cellNode = h(CellRenderer, { renderProps: {
+                        schemaModel,
+                        additionalData: this.additionalData,
+                        dragStartCell: this.dragStartCell,
+                    }, cellProps: props });
+                cells.push(cellNode);
+            }
+            // #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,
+                model: dataItem,
+                colType: this.columnService.type,
+                rowType: this.type,
+            });
+            rowsEls.push(row);
+            this.renderedRows.set(rgRow.itemIndex, row);
+            // #endregion
+        }
+        const hostAttrs = {};
+        if (this.uniqueId !== undefined) {
+            hostAttrs['data-unique-id'] = this.uniqueId;
+        }
+        const renderVNode = (h(Host, Object.assign({}, hostAttrs), h("slot", null), rowsEls));
+        return renderVNode;
+    }
+    triggerBeforeCellRender(model, row, column) {
+        const detail = {
+            column,
+            row,
+            model,
+            rowType: model.type,
+            colType: model.colType,
+        };
+        return this.beforeCellRender.emit(detail);
+    }
+    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",
+                "attribute": "readonly",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Readonly mode"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            },
+            "range": {
+                "type": "boolean",
+                "attribute": "range",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Range allowed"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            },
+            "rowClass": {
+                "type": "string",
+                "attribute": "row-class",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Defines property from which to read row class"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            },
+            "additionalData": {
+                "type": "any",
+                "attribute": "additional-data",
+                "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"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            },
+            "paddingDepth": {
+                "type": "number",
+                "attribute": "padding-depth",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Padding depth for grouping rows (in pixels per depth level)"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            },
+            "rowSelectionStore": {
+                "type": "unknown",
+                "attribute": "row-selection-store",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<SelectionStoreState>",
+                    "resolved": "ObservableMap<SelectionStoreState>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../utils",
+                            "id": "src/utils/index.ts::Observable"
+                        },
+                        "SelectionStoreState": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::SelectionStoreState"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Selection, range, focus for row selection"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "viewportRow": {
+                "type": "unknown",
+                "attribute": "viewport-row",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<ViewportState>",
+                    "resolved": "ObservableMap<ViewportState>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../utils",
+                            "id": "src/utils/index.ts::Observable"
+                        },
+                        "ViewportState": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::ViewportState"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Viewport Y"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "viewportCol": {
+                "type": "unknown",
+                "attribute": "viewport-col",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<ViewportState>",
+                    "resolved": "ObservableMap<ViewportState>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../utils",
+                            "id": "src/utils/index.ts::Observable"
+                        },
+                        "ViewportState": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::ViewportState"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Viewport X"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "dimensionRow": {
+                "type": "unknown",
+                "attribute": "dimension-row",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<DimensionSettingsState>",
+                    "resolved": "ObservableMap<DimensionSettingsState>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../utils",
+                            "id": "src/utils/index.ts::Observable"
+                        },
+                        "DimensionSettingsState": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::DimensionSettingsState"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Dimension settings Y"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "colData": {
+                "type": "unknown",
+                "attribute": "col-data",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<DSourceState<ColumnRegular, DimensionCols>>",
+                    "resolved": "ObservableMap<DSourceState<ColumnRegular, DimensionCols>>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../utils",
+                            "id": "src/utils/index.ts::Observable"
+                        },
+                        "DSourceState": {
+                            "location": "import",
+                            "path": "@store",
+                            "id": "src/store/index.ts::DSourceState"
+                        },
+                        "ColumnRegular": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::ColumnRegular"
+                        },
+                        "DimensionCols": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::DimensionCols"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Column source"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "dataStore": {
+                "type": "unknown",
+                "attribute": "data-store",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<DSourceState<DataType, DimensionRows>>",
+                    "resolved": "ObservableMap<DSourceState<DataType, DimensionRows>>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../utils",
+                            "id": "src/utils/index.ts::Observable"
+                        },
+                        "DSourceState": {
+                            "location": "import",
+                            "path": "@store",
+                            "id": "src/store/index.ts::DSourceState"
+                        },
+                        "DataType": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::DataType"
+                        },
+                        "DimensionRows": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::DimensionRows"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Data rows source"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "type": {
+                "type": "string",
+                "attribute": "type",
+                "mutable": false,
+                "complexType": {
+                    "original": "DimensionRows",
+                    "resolved": "\"rgRow\" | \"rowPinEnd\" | \"rowPinStart\"",
+                    "references": {
+                        "DimensionRows": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::DimensionRows"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Row data type"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true
+            },
+            "colType": {
+                "type": "string",
+                "attribute": "col-type",
+                "mutable": false,
+                "complexType": {
+                    "original": "DimensionCols | 'rowHeaders'",
+                    "resolved": "\"colPinEnd\" | \"colPinStart\" | \"rgCol\" | \"rowHeaders\"",
+                    "references": {
+                        "DimensionCols": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::DimensionCols"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Column data type"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true
+            },
+            "jobsBeforeRender": {
+                "type": "unknown",
+                "attribute": "jobs-before-render",
+                "mutable": false,
+                "complexType": {
+                    "original": "(Promise<any> | (() => Promise<any>))[]",
+                    "resolved": "(Promise<any> | (() => 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."
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "[]"
+            },
+            "uniqueId": {
+                "type": "any",
+                "attribute": "unique-id",
+                "mutable": false,
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Unique identifier for the data component\nUsed for tracking and debugging purposes"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            },
+            "hasColPinEnd": {
+                "type": "boolean",
+                "attribute": "has-col-pin-end",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Whether there are colPinEnd columns in the grid\nUsed to determine which column should get the last-column class"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            },
+            "hasRgCol": {
+                "type": "boolean",
+                "attribute": "has-rg-col",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Whether there are rgCol columns in the grid\nUsed to determine which column should get the last-column class"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            }
+        };
+    }
+    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": "@type",
+                            "id": "src/types/index.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; colType: DimensionCols | 'rowHeaders' }",
+                    "resolved": "{ type: DimensionRows; colType: DimensionCols | \"rowHeaders\"; }",
+                    "references": {
+                        "DimensionRows": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::DimensionRows"
+                        },
+                        "DimensionCols": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::DimensionCols"
+                        }
+                    }
+                }
+            }, {
+                "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<CellTemplateProp>",
+                    "resolved": "BeforeCellRenderEvent<CellTemplateProp>",
+                    "references": {
+                        "BeforeCellRenderEvent": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::BeforeCellRenderEvent"
+                        },
+                        "CellTemplateProp": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::CellTemplateProp"
+                        }
+                    }
+                }
+            }, {
+                "method": "beforeDataRender",
+                "name": "beforedatarender",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before data render"
+                },
+                "complexType": {
+                    "original": "AllDimensionType",
+                    "resolved": "AllDimensionType",
+                    "references": {
+                        "AllDimensionType": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.ts::AllDimensionType"
+                        }
+                    }
+                }
+            }, {
+                "method": "dragStartCell",
+                "name": "dragstartcell",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Event emitted on cell drag start"
+                },
+                "complexType": {
+                    "original": "DragStartEvent",
+                    "resolved": "DragStartEvent",
+                    "references": {
+                        "DragStartEvent": {
+                            "location": "import",
+                            "path": "@type",
+                            "id": "src/types/index.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"
+            }];
+    }
+}
+//# sourceMappingURL=revogr-data.js.map