@ozen-ui/data-grid 0.73.0

package/__inner__/esm/core/column/store/DataGridStoreColumn.js

@@ -0,0 +1,154 @@
+import { isFunction, isNumber } from '@ozen-ui/kit/utils';
+import { autorun, makeAutoObservable, reaction, runInAction } from 'mobx';
+import { EventBus } from '../../../shared';
+var DataGridStoreColumn = /** @class */ (function () {
+    function DataGridStoreColumn(column, context, root) {
+        var _a;
+        this.width = 'responsive';
+        this.eventBus = new EventBus();
+        this.rawIsVisible = true;
+        this.context = context;
+        this.root = root !== null && root !== void 0 ? root : null;
+        this.id = column.id;
+        this.cell = column.cell;
+        this.header = column.header;
+        this.accessor = column.accessor;
+        this.footer = column.footer;
+        this.name = column.name;
+        this.align = column.align;
+        this.sortSettings = column.sortSettings;
+        this.sort = null;
+        var width = (_a = column.width) !== null && _a !== void 0 ? _a : context.columnsInfo.width;
+        this.rawWidth = (function () {
+            if (isFunction(width)) {
+                return width;
+            }
+            if (width === null) {
+                return function () { return 'responsive'; };
+            }
+            return function () { return width; };
+        })();
+        makeAutoObservable(this);
+    }
+    DataGridStoreColumn.prototype.register = function () {
+        var _this = this;
+        autorun(function () {
+            _this.recalculate();
+        });
+        reaction(function () { return _this.isVisible; }, function (isVisible) {
+            _this.eventBus.publish('changeIsVisible', isVisible);
+        });
+    };
+    DataGridStoreColumn.prototype.recalculate = function () {
+        var _this = this;
+        var width = this.rawWidth(this, this.context);
+        runInAction(function () {
+            _this.setWidth(isNumber(width) ? "".concat(width, "px") : width);
+        });
+        this.eventBus.publish('recalculate', null);
+    };
+    DataGridStoreColumn.prototype.setWidth = function (width) {
+        var oldWidth = this.width;
+        this.width = width;
+        if (oldWidth !== width) {
+            this.eventBus.publish('changeWidth', width);
+        }
+    };
+    DataGridStoreColumn.prototype.setAlign = function (align) {
+        var oldAlign = this.align;
+        this.align = align;
+        if (oldAlign !== align) {
+            this.eventBus.publish('changeAlign', align);
+        }
+    };
+    DataGridStoreColumn.prototype.setSort = function (sort) {
+        var oldSort = this.sort;
+        this.sort = sort;
+        if (oldSort !== sort) {
+            this.eventBus.publish('changeSort', sort);
+            this.context.eventBus.publish('changeSorting', this);
+        }
+    };
+    DataGridStoreColumn.prototype.setIsVisible = function (isVisible) {
+        this.rawIsVisible = isVisible;
+    };
+    Object.defineProperty(DataGridStoreColumn.prototype, "hasSort", {
+        get: function () {
+            var _a;
+            return (this.sortSettings.available && ((_a = this.sortSettings.available) === null || _a === void 0 ? void 0 : _a.length) > 0);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreColumn.prototype, "isSortDisabled", {
+        get: function () {
+            return !this.hasSort || this.context.isLoading || this.context.isEmpty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreColumn.prototype.switchSort = function () {
+        if (this.isSortDisabled) {
+            return;
+        }
+        if (this.isAscending) {
+            this.setSort('descending');
+            return;
+        }
+        if (this.isDescending) {
+            this.resetSort();
+            return;
+        }
+        this.setSort('ascending');
+    };
+    DataGridStoreColumn.prototype.resetSort = function () {
+        this.setSort(null);
+    };
+    Object.defineProperty(DataGridStoreColumn.prototype, "isAscending", {
+        get: function () {
+            return this.sort === 'ascending';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreColumn.prototype, "isDescending", {
+        get: function () {
+            return this.sort === 'descending';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreColumn.prototype, "isSortActive", {
+        get: function () {
+            return this.sort !== null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreColumn.prototype, "isLeftAlign", {
+        get: function () {
+            return this.align === 'left';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreColumn.prototype, "isRightAlign", {
+        get: function () {
+            return this.align === 'right';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreColumn.prototype, "isVisible", {
+        get: function () {
+            if (this.root) {
+                return this.root.isVisible && this.rawIsVisible;
+            }
+            return this.rawIsVisible;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return DataGridStoreColumn;
+}());
+export { DataGridStoreColumn };

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

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

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

@@ -0,0 +1,7 @@
+export var dataGridStoreColumnEvent = {
+    RECALCULATE: 'recalculate',
+    CHANGE_WIDTH: 'changeWidth',
+    CHANGE_SORT: 'changeSort',
+    CHANGE_IS_VISIBLE: 'changeIsVisible',
+    CHANGE_ALIGN: 'changeAlign',
+};

package/__inner__/esm/core/column/table/DataGridColumn.js

@@ -0,0 +1,76 @@
+import { __assign } from "tslib";
+import { isArray } from '@ozen-ui/kit/utils';
+import { dataGridColumnSortType } from '../entities';
+var DataGridColumn = /** @class */ (function () {
+    function DataGridColumn(_a) {
+        var id = _a.id, cell = _a.cell, header = _a.header, accessor = _a.accessor, footer = _a.footer, name = _a.name, align = _a.align, sorting = _a.sorting, width = _a.width;
+        this.root = null;
+        this.context = null;
+        this.rawId = id;
+        this.header = header !== null && header !== void 0 ? header : name;
+        this.cell = cell !== null && cell !== void 0 ? cell : (function (data) { return String(data); });
+        this.footer = footer;
+        this.accessor = accessor;
+        this.name = name;
+        this.align = align !== null && align !== void 0 ? align : 'left';
+        this.width = width !== null && width !== void 0 ? width : null;
+        var availableSorting = (function () {
+            if (sorting === true) {
+                return Object.values(dataGridColumnSortType);
+            }
+            if (isArray(sorting)) {
+                return sorting;
+            }
+            return null;
+        })();
+        this.sortSettings = {
+            available: availableSorting,
+        };
+    }
+    DataGridColumn.prototype.setContext = function (context) {
+        this.context = context;
+    };
+    Object.defineProperty(DataGridColumn.prototype, "id", {
+        get: function () {
+            if (this.root) {
+                return "".concat(this.root.id, ".").concat(this.rawId);
+            }
+            return this.rawId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridColumn.prototype.setRoot = function (root) {
+        this.root = root;
+    };
+    DataGridColumn.prototype.createDateFilter = function (params) {
+        return this.context.createDateFilter(__assign(__assign({}, params), { column: this }));
+    };
+    DataGridColumn.prototype.createSelectFilter = function (params) {
+        return this.context.createSelectFilter(__assign(__assign({}, params), { column: this }));
+    };
+    DataGridColumn.prototype.createNumberFilter = function (params) {
+        return this.context.createNumberFilter(__assign(__assign({}, params), { column: this }));
+    };
+    DataGridColumn.prototype.createStringFilter = function (params) {
+        return this.context.createStringFilter(__assign(__assign({}, params), { column: this }));
+    };
+    DataGridColumn.prototype.createAutocompleteFilter = function (params) {
+        return this.context.createAutocompleteFilter(__assign(__assign({}, params), { column: this }));
+    };
+    DataGridColumn.prototype.createAutocompleteListCardFilter = function (params) {
+        return this.context.createAutocompleteListCardFilter(__assign(__assign({}, params), { column: this }));
+    };
+    Object.defineProperty(DataGridColumn.prototype, "depth", {
+        get: function () {
+            if (this.root) {
+                return this.root.depth + 1;
+            }
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return DataGridColumn;
+}());
+export { DataGridColumn };

package/__inner__/esm/core/column/table/index.js

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

package/__inner__/esm/core/column/table/types.js

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

package/__inner__/esm/core/columns-group/hooks/index.js

@@ -0,0 +1,2 @@
+export * from './useDataGridColumnsGroup';
+export * from './useDataGridColumnsGroupEvents';

package/__inner__/esm/core/columns-group/hooks/useDataGridColumnsGroup.js

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

package/__inner__/esm/core/columns-group/hooks/useDataGridColumnsGroupEvents.js

@@ -0,0 +1,6 @@
+import { useEventBusEvents } from '../../../shared';
+import { useDataGridColumnsGroup } from './useDataGridColumnsGroup';
+export var useDataGridColumnsGroupEvents = function (group, subscribes, store) {
+    var storeColumn = useDataGridColumnsGroup(group, store);
+    useEventBusEvents(storeColumn.eventBus, subscribes);
+};

package/__inner__/esm/core/columns-group/index.js

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

package/__inner__/esm/core/columns-group/store/DataGridStoreColumnsGroup.js

@@ -0,0 +1,184 @@
+import { __values } from "tslib";
+import { makeAutoObservable } from 'mobx';
+import { EventBus } from '../../../shared';
+import { DataGridColumn, DataGridStoreColumn } from '../../column';
+import { DataGridColumnsGroup } from '../table';
+var DataGridStoreColumnsGroup = /** @class */ (function () {
+    function DataGridStoreColumnsGroup(group, context, root, topRoot) {
+        var _this = this;
+        // eslint-disable-next-line no-use-before-define
+        this.nodes = [];
+        this.eventBus = new EventBus();
+        this.rawIsVisible = true;
+        this.context = context;
+        this.id = group.id;
+        this.header = group.header;
+        this.footer = group.footer;
+        this.depth = group.depth;
+        this.root = root !== null && root !== void 0 ? root : null;
+        this.topRoot = topRoot !== null && topRoot !== void 0 ? topRoot : this;
+        group.columns.forEach(function (column) {
+            if (column instanceof DataGridColumn) {
+                _this.addColumn(new DataGridStoreColumn(column, _this.context, _this));
+                return;
+            }
+            if (column instanceof DataGridColumnsGroup) {
+                _this.addGroup(new DataGridStoreColumnsGroup(column, _this.context, _this, _this.topRoot));
+            }
+        });
+        makeAutoObservable(this);
+    }
+    Object.defineProperty(DataGridStoreColumnsGroup.prototype, "columnsCount", {
+        get: function () {
+            return this.columns.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreColumnsGroup.prototype, "visibleColumnsCount", {
+        get: function () {
+            return this.visibleColumns.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreColumnsGroup.prototype.addColumn = function (column) {
+        this.nodes.push(column);
+        this.eventBus.publish('addColumn', column);
+        return column;
+    };
+    DataGridStoreColumnsGroup.prototype.addGroup = function (group) {
+        this.nodes.push(group);
+        this.eventBus.publish('addGroup', group);
+        return group;
+    };
+    DataGridStoreColumnsGroup.prototype.setIsVisible = function (isVisible) {
+        this.rawIsVisible = isVisible;
+    };
+    Object.defineProperty(DataGridStoreColumnsGroup.prototype, "isVisible", {
+        get: function () {
+            var _this = this;
+            var isVisible = (function () {
+                if (_this.root) {
+                    return _this.root.isVisible && _this.rawIsVisible;
+                }
+                return _this.rawIsVisible;
+            })();
+            this.eventBus.publish('changeIsVisible', isVisible);
+            return isVisible;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreColumnsGroup.prototype, "visibleNodes", {
+        get: function () {
+            return this.nodes.filter(function (column) { return column.isVisible; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreColumnsGroup.prototype.getGroups = function (isVisibleOnly) {
+        var groupsByDepth = [];
+        var prepareGroup = function (group, depth) {
+            if (depth === void 0) { depth = 0; }
+            var nodes = isVisibleOnly ? group.visibleNodes : group.nodes;
+            nodes.forEach(function (node) {
+                if (node instanceof DataGridStoreColumn) {
+                    return;
+                }
+                if (isVisibleOnly && node.visibleColumns.length === 0) {
+                    return;
+                }
+                if (!groupsByDepth[depth]) {
+                    groupsByDepth[depth] = [];
+                }
+                groupsByDepth[depth].push(node);
+                prepareGroup(node, depth + 1);
+            });
+        };
+        prepareGroup(this);
+        return groupsByDepth;
+    };
+    Object.defineProperty(DataGridStoreColumnsGroup.prototype, "leftGroups", {
+        get: function () {
+            var e_1, _a;
+            var leftGroups = [];
+            var rootNodes = this.context.getNodesByDepth(true);
+            var equalLevelNodes = rootNodes[this.depth];
+            if (!equalLevelNodes) {
+                throw new Error('Error getting groups from left.');
+            }
+            var rootGroups = equalLevelNodes.filter(function (node) { return node instanceof DataGridStoreColumnsGroup; });
+            try {
+                for (var rootGroups_1 = __values(rootGroups), rootGroups_1_1 = rootGroups_1.next(); !rootGroups_1_1.done; rootGroups_1_1 = rootGroups_1.next()) {
+                    var group = rootGroups_1_1.value;
+                    if (group.id === this.id) {
+                        break;
+                    }
+                    leftGroups.push(group);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (rootGroups_1_1 && !rootGroups_1_1.done && (_a = rootGroups_1.return)) _a.call(rootGroups_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return leftGroups;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreColumnsGroup.prototype, "offset", {
+        get: function () {
+            var leftGroupsTotalCols = 0;
+            this.leftGroups.forEach(function (leftGroup) {
+                leftGroupsTotalCols += leftGroup.offset + leftGroup.visibleColumnsCount;
+            });
+            var globalColumns = this.context.columns;
+            var firstGroupColumn = this.visibleColumns[0];
+            if (!firstGroupColumn) {
+                throw new Error('Failed to calculate column offset.');
+            }
+            var firstGroupColumnIndex = globalColumns.findIndex(function (globalColumn) { return globalColumn.id === firstGroupColumn.id; });
+            if (firstGroupColumnIndex === -1) {
+                throw new Error('Failed to calculate column offset.');
+            }
+            if (firstGroupColumnIndex === 0) {
+                return 0;
+            }
+            return firstGroupColumnIndex - leftGroupsTotalCols;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreColumnsGroup.prototype, "columns", {
+        get: function () {
+            var columns = [];
+            var getColumnsFromNode = function (node) {
+                node.nodes.forEach(function (node) {
+                    if (node instanceof DataGridStoreColumn) {
+                        columns.push(node);
+                    }
+                    else {
+                        getColumnsFromNode(node);
+                    }
+                });
+            };
+            getColumnsFromNode(this);
+            return columns;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreColumnsGroup.prototype, "visibleColumns", {
+        get: function () {
+            return this.columns.filter(function (column) { return column.isVisible; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return DataGridStoreColumnsGroup;
+}());
+export { DataGridStoreColumnsGroup };

package/__inner__/esm/core/columns-group/store/index.js

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

package/__inner__/esm/core/columns-group/store/types.js

@@ -0,0 +1,5 @@
+export var dataGridStoreColumnsGroupEvent = {
+    CHANGE_IS_VISIBLE: 'changeIsVisible',
+    ADD_COLUMN: 'addColumn',
+    ADD_GROUP: 'addGroup',
+};

package/__inner__/esm/core/columns-group/table/DataGridColumnsGroup.js

@@ -0,0 +1,56 @@
+import { DataGridColumn } from '../../column';
+var DataGridColumnsGroup = /** @class */ (function () {
+    function DataGridColumnsGroup(_a) {
+        var id = _a.id, header = _a.header, footer = _a.footer;
+        // eslint-disable-next-line no-use-before-define
+        this.columns = [];
+        // eslint-disable-next-line no-use-before-define
+        this.root = null;
+        this.rawId = id;
+        this.header = header !== null && header !== void 0 ? header : this.id;
+        this.footer = footer;
+    }
+    Object.defineProperty(DataGridColumnsGroup.prototype, "id", {
+        get: function () {
+            if (this.root) {
+                return "".concat(this.root.id, ".").concat(this.rawId);
+            }
+            return this.rawId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridColumnsGroup.prototype.createColumn = function (columnParams) {
+        var column = this.addColumn(new DataGridColumn(columnParams));
+        column.setRoot(this);
+        return column;
+    };
+    DataGridColumnsGroup.prototype.setRoot = function (root) {
+        this.root = root;
+    };
+    DataGridColumnsGroup.prototype.addColumn = function (column) {
+        this.columns.push(column);
+        return column;
+    };
+    DataGridColumnsGroup.prototype.createGroup = function (groupParams) {
+        var group = this.addGroup(new DataGridColumnsGroup(groupParams));
+        return group;
+    };
+    Object.defineProperty(DataGridColumnsGroup.prototype, "depth", {
+        get: function () {
+            if (this.root) {
+                return this.root.depth + 1;
+            }
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridColumnsGroup.prototype.addGroup = function (group) {
+        this.columns.push(group);
+        group.setRoot(this);
+        return group;
+    };
+    return DataGridColumnsGroup;
+}());
+export { DataGridColumnsGroup };

package/__inner__/esm/core/columns-group/table/index.js

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

package/__inner__/esm/core/columns-group/table/types.js

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

package/__inner__/esm/core/entities/accessor.js

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

package/__inner__/esm/core/entities/cell.js

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

package/__inner__/esm/core/entities/data.js

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

package/__inner__/esm/core/entities/footer.js

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

package/__inner__/esm/core/entities/header.js

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

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

@@ -0,0 +1,5 @@
+export * from './accessor';
+export * from './cell';
+export * from './data';
+export * from './footer';
+export * from './header';

package/__inner__/esm/core/filter/entities/date-type.js

@@ -0,0 +1 @@
+export var dataGridFilterDateType = ['single', 'range'];

package/__inner__/esm/core/filter/entities/group.js

@@ -0,0 +1 @@
+export var dataGridFilterGroup = ['main', 'sub-main', 'additional'];

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

@@ -0,0 +1,7 @@
+export * from './date-type';
+export * from './group';
+export * from './info';
+export * from './input-validate';
+export * from './logic';
+export * from './option';
+export * from './select-type';

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

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

package/__inner__/esm/core/filter/entities/input-validate.js

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

package/__inner__/esm/core/filter/entities/logic.js

@@ -0,0 +1 @@
+export var dataGridFilterLogic = ['immediate', 'confirmable'];

package/__inner__/esm/core/filter/entities/option.js

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

package/__inner__/esm/core/filter/entities/select-type.js

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

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

@@ -0,0 +1,4 @@
+export * from './useDataGridFilter';
+export * from './useDataGridFilterEvents';
+export * from './useDataGridFilters';
+export * from './useDataGridFiltersEvents';

package/__inner__/esm/core/filter/hooks/useDataGridFilter.js

@@ -0,0 +1,5 @@
+import { useDataGridFilters } from './useDataGridFilters';
+export var useDataGridFilter = function (filter, store) {
+    var filters = useDataGridFilters(store);
+    return filters.findFilter(filter);
+};

package/__inner__/esm/core/filter/hooks/useDataGridFilterEvents.js

@@ -0,0 +1,6 @@
+import { useEventBusEvents } from '../../../shared';
+import { useDataGridFilter } from './useDataGridFilter';
+export var useDataGridFilterEvents = function (filter, subscribes, store) {
+    var storeFilter = useDataGridFilter(filter, store);
+    useEventBusEvents(storeFilter.eventBus, subscribes);
+};

package/__inner__/esm/core/filter/hooks/useDataGridFilters.js

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

package/__inner__/esm/core/filter/hooks/useDataGridFiltersEvents.js

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

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

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