@ozen-ui/data-grid 0.73.0

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+import { observer } from 'mobx-react-lite';
+export { observer as dataGridObserver };

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

@@ -0,0 +1,2 @@
+export * from './position';
+export * from './settings';

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

@@ -0,0 +1 @@
+export var dataGridSubRowPosition = ['left', 'right'];

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

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

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

@@ -0,0 +1,4 @@
+export * from './useDataGridSubRow';
+export * from './useDataGridSubRowEvents';
+export * from './useDataGridSubRows';
+export * from './useDataGridSubRowsEvents';

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

@@ -0,0 +1,5 @@
+import { useDataGridSubRows } from './useDataGridSubRows';
+export var useDataGridSubRow = function (subRow, store) {
+    var subRows = useDataGridSubRows(store);
+    return subRows.findRow(subRow);
+};

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

@@ -0,0 +1,6 @@
+import { useEventBusEvents } from '../../../shared';
+import { useDataGridSubRow } from './useDataGridSubRow';
+export var useDataGridSubRowEvents = function (subRow, subscribes, store) {
+    var storeSubRow = useDataGridSubRow(subRow, store);
+    useEventBusEvents(storeSubRow.eventBus, subscribes);
+};

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+export * from './sub-row';
+export * from './sub-rows';

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

@@ -0,0 +1,100 @@
+import { makeAutoObservable } from 'mobx';
+import { EventBus } from '../../../../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 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));
+        });
+        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;
+}());
+export { DataGridStoreSubRow };

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

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

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

@@ -0,0 +1,4 @@
+export var dataGridStoreSubRowEvent = {
+    CHANGE_EXPANDED: 'changeExpanded',
+    ADD_SUB_ROW: 'addSubRow',
+};

package/__inner__/esm/core/sub-row/store/sub-rows/DataGridStoreSubRows.js

@@ -0,0 +1,155 @@
+import { makeAutoObservable } from 'mobx';
+import { EventBus } from '../../../../shared';
+import { DataGridStoreSubRow } from '../sub-row';
+var DataGridStoreSubRows = /** @class */ (function () {
+    function DataGridStoreSubRows(settings, subRows, context) {
+        var _this = this;
+        this.rows = [];
+        this.expandedRootsByRowId = {};
+        this.eventBus = new EventBus();
+        this.context = context;
+        this.position = settings.position;
+        this.isWithMargin = settings.isWithMargin;
+        subRows.forEach(function (subRow) {
+            _this.addSubRow(new DataGridStoreSubRow(subRow, _this.context));
+        });
+        makeAutoObservable(this);
+    }
+    DataGridStoreSubRows.prototype.collapseNotExistRows = function () {
+        var _this = this;
+        var dataById = this.context.dataById;
+        Object.keys(this.expandedRootsByRowId).forEach(function (id) {
+            if (!dataById[id]) {
+                _this.collapseRoot(id);
+            }
+        });
+    };
+    DataGridStoreSubRows.prototype.findRow = function (tableSubRow) {
+        var subRow = this.rowById[tableSubRow.id];
+        if (!subRow) {
+            throw new Error("No subRow found with id \"".concat(tableSubRow.id, "\"."));
+        }
+        return subRow;
+    };
+    Object.defineProperty(DataGridStoreSubRows.prototype, "rowById", {
+        get: function () {
+            var rowById = {};
+            var extractRows = function (row) {
+                rowById[row.id] = row;
+                row.rows.forEach(function (row) {
+                    extractRows(row);
+                });
+            };
+            this.rows.forEach(function (row) {
+                extractRows(row);
+            });
+            return rowById;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreSubRows.prototype, "isEnabled", {
+        get: function () {
+            return this.rows.length > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreSubRows.prototype, "isLeft", {
+        get: function () {
+            return this.position === 'left';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreSubRows.prototype, "isRight", {
+        get: function () {
+            return this.position === 'right';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreSubRows.prototype.setPosition = function (position) {
+        this.position = position;
+    };
+    DataGridStoreSubRows.prototype.setIsWithMargin = function (isWithMargin) {
+        this.isWithMargin = isWithMargin;
+    };
+    DataGridStoreSubRows.prototype.enableMargin = function () {
+        this.setIsWithMargin(true);
+    };
+    DataGridStoreSubRows.prototype.disableMargin = function () {
+        this.setIsWithMargin(false);
+    };
+    Object.defineProperty(DataGridStoreSubRows.prototype, "canExpandRoot", {
+        get: function () {
+            return this.rows.length > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreSubRows.prototype.isSomeRowsVisible = function (id, index) {
+        var item = this.context.dataById[id];
+        if (!item) {
+            return false;
+        }
+        var isSomeVisible = this.rows.some(function (row) { return row.isVisible(item, index); });
+        return this.rows.length > 0 && isSomeVisible;
+    };
+    DataGridStoreSubRows.prototype.expandRoot = function (rowId) {
+        var oldIsExpanded = this.getIsExpandedRoot(rowId);
+        this.expandedRootsByRowId[rowId] = true;
+        if (!oldIsExpanded) {
+            this.eventBus.publish('changeExpandedRoot', {
+                rowId: rowId,
+                isExpanded: true,
+            });
+            this.eventBus.publish('changeExpanded', {
+                id: 'root',
+                rowId: rowId,
+                isExpanded: true,
+            });
+        }
+    };
+    DataGridStoreSubRows.prototype.collapseAll = function () {
+        var _this = this;
+        Object.keys(this.expandedRootsByRowId).forEach(function (rowId) {
+            _this.collapseRoot(rowId);
+        });
+    };
+    DataGridStoreSubRows.prototype.collapseRoot = function (rowId) {
+        var oldIsExpanded = this.getIsExpandedRoot(rowId);
+        delete this.expandedRootsByRowId[rowId];
+        this.rows.forEach(function (subRow) {
+            subRow.collapse(rowId);
+        });
+        if (oldIsExpanded) {
+            this.eventBus.publish('changeExpandedRoot', {
+                rowId: rowId,
+                isExpanded: false,
+            });
+            this.eventBus.publish('changeExpanded', {
+                id: 'root',
+                rowId: rowId,
+                isExpanded: false,
+            });
+        }
+    };
+    DataGridStoreSubRows.prototype.toggleRoot = function (id) {
+        if (this.getIsExpandedRoot(id)) {
+            this.collapseRoot(id);
+            return;
+        }
+        this.expandRoot(id);
+    };
+    DataGridStoreSubRows.prototype.getIsExpandedRoot = function (rowId) {
+        return !!this.expandedRootsByRowId[rowId];
+    };
+    DataGridStoreSubRows.prototype.addSubRow = function (subRow) {
+        this.rows.push(subRow);
+        this.eventBus.publish('addSubRow', subRow);
+        return subRow;
+    };
+    return DataGridStoreSubRows;
+}());
+export { DataGridStoreSubRows };

package/__inner__/esm/core/sub-row/store/sub-rows/index.js

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

package/__inner__/esm/core/sub-row/store/sub-rows/types.js

@@ -0,0 +1,5 @@
+export var dataGridStoreSubRowsEvent = {
+    CHANGE_EXPANDED_ROOT: 'changeExpandedRoot',
+    CHANGE_EXPANDED: 'changeExpanded',
+    ADD_SUB_ROW: 'addSubRow',
+};

package/__inner__/esm/core/sub-row/table/DataGridSubRow.js

@@ -0,0 +1,46 @@
+var DataGridSubRow = /** @class */ (function () {
+    function DataGridSubRow(_a) {
+        var id = _a.id, render = _a.render, isVisible = _a.isVisible;
+        // eslint-disable-next-line no-use-before-define
+        this.root = null;
+        // eslint-disable-next-line no-use-before-define
+        this.subRows = [];
+        this.rawId = id;
+        this.render = render;
+        this.isVisible = isVisible !== null && isVisible !== void 0 ? isVisible : (function () { return true; });
+    }
+    Object.defineProperty(DataGridSubRow.prototype, "id", {
+        get: function () {
+            if (this.root) {
+                return "".concat(this.root.id, ".").concat(this.rawId);
+            }
+            return "subRow_".concat(this.rawId);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridSubRow.prototype.setRoot = function (root) {
+        this.root = root;
+    };
+    Object.defineProperty(DataGridSubRow.prototype, "depth", {
+        get: function () {
+            if (this.root) {
+                return this.root.depth + 1;
+            }
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridSubRow.prototype.createSubRow = function (params) {
+        var created = this.addSubRow(new DataGridSubRow(params));
+        return created;
+    };
+    DataGridSubRow.prototype.addSubRow = function (subRow) {
+        this.subRows.push(subRow);
+        subRow.setRoot(this);
+        return subRow;
+    };
+    return DataGridSubRow;
+}());
+export { DataGridSubRow };

package/__inner__/esm/core/sub-row/table/index.js

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

package/__inner__/esm/core/sub-row/table/types.js

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

package/__inner__/esm/core/table/DataGridTable.js

@@ -0,0 +1,139 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+import { __assign } from "tslib";
+import { useDataGridColumnEvents, useDataGridColumn, useDataGridColumnsInfo, DataGridColumn, } from '../column';
+import { useDataGridColumnsGroupEvents, useDataGridColumnsGroup, DataGridColumnsGroup, } from '../columns-group';
+import { useDataGridFiltersEvents, useDataGridFilters, useDataGridFilterEvents, useDataGridFilter, DataGridDateTableFilter, DataGridNumberTableFilter, DataGridStringTableFilter, DataGridAutocompleteListCardTableFilter, DataGridSelectTableFilter, DataGridAutocompleteTableFilter, } from '../filter';
+import { useDataGridPaginationEvents, useDataGridPagination, } from '../pagination';
+import { useDataGridSelectionEvents, useDataGridSelection } from '../selection';
+import { useDataGridCreateStore, useDataGridStore, useDataGridStoreEvents, } from '../store';
+import { useDataGridSubRowsEvents, useDataGridSubRows, useDataGridSubRowEvents, useDataGridSubRow, DataGridSubRow, } from '../sub-row';
+var DataGridTable = /** @class */ (function () {
+    function DataGridTable(_a) {
+        var generateRowId = _a.generateRowId, pagination = _a.pagination, subRow = _a.subRow, selection = _a.selection, filter = _a.filter, columns = _a.columns;
+        var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        this.nodes = [];
+        this.subRows = [];
+        this.filters = [];
+        this.generateRowId = generateRowId;
+        this.pagination = pagination
+            ? __assign(__assign({}, pagination), { isEnabled: true, total: (_b = pagination.total) !== null && _b !== void 0 ? _b : 0, pageSize: (_c = pagination.pageSize) !== null && _c !== void 0 ? _c : 0, availableSizes: (_d = pagination.availableSizes) !== null && _d !== void 0 ? _d : [] }) : {
+            isEnabled: false,
+            pageSize: 0,
+            total: 0,
+            availableSizes: [],
+        };
+        this.subRowSettings = __assign(__assign({}, subRow), { position: (_e = subRow === null || subRow === void 0 ? void 0 : subRow.position) !== null && _e !== void 0 ? _e : 'left', isWithMargin: (_f = subRow === null || subRow === void 0 ? void 0 : subRow.isWithMargin) !== null && _f !== void 0 ? _f : false });
+        this.selectionInfo = __assign(__assign({}, selection), { isEnabled: (_g = selection === null || selection === void 0 ? void 0 : selection.isEnabled) !== null && _g !== void 0 ? _g : false, type: (_h = selection === null || selection === void 0 ? void 0 : selection.type) !== null && _h !== void 0 ? _h : 'multiple' });
+        this.filterInfo = __assign(__assign({}, filter), { logic: (_j = filter === null || filter === void 0 ? void 0 : filter.logic) !== null && _j !== void 0 ? _j : 'immediate' });
+        this.columnsInfo = __assign(__assign({}, columns), { canHide: (_k = columns === null || columns === void 0 ? void 0 : columns.canHide) !== null && _k !== void 0 ? _k : true, width: (_l = columns === null || columns === void 0 ? void 0 : columns.width) !== null && _l !== void 0 ? _l : 'responsive', verticalAlign: (_m = columns === null || columns === void 0 ? void 0 : columns.verticalAlign) !== null && _m !== void 0 ? _m : 'middle' });
+    }
+    DataGridTable.prototype.createColumn = function (columnParams) {
+        var column = this.addColumn(new DataGridColumn(columnParams));
+        return column;
+    };
+    DataGridTable.prototype.addFilter = function (filter) {
+        this.filters.push(filter);
+        return filter;
+    };
+    DataGridTable.prototype.createDateFilter = function (params) {
+        return this.addFilter(new DataGridDateTableFilter(params));
+    };
+    DataGridTable.prototype.createSelectFilter = function (params) {
+        return this.addFilter(new DataGridSelectTableFilter(params));
+    };
+    DataGridTable.prototype.createNumberFilter = function (params) {
+        return this.addFilter(new DataGridNumberTableFilter(params));
+    };
+    DataGridTable.prototype.createStringFilter = function (params) {
+        return this.addFilter(new DataGridStringTableFilter(params));
+    };
+    DataGridTable.prototype.createAutocompleteFilter = function (params) {
+        return this.addFilter(new DataGridAutocompleteTableFilter(params));
+    };
+    DataGridTable.prototype.createAutocompleteListCardFilter = function (params) {
+        return this.addFilter(new DataGridAutocompleteListCardTableFilter(params));
+    };
+    DataGridTable.prototype.addColumn = function (column) {
+        this.nodes.push(column);
+        column.setContext(this);
+        return column;
+    };
+    DataGridTable.prototype.createGroup = function (groupParams) {
+        var group = this.addGroup(new DataGridColumnsGroup(groupParams));
+        return group;
+    };
+    DataGridTable.prototype.addGroup = function (group) {
+        this.nodes.push(group);
+        return group;
+    };
+    DataGridTable.prototype.createSubRow = function (params) {
+        var subRow = this.addSubRow(new DataGridSubRow(params));
+        return subRow;
+    };
+    DataGridTable.prototype.addSubRow = function (subRow) {
+        this.subRows.push(subRow);
+        return subRow;
+    };
+    DataGridTable.prototype.useStore = function () {
+        return useDataGridStore();
+    };
+    DataGridTable.prototype.useCreateStore = function (data, onCreate) {
+        return useDataGridCreateStore(this, data, onCreate);
+    };
+    DataGridTable.prototype.useColumn = function (column, store) {
+        return useDataGridColumn(column, store);
+    };
+    DataGridTable.prototype.useColumnEvents = function (column, subscribes, store) {
+        return useDataGridColumnEvents(column, subscribes, store);
+    };
+    DataGridTable.prototype.useColumnsInfo = function () {
+        return useDataGridColumnsInfo();
+    };
+    DataGridTable.prototype.useColumnsGroup = function (group, store) {
+        return useDataGridColumnsGroup(group, store);
+    };
+    DataGridTable.prototype.useColumnsGroupEvents = function (group, subscribes, store) {
+        return useDataGridColumnsGroupEvents(group, subscribes, store);
+    };
+    DataGridTable.prototype.useFilters = function (store) {
+        return useDataGridFilters(store);
+    };
+    DataGridTable.prototype.useFilter = function (filter, store) {
+        return useDataGridFilter(filter, store);
+    };
+    DataGridTable.prototype.useFilterEvents = function (filter, subscribes, store) {
+        return useDataGridFilterEvents(filter, subscribes, store);
+    };
+    DataGridTable.prototype.useFiltersEvents = function (subscribes, store) {
+        return useDataGridFiltersEvents(subscribes, store);
+    };
+    DataGridTable.prototype.usePagination = function (store) {
+        return useDataGridPagination(store);
+    };
+    DataGridTable.prototype.usePaginationEvents = function (subscribes, store) {
+        return useDataGridPaginationEvents(subscribes, store);
+    };
+    DataGridTable.prototype.useSelection = function (store) {
+        return useDataGridSelection(store);
+    };
+    DataGridTable.prototype.useSelectionEvents = function (subscribes, store) {
+        return useDataGridSelectionEvents(subscribes, store);
+    };
+    DataGridTable.prototype.useSubRow = function (subRow, store) {
+        return useDataGridSubRow(subRow, store);
+    };
+    DataGridTable.prototype.useSubRowEvents = function (subRow, subscribes, store) {
+        return useDataGridSubRowEvents(subRow, subscribes, store);
+    };
+    DataGridTable.prototype.useSubRows = function (store) {
+        return useDataGridSubRows(store);
+    };
+    DataGridTable.prototype.useSubRowsEvents = function (subscribes, store) {
+        return useDataGridSubRowsEvents(subscribes, store);
+    };
+    DataGridTable.prototype.useStoreEvents = function (subscribes, store) {
+        return useDataGridStoreEvents(subscribes, store);
+    };
+    return DataGridTable;
+}());
+export { DataGridTable };

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

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

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

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

package/__inner__/esm/index.js

@@ -0,0 +1,3 @@
+export * from './core';
+export * from './shared';
+export * from './ui';

package/__inner__/esm/shared/classNames/index.js

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

package/__inner__/esm/shared/classNames/utils/cn.js

@@ -0,0 +1,2 @@
+import { withNaming } from '@bem-react/classname';
+export var cn = withNaming({ n: '', e: '-', m: '_', v: '_' });

package/__inner__/esm/shared/classNames/utils/index.js

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

package/__inner__/esm/shared/css/index.js

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

package/__inner__/esm/shared/css/types/index.js

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

package/__inner__/esm/shared/css/types/unit.js

@@ -0,0 +1,17 @@
+export var cssUnit = [
+    'em',
+    'ex',
+    'ch',
+    'rem',
+    'vw',
+    'vh',
+    'vmin',
+    'vmax',
+    '%',
+    'cm',
+    'mm',
+    'in',
+    'px',
+    'pt',
+    'pc',
+];

package/__inner__/esm/shared/environment/constants/index.js

@@ -0,0 +1,2 @@
+export * from './isDev';
+export * from './isProduction';

package/__inner__/esm/shared/environment/constants/isDev.js

@@ -0,0 +1,2 @@
+import { isProduction } from './isProduction';
+export var isDev = !isProduction;

package/__inner__/esm/shared/environment/constants/isProduction.js

@@ -0,0 +1 @@
+export var isProduction = process.env.NODE_ENV === 'production';

package/__inner__/esm/shared/environment/index.js

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

package/__inner__/esm/shared/event-bus/entities/EventBus.js

@@ -0,0 +1,48 @@
+var EventBus = /** @class */ (function () {
+    function EventBus() {
+        this.listenersByEvent = {};
+    }
+    EventBus.prototype.subscribe = function (event, callback, isClearAfterCall) {
+        var _this = this;
+        if (isClearAfterCall === void 0) { isClearAfterCall = false; }
+        var listener = {
+            callback: callback,
+            isClearAfterCall: isClearAfterCall,
+        };
+        if (!this.listenersByEvent[event]) {
+            this.listenersByEvent[event] = new Set();
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this.listenersByEvent[event].add(listener);
+        return function () {
+            _this.unsubscribe(event, listener);
+        };
+    };
+    EventBus.prototype.publish = function (event, payload) {
+        var _this = this;
+        var listeners = this.listenersByEvent[event];
+        if (!listeners) {
+            return;
+        }
+        listeners.forEach(function (listener) {
+            var callback = listener.callback, isClearAfterCall = listener.isClearAfterCall;
+            callback(payload);
+            if (isClearAfterCall) {
+                _this.unsubscribe(event, listener);
+            }
+        });
+    };
+    EventBus.prototype.clear = function (event) {
+        var _a;
+        (_a = this.listenersByEvent[event]) === null || _a === void 0 ? void 0 : _a.clear();
+    };
+    EventBus.prototype.unsubscribe = function (event, listener) {
+        var listeners = this.listenersByEvent[event];
+        if (!listeners) {
+            return;
+        }
+        listeners.delete(listener);
+    };
+    return EventBus;
+}());
+export { EventBus };