@ozen-ui/data-grid 0.73.0

package/__inner__/esm/core/pagination/index.js

@@ -0,0 +1,3 @@
+export * from './entities';
+export * from './hooks';
+export * from './store';

package/__inner__/esm/core/pagination/store/DataGridStorePagination.js

@@ -0,0 +1,80 @@
+import { shallowEqual } from '@ozen-ui/kit/utils';
+import { makeAutoObservable, toJS } from 'mobx';
+import { EventBus } from '../../../shared';
+var DataGridStorePagination = /** @class */ (function () {
+    function DataGridStorePagination(_a, context) {
+        var total = _a.total, isEnabled = _a.isEnabled, pageSize = _a.pageSize, availableSizes = _a.availableSizes;
+        this.isEnabled = false;
+        this.eventBus = new EventBus();
+        this.context = context;
+        this.index = 0;
+        this.total = total;
+        this.isEnabled = isEnabled;
+        this.pageSize = pageSize;
+        this.availableSizes = availableSizes;
+        makeAutoObservable(this);
+    }
+    DataGridStorePagination.prototype.setAvailableSizes = function (sizes) {
+        var oldSizes = this.availableSizes;
+        this.availableSizes = sizes;
+        if (!shallowEqual(toJS(oldSizes), sizes)) {
+            this.eventBus.publish('changeAvailableSizes', sizes);
+        }
+        if (!this.availableSizes.includes(this.pageSize)) {
+            var firstSize = this.availableSizes[0];
+            var lastSize = this.availableSizes[this.availableSizes.length - 1];
+            if (firstSize && this.pageSize < firstSize) {
+                this.setPageSize(firstSize);
+                return;
+            }
+            if (lastSize && this.pageSize > lastSize) {
+                this.setPageSize(lastSize);
+                return;
+            }
+            throw new Error("Failed to calculate new pageSize for updated availableSizes. availableSizes: [".concat(this.availableSizes.join(', '), "], pageSize: \"").concat(this.pageSize, "\""));
+        }
+    };
+    DataGridStorePagination.prototype.setPageSize = function (size) {
+        var oldSize = this.pageSize;
+        this.pageSize = size;
+        if (oldSize !== size) {
+            this.eventBus.publish('changePageSize', size);
+        }
+    };
+    DataGridStorePagination.prototype.setIndex = function (index) {
+        var oldIndex = this.index;
+        this.index = index;
+        if (oldIndex !== index) {
+            this.eventBus.publish('changeIndex', index);
+        }
+    };
+    DataGridStorePagination.prototype.setTotal = function (total) {
+        var oldTotal = this.total;
+        this.total = total;
+        if (oldTotal !== total) {
+            this.eventBus.publish('changeTotal', total);
+        }
+    };
+    DataGridStorePagination.prototype.setIsEnabled = function (isEnabled) {
+        var oldIsEnabled = this.isEnabled;
+        this.isEnabled = isEnabled;
+        if (oldIsEnabled !== isEnabled) {
+            this.eventBus.publish('changeIsEnabled', isEnabled);
+        }
+    };
+    DataGridStorePagination.prototype.enable = function () {
+        this.setIsEnabled(true);
+    };
+    DataGridStorePagination.prototype.disable = function () {
+        this.setIsEnabled(false);
+    };
+    Object.defineProperty(DataGridStorePagination.prototype, "isAvailableSizeEnabled", {
+        get: function () {
+            return this.availableSizes.length > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return DataGridStorePagination;
+}());
+export { DataGridStorePagination };

package/__inner__/esm/core/pagination/store/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridStorePagination';
+export * from './types';

package/__inner__/esm/core/pagination/store/types.js

@@ -0,0 +1,7 @@
+export var dataGridStorePaginationEvent = {
+    CHANGE_AVAILABLE_SIZES: 'changeAvailableSizes',
+    CHANGE_PAGE_SIZE: 'changePageSize',
+    CHANGE_INDEX: 'changeIndex',
+    CHANGE_TOTAL: 'changeTotal',
+    CHANGE_IS_ENABLED: 'changeIsEnabled',
+};

package/__inner__/esm/core/row/entities/id.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/core/row/entities/index.js

@@ -0,0 +1 @@
+export * from './id';

package/__inner__/esm/core/row/index.js

@@ -0,0 +1 @@
+export * from './entities';

package/__inner__/esm/core/selection/entities/index.js

@@ -0,0 +1,2 @@
+export * from './info';
+export * from './type';

package/__inner__/esm/core/selection/entities/info.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/core/selection/entities/type.js

@@ -0,0 +1 @@
+export var dataGridSelectionType = ['single', 'multiple'];

package/__inner__/esm/core/selection/hooks/index.js

@@ -0,0 +1,2 @@
+export * from './useDataGridSelection';
+export * from './useDataGridSelectionEvents';

package/__inner__/esm/core/selection/hooks/useDataGridSelection.js

@@ -0,0 +1,6 @@
+import { useDataGridStore } from '../../store';
+export var useDataGridSelection = function (store) {
+    var contextStore = useDataGridStore();
+    var neededStore = store !== null && store !== void 0 ? store : contextStore;
+    return neededStore.selection;
+};

package/__inner__/esm/core/selection/hooks/useDataGridSelectionEvents.js

@@ -0,0 +1,6 @@
+import { useEventBusEvents } from '../../../shared';
+import { useDataGridSelection } from './useDataGridSelection';
+export var useDataGridSelectionEvents = function (subscribes, store) {
+    var selection = useDataGridSelection(store);
+    useEventBusEvents(selection.eventBus, subscribes);
+};

package/__inner__/esm/core/selection/index.js

@@ -0,0 +1,3 @@
+export * from './entities';
+export * from './hooks';
+export * from './store';

package/__inner__/esm/core/selection/store/DataGridStoreSelection.js

@@ -0,0 +1,140 @@
+import { __read } from "tslib";
+import { makeAutoObservable } from 'mobx';
+import { EventBus } from '../../../shared';
+var DataGridStoreSelection = /** @class */ (function () {
+    function DataGridStoreSelection(_a, context) {
+        var isEnabled = _a.isEnabled, type = _a.type;
+        this.rawSelectedRows = {};
+        this.eventBus = new EventBus();
+        this.context = context;
+        this.isEnabled = isEnabled;
+        this.type = type;
+        makeAutoObservable(this);
+    }
+    Object.defineProperty(DataGridStoreSelection.prototype, "selectedRows", {
+        get: function () {
+            var selectedRows = [];
+            Object.entries(this.rawSelectedRows).forEach(function (_a) {
+                var _b = __read(_a, 2), rowId = _b[0], isSelected = _b[1];
+                if (!isSelected) {
+                    return;
+                }
+                selectedRows.push(rowId);
+            });
+            return selectedRows;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreSelection.prototype, "isSingle", {
+        get: function () {
+            return this.type === 'single';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreSelection.prototype, "isMultiple", {
+        get: function () {
+            return this.type === 'multiple';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreSelection.prototype.setType = function (type) {
+        var _this = this;
+        this.type = type;
+        if (type === 'single') {
+            var selectedRowsEntries = Object.entries(this.rawSelectedRows).filter(function (selected) { return selected; });
+            var selectedRowsCount = selectedRowsEntries.length;
+            if (selectedRowsCount > 1) {
+                selectedRowsEntries.forEach(function (_a, index) {
+                    var _b = __read(_a, 1), id = _b[0];
+                    if (index === 0) {
+                        return;
+                    }
+                    _this.unselectRow(id);
+                });
+            }
+        }
+        this.eventBus.publish('changeType', type);
+    };
+    Object.defineProperty(DataGridStoreSelection.prototype, "selectedCount", {
+        get: function () {
+            return this.selectedRows.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreSelection.prototype, "isAllSelected", {
+        get: function () {
+            var _this = this;
+            if (this.context.data.length === 0) {
+                return false;
+            }
+            return this.context.data.every(function (item) {
+                return _this.getIsSelectedRow(_this.context.generateRowId(item));
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreSelection.prototype, "isSomeSelected", {
+        get: function () {
+            var _this = this;
+            return this.context.data.some(function (item) {
+                return _this.getIsSelectedRow(_this.context.generateRowId(item));
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreSelection.prototype.selectAll = function () {
+        var _this = this;
+        this.context.data.forEach(function (item) {
+            var id = _this.context.generateRowId(item);
+            _this.selectRow(id);
+        });
+    };
+    DataGridStoreSelection.prototype.unselectAll = function () {
+        var _this = this;
+        Object.keys(this.rawSelectedRows).forEach(function (id) {
+            _this.unselectRow(id);
+        });
+    };
+    DataGridStoreSelection.prototype.getIsSelectedRow = function (id) {
+        return !!this.rawSelectedRows[id];
+    };
+    DataGridStoreSelection.prototype.setRowSelected = function (id, isSelected) {
+        var oldValue = this.getIsSelectedRow(id);
+        if (isSelected) {
+            if (this.isSingle) {
+                this.unselectAll();
+            }
+            this.rawSelectedRows[id] = true;
+        }
+        else {
+            delete this.rawSelectedRows[id];
+        }
+        if (oldValue !== isSelected) {
+            this.eventBus.publish('change', { rowId: id, isSelected: isSelected });
+        }
+    };
+    DataGridStoreSelection.prototype.selectRow = function (id) {
+        this.setRowSelected(id, true);
+    };
+    DataGridStoreSelection.prototype.unselectRow = function (id) {
+        this.setRowSelected(id, false);
+    };
+    DataGridStoreSelection.prototype.setIsEnabled = function (isEnabled) {
+        this.isEnabled = isEnabled;
+        this.eventBus.publish('changeIsEnabled', isEnabled);
+    };
+    DataGridStoreSelection.prototype.enable = function () {
+        this.setIsEnabled(true);
+    };
+    DataGridStoreSelection.prototype.disable = function () {
+        this.setIsEnabled(false);
+    };
+    return DataGridStoreSelection;
+}());
+export { DataGridStoreSelection };

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

@@ -0,0 +1,2 @@
+export * from './DataGridStoreSelection';
+export * from './types';

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

@@ -0,0 +1,5 @@
+export var dataGridStoreSelectionEvent = {
+    CHANGE: 'change',
+    CHANGE_IS_ENABLED: 'changeIsEnabled',
+    CHANGE_TYPE: 'changeType',
+};

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

@@ -0,0 +1,323 @@
+import { __read, __spreadArray } from "tslib";
+import { makeAutoObservable, reaction } from 'mobx';
+import { EventBus } from '../../shared';
+import { DataGridColumn, DataGridStoreColumn } from '../column';
+import { DataGridColumnsGroup, DataGridStoreColumnsGroup, } from '../columns-group';
+import { DataGridStoreAutocompleteFilter, DataGridStoreAutocompleteListCardFilter, DataGridStoreDateFilter, DataGridStoreFilters, DataGridStoreNumberFilter, DataGridStoreSelectFilter, DataGridStoreStringFilter, DataGridAutocompleteListCardTableFilter, DataGridDateTableFilter, DataGridNumberTableFilter, DataGridAutocompleteTableFilter, DataGridStringTableFilter, DataGridSelectTableFilter, } from '../filter';
+import { DataGridStoreModals } from '../modals';
+import { DataGridStorePagination } from '../pagination';
+import { DataGridStoreSelection } from '../selection';
+import { DataGridStoreSubRows } from '../sub-row';
+var DataGridStore = /** @class */ (function () {
+    function DataGridStore(table, data) {
+        var _this = this;
+        this.nodes = [];
+        this.data = [];
+        this.rawStatus = 'default';
+        this.eventBus = new EventBus();
+        this.columnsInfo = table.columnsInfo;
+        this.subRows = new DataGridStoreSubRows(table.subRowSettings, table.subRows, this);
+        table.nodes.forEach(function (column) {
+            if (column instanceof DataGridColumn) {
+                _this.addColumn(new DataGridStoreColumn(column, _this));
+                return;
+            }
+            if (column instanceof DataGridColumnsGroup) {
+                _this.addGroup(new DataGridStoreColumnsGroup(column, _this));
+            }
+        });
+        this.generateRowId = table.generateRowId;
+        this.pagination = new DataGridStorePagination(table.pagination, this);
+        this.modals = new DataGridStoreModals(this);
+        this.selection = new DataGridStoreSelection(table.selectionInfo, this);
+        this.filters = new DataGridStoreFilters(table.filterInfo, this);
+        table.filters.forEach(function (filter) {
+            var createdFilter = (function () {
+                if (filter instanceof DataGridAutocompleteTableFilter) {
+                    return new DataGridStoreAutocompleteFilter(filter, _this);
+                }
+                if (filter instanceof DataGridDateTableFilter) {
+                    return new DataGridStoreDateFilter(filter, _this);
+                }
+                if (filter instanceof DataGridSelectTableFilter) {
+                    return new DataGridStoreSelectFilter(filter, _this);
+                }
+                if (filter instanceof DataGridStringTableFilter) {
+                    return new DataGridStoreStringFilter(filter, _this);
+                }
+                if (filter instanceof DataGridNumberTableFilter) {
+                    return new DataGridStoreNumberFilter(filter, _this);
+                }
+                if (filter instanceof DataGridAutocompleteListCardTableFilter) {
+                    return new 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();
+        makeAutoObservable(this);
+        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 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 DataGridStoreColumn) {
+                    columns.push(node);
+                }
+                else if (node instanceof 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 = __read(_a, 2), _index = _b[0], groups = _b[1];
+            var index = Number(_index);
+            groupsArray[index] = __spreadArray([], __read(groups), false);
+        });
+        return __spreadArray(__spreadArray([], __read(groupsArray), false), [columns], false);
+    };
+    return DataGridStore;
+}());
+export { DataGridStore };

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

@@ -0,0 +1,8 @@
+export var dataGridStoreEvent = {
+    RECALCULATE: 'recalculate',
+    CHANGE_STATUS: 'changeStatus',
+    ADD_COLUMN: 'addColumn',
+    ADD_GROUP: 'addGroup',
+    CHANGE_DATA: 'changeData',
+    CHANGE_SORTING: 'changeSorting',
+};

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

@@ -0,0 +1,2 @@
+export * from './events';
+export * from './status';

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

@@ -0,0 +1,5 @@
+import { __read, __spreadArray } from "tslib";
+export var dataGridStoreStatus = ['default', 'loading'];
+export var dataGridStoreWithEmptyStatus = __spreadArray(__spreadArray([], __read(dataGridStoreStatus), false), [
+    'empty',
+], false);

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

@@ -0,0 +1,3 @@
+export * from './useDataGridCreateStore';
+export * from './useDataGridStore';
+export * from './useDataGridStoreEvents';

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

@@ -0,0 +1,17 @@
+import { useEventListener } from "@ozen-ui/kit/useEventListener";
+import { useStoredValue } from "@ozen-ui/kit/useStoredValue";
+import { DataGridStore } from '../DataGridStore';
+export var useDataGridCreateStore = function (table, data, onCreate) {
+    var store = useStoredValue(function () {
+        var created = new DataGridStore(table, data);
+        onCreate === null || onCreate === void 0 ? void 0 : onCreate(created);
+        return created;
+    });
+    useEventListener({
+        eventName: 'resize',
+        handler: function () {
+            store.current.recalculate();
+        },
+    });
+    return store.current;
+};

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

@@ -0,0 +1,5 @@
+import { useDataGridContext } from '../../../ui/context';
+export var useDataGridStore = function () {
+    var store = useDataGridContext().store;
+    return store;
+};

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

@@ -0,0 +1,7 @@
+import { useEventBusEvents } from '../../../shared';
+import { useDataGridStore } from './useDataGridStore';
+export var useDataGridStoreEvents = function (subscribes, store) {
+    var contextStore = useDataGridStore();
+    var neededStore = store !== null && store !== void 0 ? store : contextStore;
+    useEventBusEvents(neededStore.eventBus, subscribes);
+};