@ozen-ui/data-grid 0.73.0

package/__inner__/cjs/core/selection/store/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./DataGridStoreSelection"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/core/selection/store/types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridStoreSelectionEvent = void 0;
+exports.dataGridStoreSelectionEvent = {
+    CHANGE: 'change',
+    CHANGE_IS_ENABLED: 'changeIsEnabled',
+    CHANGE_TYPE: 'changeType',
+};

package/__inner__/cjs/core/store/DataGridStore.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGridStore = void 0;
+var tslib_1 = require("tslib");
+var mobx_1 = require("mobx");
+var shared_1 = require("../../shared");
+var column_1 = require("../column");
+var columns_group_1 = require("../columns-group");
+var filter_1 = require("../filter");
+var modals_1 = require("../modals");
+var pagination_1 = require("../pagination");
+var selection_1 = require("../selection");
+var sub_row_1 = require("../sub-row");
+var DataGridStore = /** @class */ (function () {
+    function DataGridStore(table, data) {
+        var _this = this;
+        this.nodes = [];
+        this.data = [];
+        this.rawStatus = 'default';
+        this.eventBus = new shared_1.EventBus();
+        this.columnsInfo = table.columnsInfo;
+        this.subRows = new sub_row_1.DataGridStoreSubRows(table.subRowSettings, table.subRows, this);
+        table.nodes.forEach(function (column) {
+            if (column instanceof column_1.DataGridColumn) {
+                _this.addColumn(new column_1.DataGridStoreColumn(column, _this));
+                return;
+            }
+            if (column instanceof columns_group_1.DataGridColumnsGroup) {
+                _this.addGroup(new columns_group_1.DataGridStoreColumnsGroup(column, _this));
+            }
+        });
+        this.generateRowId = table.generateRowId;
+        this.pagination = new pagination_1.DataGridStorePagination(table.pagination, this);
+        this.modals = new modals_1.DataGridStoreModals(this);
+        this.selection = new selection_1.DataGridStoreSelection(table.selectionInfo, this);
+        this.filters = new filter_1.DataGridStoreFilters(table.filterInfo, this);
+        table.filters.forEach(function (filter) {
+            var createdFilter = (function () {
+                if (filter instanceof filter_1.DataGridAutocompleteTableFilter) {
+                    return new filter_1.DataGridStoreAutocompleteFilter(filter, _this);
+                }
+                if (filter instanceof filter_1.DataGridDateTableFilter) {
+                    return new filter_1.DataGridStoreDateFilter(filter, _this);
+                }
+                if (filter instanceof filter_1.DataGridSelectTableFilter) {
+                    return new filter_1.DataGridStoreSelectFilter(filter, _this);
+                }
+                if (filter instanceof filter_1.DataGridStringTableFilter) {
+                    return new filter_1.DataGridStoreStringFilter(filter, _this);
+                }
+                if (filter instanceof filter_1.DataGridNumberTableFilter) {
+                    return new filter_1.DataGridStoreNumberFilter(filter, _this);
+                }
+                if (filter instanceof filter_1.DataGridAutocompleteListCardTableFilter) {
+                    return new filter_1.DataGridStoreAutocompleteListCardFilter(filter, _this);
+                }
+                return null;
+            })();
+            if (!createdFilter) {
+                throw new Error("Failed to create filter based on filter with id \"".concat(filter.id, "\"."));
+            }
+            if (!createdFilter) {
+                return;
+            }
+            _this.filters.addFilter(createdFilter);
+            if (!filter.column) {
+                return;
+            }
+            var storeColumn = _this.findColumn(filter.column);
+            if (!storeColumn) {
+                return;
+            }
+            createdFilter.setColumn(storeColumn);
+        });
+        this.setData(data);
+        this.recalculate();
+        (0, mobx_1.makeAutoObservable)(this);
+        (0, mobx_1.reaction)(function () { return _this.status; }, function (status) {
+            _this.eventBus.publish('changeStatus', status);
+        });
+        this.filters.register();
+        this.columns.forEach(function (column) {
+            column.register();
+        });
+    }
+    DataGridStore.prototype.findColumn = function (tableColumn) {
+        var column = this.columnById[tableColumn.id];
+        if (!column) {
+            throw new Error("Column with id \"".concat(tableColumn.id, "\" not found."));
+        }
+        return column;
+    };
+    DataGridStore.prototype.findGroup = function (tableGroup) {
+        var group = this.groupById[tableGroup.id];
+        if (!group) {
+            throw new Error("Group with id \"".concat(tableGroup.id, "\" not found."));
+        }
+        return group;
+    };
+    DataGridStore.prototype.setVerticalAlign = function (align) {
+        this.columnsInfo.verticalAlign = align;
+    };
+    Object.defineProperty(DataGridStore.prototype, "groupById", {
+        get: function () {
+            var groupById = {};
+            var extractGroups = function (node) {
+                if (node instanceof column_1.DataGridStoreColumn) {
+                    return;
+                }
+                groupById[node.id] = node;
+                node.nodes.forEach(function (node) {
+                    extractGroups(node);
+                });
+            };
+            this.nodes.forEach(function (node) {
+                extractGroups(node);
+            });
+            return groupById;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStore.prototype, "columnById", {
+        get: function () {
+            var columnById = {};
+            this.allColumns.forEach(function (column) {
+                columnById[column.id] = column;
+            });
+            return columnById;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStore.prototype.recalculate = function () {
+        this.columns.forEach(function (column) {
+            column.recalculate();
+        });
+        this.eventBus.publish('recalculate', null);
+    };
+    Object.defineProperty(DataGridStore.prototype, "status", {
+        get: function () {
+            if (this.rawStatus === 'loading') {
+                return 'loading';
+            }
+            if (this.data.length === 0) {
+                return 'empty';
+            }
+            return 'default';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStore.prototype.setStatus = function (status) {
+        this.rawStatus = status;
+    };
+    Object.defineProperty(DataGridStore.prototype, "colSpan", {
+        get: function () {
+            var colSpan = this.columnsCount;
+            if (this.subRows.isEnabled) {
+                colSpan += 1;
+            }
+            if (this.selection.isEnabled) {
+                colSpan += 1;
+            }
+            return colSpan;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStore.prototype, "isLoading", {
+        get: function () {
+            return this.status === 'loading';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStore.prototype, "isPlaceholder", {
+        get: function () {
+            return this.isLoading || this.isEmpty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStore.prototype, "isDefault", {
+        get: function () {
+            return this.status === 'default';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStore.prototype, "isEmpty", {
+        get: function () {
+            return this.status === 'empty';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStore.prototype.setLoading = function () {
+        this.setStatus('loading');
+    };
+    DataGridStore.prototype.setDefault = function () {
+        this.setStatus('default');
+    };
+    Object.defineProperty(DataGridStore.prototype, "columnsCount", {
+        get: function () {
+            return this.columns.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStore.prototype, "allColumns", {
+        get: function () {
+            var columns = [];
+            this.nodes.forEach(function (node) {
+                if (node instanceof column_1.DataGridStoreColumn) {
+                    columns.push(node);
+                }
+                else if (node instanceof columns_group_1.DataGridStoreColumnsGroup) {
+                    node.columns.forEach(function (column) {
+                        columns.push(column);
+                    });
+                }
+            });
+            return columns;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStore.prototype, "columns", {
+        get: function () {
+            return this.allColumns.filter(function (column) { return column.isVisible; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStore.prototype, "visibleNodes", {
+        get: function () {
+            return this.nodes.filter(function (node) { return node.isVisible; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStore.prototype, "footerNodes", {
+        get: function () {
+            return this.getNodesByDepth(true).filter(function (nodes) {
+                return nodes.some(function (node) { return !!(node === null || node === void 0 ? void 0 : node.footer); });
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStore.prototype, "headerNodes", {
+        get: function () {
+            return this.getNodesByDepth(true).filter(function (nodes) {
+                return nodes.some(function (node) { return !!(node === null || node === void 0 ? void 0 : node.header); });
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStore.prototype.addColumn = function (column) {
+        this.nodes.push(column);
+        this.eventBus.publish('addColumn', column);
+        return column;
+    };
+    DataGridStore.prototype.addGroup = function (group) {
+        this.nodes.push(group);
+        this.eventBus.publish('addGroup', group);
+        return group;
+    };
+    DataGridStore.prototype.setData = function (data) {
+        this.data = data;
+        this.eventBus.publish('changeData', data);
+        this.subRows.collapseNotExistRows();
+    };
+    Object.defineProperty(DataGridStore.prototype, "dataById", {
+        get: function () {
+            var _this = this;
+            var dataById = {};
+            this.data.forEach(function (item) {
+                dataById[_this.generateRowId(item)] = item;
+            });
+            return dataById;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStore.prototype.getNodesByDepth = function (isVisibleOnly) {
+        var columns = isVisibleOnly ? this.columns : this.allColumns;
+        var groupsByDepth = [];
+        var processedGroups = new Set();
+        columns.forEach(function (column) {
+            var root = column.root;
+            if (!root) {
+                return;
+            }
+            var topRoot = root.topRoot;
+            if (processedGroups.has(topRoot)) {
+                return;
+            }
+            processedGroups.add(topRoot);
+            var groups = topRoot.getGroups(isVisibleOnly);
+            if (!groupsByDepth[topRoot.depth]) {
+                groupsByDepth[topRoot.depth] = [];
+            }
+            groupsByDepth[topRoot.depth].push(topRoot);
+            groups.forEach(function (groups) {
+                groups.forEach(function (group) {
+                    if (!groupsByDepth[group.depth]) {
+                        groupsByDepth[group.depth] = [];
+                    }
+                    groupsByDepth[group.depth].push(group);
+                });
+            });
+        });
+        var groupsArray = [];
+        Object.entries(groupsByDepth).forEach(function (_a) {
+            var _b = tslib_1.__read(_a, 2), _index = _b[0], groups = _b[1];
+            var index = Number(_index);
+            groupsArray[index] = tslib_1.__spreadArray([], tslib_1.__read(groups), false);
+        });
+        return tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(groupsArray), false), [columns], false);
+    };
+    return DataGridStore;
+}());
+exports.DataGridStore = DataGridStore;

package/__inner__/cjs/core/store/entities/events.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridStoreEvent = void 0;
+exports.dataGridStoreEvent = {
+    RECALCULATE: 'recalculate',
+    CHANGE_STATUS: 'changeStatus',
+    ADD_COLUMN: 'addColumn',
+    ADD_GROUP: 'addGroup',
+    CHANGE_DATA: 'changeData',
+    CHANGE_SORTING: 'changeSorting',
+};

package/__inner__/cjs/core/store/entities/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./events"), exports);
+tslib_1.__exportStar(require("./status"), exports);

package/__inner__/cjs/core/store/entities/status.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridStoreWithEmptyStatus = exports.dataGridStoreStatus = void 0;
+var tslib_1 = require("tslib");
+exports.dataGridStoreStatus = ['default', 'loading'];
+exports.dataGridStoreWithEmptyStatus = tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(exports.dataGridStoreStatus), false), [
+    'empty',
+], false);

package/__inner__/cjs/core/store/hooks/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./useDataGridCreateStore"), exports);
+tslib_1.__exportStar(require("./useDataGridStore"), exports);
+tslib_1.__exportStar(require("./useDataGridStoreEvents"), exports);

package/__inner__/cjs/core/store/hooks/useDataGridCreateStore.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataGridCreateStore = void 0;
+var useEventListener_1 = require("@ozen-ui/kit/useEventListener");
+var useStoredValue_1 = require("@ozen-ui/kit/useStoredValue");
+var DataGridStore_1 = require("../DataGridStore");
+var useDataGridCreateStore = function (table, data, onCreate) {
+    var store = (0, useStoredValue_1.useStoredValue)(function () {
+        var created = new DataGridStore_1.DataGridStore(table, data);
+        onCreate === null || onCreate === void 0 ? void 0 : onCreate(created);
+        return created;
+    });
+    (0, useEventListener_1.useEventListener)({
+        eventName: 'resize',
+        handler: function () {
+            store.current.recalculate();
+        },
+    });
+    return store.current;
+};
+exports.useDataGridCreateStore = useDataGridCreateStore;

package/__inner__/cjs/core/store/hooks/useDataGridStore.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataGridStore = void 0;
+var context_1 = require("../../../ui/context");
+var useDataGridStore = function () {
+    var store = (0, context_1.useDataGridContext)().store;
+    return store;
+};
+exports.useDataGridStore = useDataGridStore;

package/__inner__/cjs/core/store/hooks/useDataGridStoreEvents.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataGridStoreEvents = void 0;
+var shared_1 = require("../../../shared");
+var useDataGridStore_1 = require("./useDataGridStore");
+var useDataGridStoreEvents = function (subscribes, store) {
+    var contextStore = (0, useDataGridStore_1.useDataGridStore)();
+    var neededStore = store !== null && store !== void 0 ? store : contextStore;
+    (0, shared_1.useEventBusEvents)(neededStore.eventBus, subscribes);
+};
+exports.useDataGridStoreEvents = useDataGridStoreEvents;

package/__inner__/cjs/core/store/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./entities"), exports);
+tslib_1.__exportStar(require("./hooks"), exports);
+tslib_1.__exportStar(require("./utils"), exports);
+tslib_1.__exportStar(require("./DataGridStore"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/core/store/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/__inner__/cjs/core/store/utils/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./observer"), exports);

package/__inner__/cjs/core/store/utils/observer/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./observer"), exports);

package/__inner__/cjs/core/store/utils/observer/observer.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridObserver = void 0;
+var mobx_react_lite_1 = require("mobx-react-lite");
+Object.defineProperty(exports, "dataGridObserver", { enumerable: true, get: function () { return mobx_react_lite_1.observer; } });

package/__inner__/cjs/core/sub-row/entities/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./position"), exports);
+tslib_1.__exportStar(require("./settings"), exports);

package/__inner__/cjs/core/sub-row/entities/position.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridSubRowPosition = void 0;
+exports.dataGridSubRowPosition = ['left', 'right'];

package/__inner__/cjs/core/sub-row/entities/settings.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/__inner__/cjs/core/sub-row/hooks/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./useDataGridSubRow"), exports);
+tslib_1.__exportStar(require("./useDataGridSubRowEvents"), exports);
+tslib_1.__exportStar(require("./useDataGridSubRows"), exports);
+tslib_1.__exportStar(require("./useDataGridSubRowsEvents"), exports);

package/__inner__/cjs/core/sub-row/hooks/useDataGridSubRow.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataGridSubRow = void 0;
+var useDataGridSubRows_1 = require("./useDataGridSubRows");
+var useDataGridSubRow = function (subRow, store) {
+    var subRows = (0, useDataGridSubRows_1.useDataGridSubRows)(store);
+    return subRows.findRow(subRow);
+};
+exports.useDataGridSubRow = useDataGridSubRow;

package/__inner__/cjs/core/sub-row/hooks/useDataGridSubRowEvents.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataGridSubRowEvents = void 0;
+var shared_1 = require("../../../shared");
+var useDataGridSubRow_1 = require("./useDataGridSubRow");
+var useDataGridSubRowEvents = function (subRow, subscribes, store) {
+    var storeSubRow = (0, useDataGridSubRow_1.useDataGridSubRow)(subRow, store);
+    (0, shared_1.useEventBusEvents)(storeSubRow.eventBus, subscribes);
+};
+exports.useDataGridSubRowEvents = useDataGridSubRowEvents;

package/__inner__/cjs/core/sub-row/hooks/useDataGridSubRows.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataGridSubRows = void 0;
+var store_1 = require("../../store");
+var useDataGridSubRows = function (store) {
+    var contextStore = (0, store_1.useDataGridStore)();
+    var neededStore = store !== null && store !== void 0 ? store : contextStore;
+    return neededStore.subRows;
+};
+exports.useDataGridSubRows = useDataGridSubRows;

package/__inner__/cjs/core/sub-row/hooks/useDataGridSubRowsEvents.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataGridSubRowsEvents = void 0;
+var shared_1 = require("../../../shared");
+var useDataGridSubRows_1 = require("./useDataGridSubRows");
+var useDataGridSubRowsEvents = function (subscribes, store) {
+    var subRows = (0, useDataGridSubRows_1.useDataGridSubRows)(store);
+    (0, shared_1.useEventBusEvents)(subRows.eventBus, subscribes);
+};
+exports.useDataGridSubRowsEvents = useDataGridSubRowsEvents;

package/__inner__/cjs/core/sub-row/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./entities"), exports);
+tslib_1.__exportStar(require("./hooks"), exports);
+tslib_1.__exportStar(require("./store"), exports);
+tslib_1.__exportStar(require("./table"), exports);

package/__inner__/cjs/core/sub-row/store/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./sub-row"), exports);
+tslib_1.__exportStar(require("./sub-rows"), exports);

package/__inner__/cjs/core/sub-row/store/sub-row/DataGridStoreSubRow.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGridStoreSubRow = void 0;
+var mobx_1 = require("mobx");
+var shared_1 = require("../../../../shared");
+var DataGridStoreSubRow = /** @class */ (function () {
+    function DataGridStoreSubRow(subRow, context, root) {
+        var _this = this;
+        // eslint-disable-next-line no-use-before-define
+        this.rows = [];
+        this.expandedByRowId = {};
+        this.eventBus = new shared_1.EventBus();
+        this.context = context;
+        this.root = root !== null && root !== void 0 ? root : null;
+        this.id = subRow.id;
+        this.render = subRow.render;
+        this.getIsVisible = subRow.isVisible;
+        subRow.subRows.forEach(function (subRow) {
+            _this.addSubRow(new DataGridStoreSubRow(subRow, _this.context, _this));
+        });
+        (0, mobx_1.makeAutoObservable)(this);
+    }
+    Object.defineProperty(DataGridStoreSubRow.prototype, "isRoot", {
+        get: function () {
+            return this.root == null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreSubRow.prototype.generateId = function (index) {
+        return "".concat(this.id, "_").concat(index);
+    };
+    DataGridStoreSubRow.prototype.getIsExpanded = function (id) {
+        return !!this.expandedByRowId[id];
+    };
+    DataGridStoreSubRow.prototype.expand = function (id) {
+        var oldExpanded = this.getIsExpanded(id);
+        this.expandedByRowId[id] = true;
+        if (!oldExpanded) {
+            this.eventBus.publish('changeExpanded', { isExpanded: true, rowId: id });
+            this.context.subRows.eventBus.publish('changeExpanded', {
+                id: this.id,
+                isExpanded: true,
+                rowId: id,
+            });
+        }
+    };
+    DataGridStoreSubRow.prototype.collapse = function (id) {
+        var oldExpanded = this.getIsExpanded(id);
+        delete this.expandedByRowId[id];
+        if (oldExpanded) {
+            this.eventBus.publish('changeExpanded', { isExpanded: false, rowId: id });
+            this.context.subRows.eventBus.publish('changeExpanded', {
+                id: this.id,
+                isExpanded: false,
+                rowId: id,
+            });
+        }
+        this.rows.forEach(function (subRow) {
+            subRow.collapse(id);
+        });
+    };
+    DataGridStoreSubRow.prototype.toggle = function (id) {
+        if (this.getIsExpanded(id)) {
+            this.collapse(id);
+            return;
+        }
+        this.expand(id);
+    };
+    DataGridStoreSubRow.prototype.isVisible = function (item, index) {
+        if (this.root) {
+            return (this.getIsVisible(item, index) && this.root.getIsVisible(item, index));
+        }
+        return this.getIsVisible(item, index);
+    };
+    DataGridStoreSubRow.prototype.isSomeRowsVisible = function (item, index) {
+        return this.rows.some(function (row) { return row.isVisible(item, index); });
+    };
+    Object.defineProperty(DataGridStoreSubRow.prototype, "canExpand", {
+        get: function () {
+            return this.rows.length > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreSubRow.prototype, "depth", {
+        get: function () {
+            if (this.root) {
+                return this.root.depth + 1;
+            }
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreSubRow.prototype.addSubRow = function (subRow) {
+        this.rows.push(subRow);
+        this.eventBus.publish('addSubRow', subRow);
+        return subRow;
+    };
+    return DataGridStoreSubRow;
+}());
+exports.DataGridStoreSubRow = DataGridStoreSubRow;

package/__inner__/cjs/core/sub-row/store/sub-row/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./DataGridStoreSubRow"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/core/sub-row/store/sub-row/types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridStoreSubRowEvent = void 0;
+exports.dataGridStoreSubRowEvent = {
+    CHANGE_EXPANDED: 'changeExpanded',
+    ADD_SUB_ROW: 'addSubRow',
+};