ngx-register-base 1.3.1 → 1.3.2

package/esm2022/lib/core/register-base/register-base.mjs

@@ -0,0 +1,575 @@
+import { ChangeDetectorRef, DestroyRef, Directive, inject, } from '@angular/core';
+import { Router } from '@angular/router';
+import { BehaviorSubject, catchError, combineLatest, debounceTime, filter as rxjsFilter, map, ReplaySubject, switchMap, take, tap, throwError, } from 'rxjs';
+import { ERegisterObjectState, EInputsAction, EInputsState, } from '../../types';
+import { EColumnStatus, } from '../../components/column-settings/types/column-settings.types';
+import { SelectionTypes, } from '../../components/checkbox-selector/checkbox-selector.types';
+import { FiltersStateService, FiltersService, FiltersTransmitService, SelectedObjectsStateService, } from '../../services';
+import { SEARCH_INPUT_DEBOUNCE_TIME_MLS, SETTINGS_TYPE, USER_PROFILE_LOADER, USER_SETTINGS_LOADER, } from '../../consts/register-base.consts';
+import { getLastSegmentOfPathName, isNonNull } from '../../utils';
+import { DEFAULT_LIMIT } from '../../services/inputs-state.service';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import _ from 'lodash';
+import { RegisterBaseStore } from './register-base.store';
+import * as i0 from "@angular/core";
+export class RegisterBase {
+    get limit() {
+        return this._limit;
+    }
+    get offset() {
+        return this._offset;
+    }
+    /** Uuid'ы всех выбранных или исключаемых объектов реестра (зависит от состояния еще не загруженных объектов) */
+    get idsFromState() {
+        const service = this.selectedService;
+        if (!service) {
+            throw new Error('SelectedObjectsStateService не запровайжен');
+        }
+        return service.keys();
+    }
+    /** Все выбранные uuid'ы реестра */
+    get selectedIdsFromState() {
+        const service = this.selectedService;
+        if (!service) {
+            throw new Error('SelectedObjectsStateService не запровайжен');
+        }
+        return service.selectedKeys();
+    }
+    /** Все выбранные объекты реестра */
+    get selectedObjectsFromState() {
+        const service = this.selectedService;
+        if (!service) {
+            throw new Error('SelectedObjectsStateService не запровайжен');
+        }
+        return service.selectedValues();
+    }
+    constructor(injector, columnsData) {
+        this.injector = injector;
+        /** Сервисы управления фильтрами */
+        this.filtersService = inject(FiltersService);
+        this.stateService = inject(FiltersStateService);
+        this.transmitter = inject(FiltersTransmitService, { optional: true });
+        /** Сервис управления пользователем */
+        this.userService = inject(USER_PROFILE_LOADER);
+        /** Сервис управления данными в реестре */
+        this.baseStore = inject((RegisterBaseStore), { optional: true });
+        // TODO удалить optional: true после выполнения задачи SMA2-3134
+        this.selectedService = inject((SelectedObjectsStateService), {
+            optional: true,
+        });
+        // TODO protected readonly navigationService = inject(NavigationService);
+        this.router = inject(Router);
+        this.cdr = inject(ChangeDetectorRef);
+        this.destroyRef = inject(DestroyRef);
+        this.settingsService = inject(USER_SETTINGS_LOADER);
+        this.filterApplied$ = this.stateService.gqlValues$.pipe(map((filter) => Number(filter.length) > 0));
+        this.page$ = this.stateService.page$;
+        this.limit$ = this.stateService.limit$;
+        this.selectedRecordsLoading$ = new BehaviorSubject(false);
+        this.data = [];
+        this.visibleData = [];
+        this.dataCount = 0;
+        /** @deprecated Используйте selectedObjectsFromState */
+        this.selectedObjects = new Set();
+        /** @deprecated Используйте selectedIdsFromState */
+        this.selectedIds = new Set();
+        this._user = this.userService.getUserProfile();
+        this.stickyLeftIds = [];
+        this.stickyRightIds = [];
+        this.currentFilter = null;
+        this.filterState = [];
+        this._modulePath = getLastSegmentOfPathName(this.router.url);
+        this._defaultFilterApplied$ = new ReplaySubject();
+        /**
+         * Контрол строки поиска
+         */
+        this.searchInput = this.filtersService.searchInput;
+        this._selectionType$ = this.selectedService?.selectionType$ ?? new BehaviorSubject(null);
+        this.stateObjects = this.selectedService?.state;
+        this.columnsData = columnsData;
+        this._defaultColumnsWidths = new Map(columnsData.map((col) => [col.name, col.width]));
+        this.columns = this._getDefaultColumnsRecursive(columnsData);
+        this._subscribeOnSettings();
+        this._fetchSavedPageRowsLimit();
+        const state = this.router.getCurrentNavigation()?.extras?.state;
+        if (state) {
+            this.filterState = this.parseToFilters(state);
+        }
+    }
+    _subscribeOnSettings() {
+        this.settingsService.settings$
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(([userSetting]) => {
+            const { tableColumnsWidth } = userSetting?.settings ?? {};
+            const type = userSetting?.settings_type;
+            if (type && type !== SETTINGS_TYPE.COLUMNS) {
+                return;
+            }
+            const cleanedCurrent = this._omitUndefined(this._columnsSettings?.settings.tableColumnsWidth);
+            const cleanedNew = this._omitUndefined(tableColumnsWidth);
+            if (!_.isEqual(cleanedCurrent, cleanedNew)) {
+                this._setColumnsWidth(tableColumnsWidth);
+            }
+            this._columnsSettings = userSetting;
+        });
+    }
+    _omitUndefined(arr) {
+        return _.map(arr ?? [], (obj) => _.omitBy(obj, _.isUndefined));
+    }
+    _setColumnsWidth(columnsWidth) {
+        const thsWidthMap = new Map(columnsWidth?.map(({ name, width }) => [name, width]));
+        this.columnsData = this.columnsData.map((col) => {
+            const defaultWidth = this._defaultColumnsWidths.get(col.name);
+            const currentWidth = thsWidthMap.has(col.name) ? thsWidthMap.get(col.name) : null;
+            const width = currentWidth === null ? defaultWidth : currentWidth;
+            return {
+                ...col,
+                width,
+            };
+        });
+    }
+    _fetchSavedPageRowsLimit() {
+        this.settingsService
+            .fetchUserSettings$({
+            id_user: {
+                _eq: this._user.id,
+            },
+            settings_type: {
+                _eq: SETTINGS_TYPE.REGISTER_PAGE_ROWS_LIMIT,
+            },
+            module_name: {
+                _eq: this._modulePath,
+            },
+        }, true)
+            .subscribe(([firstSetting]) => {
+            this._pageRowsLimitSetting = firstSetting;
+            const { pageRowsLimit } = firstSetting?.settings ?? {};
+            this.stateService.setLimit(pageRowsLimit ?? DEFAULT_LIMIT);
+        });
+    }
+    ngOnInit() {
+        this.filtersForm = this.buildForm;
+        this.filtersService.init(this.filtersForm);
+        this.stateService.setState({ state: EInputsState.HIDDEN, action: EInputsAction.OPEN });
+        this.fetchTotalObjects(this.baseFilter(this._user));
+        this._subscribeOnMutationCompleted();
+        this.subscribeOnPaging();
+        // TODO проверить нужна ли Перезагрузка страницы
+        // if (this.navigationService.previousUrl === null) {
+        //   this.stateService.setOffset(0);
+        //   this.stateService.setPage(1);
+        // }
+        this.baseStore?.count$?.subscribe((count) => {
+            this.dataCount = count;
+            this.stateService.setCount(count);
+        });
+    }
+    ngAfterViewInit(searchLimiter = 2) {
+        this._setFilters();
+        this.subscribeOnSearchChanges(searchLimiter);
+    }
+    _setFilters() {
+        const queryFilters = this.transmitter?.filters;
+        const querySearch = this.transmitter?.search;
+        let filters;
+        if (querySearch) {
+            this.searchInput.setValue(querySearch);
+        }
+        if (!queryFilters || queryFilters.length > 0) {
+            filters = queryFilters || [];
+        }
+        this.applyBaseFilter();
+        this._initDefaultFilter(filters);
+    }
+    applyBaseFilter(_data) { }
+    ngOnDestroy() {
+        this.actionCompleted$.complete();
+        this.selectedRecordsLoading$.complete();
+        this.filtersService.clear();
+        this.stateService.setOffset(0);
+        this.stateService.setGqlValues({});
+        if (this.searchInput?.value) {
+            this.stateService.setSearchFilterValue('');
+            this.stateService.setGqlValues(this.filtersService.gqlFilter);
+        }
+    }
+    applyFilters(filters) {
+        this.filtersService.setUserSettingsFilterValues(filters);
+        this.stateService.setGqlValues(this.filtersService.gqlFilter);
+    }
+    setData(data, count) {
+        this.data = data;
+        if (count !== undefined) {
+            this.dataCount = count;
+            this.stateService.setCount(count);
+        }
+        this.cdr.markForCheck();
+    }
+    updateAllStateObjectsByState(state) {
+        this.selectedService?.setAllStateObjectsByState(state);
+    }
+    updateStateObjectByKey(key, updates) {
+        this.selectedService?.setStateObjectByKey(key, updates);
+    }
+    clearSelections(data) {
+        this.selectedIds.clear();
+        this.selectedObjects.clear();
+        if (this.selectedService) {
+            this.selectedService?.resetState(data);
+            this.buildActions({
+                row: [],
+                count: 0,
+            });
+        }
+    }
+    actionCompleted() {
+        const filter = this.buildFilter(this.limit, this.offset, this._filterState);
+        this.currentFilter = filter;
+        this.clearSelections();
+        this.objectsSubscription({ filter });
+    }
+    buildActions(_data) { }
+    subscribeOnSearchChanges(limiter) {
+        this.searchInput?.valueChanges
+            .pipe(rxjsFilter((value) => !value || value.length > limiter), debounceTime(SEARCH_INPUT_DEBOUNCE_TIME_MLS), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            this.stateService.setGqlValues(this.filtersService.gqlFilter);
+        });
+    }
+    updateRegister() {
+        this.stateService.setLimit(this.stateService.limit);
+    }
+    subscribeOnPaging() {
+        this._defaultFilterApplied$
+            .pipe(take(1), switchMap(() => combineLatest([
+            this.stateService.limit$.pipe(rxjsFilter(isNonNull)),
+            this.stateService.offset$,
+            this.stateService.gqlValues$.pipe(tap((data) => {
+                if (Number(data.length) > 0) {
+                    this.selectChanged(null);
+                }
+            })),
+            this.stateService.sorter$,
+        ]).pipe(debounceTime(250))), catchError((e) => {
+            console.error('pagination', e);
+            return throwError(() => new Error(e));
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe(([limit, offset, gqlFilter, sorter]) => {
+            const filter = this.buildFilter(limit, offset, gqlFilter, sorter);
+            const gqlFilterUpdated = !_.isEqual(this._filterState, gqlFilter);
+            this.currentFilter = filter;
+            this._filterState = gqlFilter;
+            this._limit = limit;
+            this._offset = offset;
+            if (this.stateObjects) {
+                if (gqlFilterUpdated) {
+                    this.selectedService?.resetState();
+                }
+                this.objectsSubscription({ filter, callback: this._setStateObjects.bind(this) });
+            }
+            else {
+                this.objectsSubscription({ filter });
+            }
+            this.fetchTotalFilteredObjects?.(filter.where);
+        });
+    }
+    _setStateObjects(data) {
+        this.selectedService?.loadStateObjects(data);
+    }
+    selectChanged(value) {
+        this._selectionType$.next(value);
+        const stateObjects = this.stateObjects;
+        if (stateObjects) {
+            this._changeStateObjects(stateObjects(), value);
+            return;
+        }
+        const filter = this._selectChangedFilter(value);
+        this.currentFilter = filter;
+        this.buildActions({
+            row: [...(this.selectedObjects ?? [])],
+            count: this.selectedObjects ? this.selectedObjects.size : 0,
+        });
+        if (!filter) {
+            return;
+        }
+        this.selectedRecordsLoading$.next(true);
+        this.objectsSubscription({
+            filter,
+            callback: this._setSelected.bind(this),
+        });
+    }
+    _changeStateObjects(stateObjects, value) {
+        if (value === SelectionTypes.ALL) {
+            this.updateAllStateObjectsByState(ERegisterObjectState.SELECTED);
+        }
+        else if (value === SelectionTypes.INVERSE) {
+            this._inverseStateObjects(stateObjects);
+        }
+        else if (value === SelectionTypes.VISIBLE) {
+            this._selectVisibleStateObjects();
+        }
+        else if (typeof value === 'number') {
+            this._selectFirstNStateObjects(value);
+        }
+        else {
+            this.clearSelections(this.data);
+        }
+        this.buildActions({
+            row: [...this.selectedObjectsFromState],
+            count: this.selectedObjectsFromState.size,
+        });
+    }
+    _inverseStateObjects(stateObjects) {
+        for (const [key, { state }] of stateObjects) {
+            const inverseState = state === ERegisterObjectState.SELECTED
+                ? ERegisterObjectState.UNSELECTED
+                : ERegisterObjectState.SELECTED;
+            this.updateStateObjectByKey(key, { state: inverseState });
+        }
+    }
+    _selectVisibleStateObjects() {
+        this.updateAllStateObjectsByState(ERegisterObjectState.UNSELECTED);
+        for (const visibleObject of this.visibleData) {
+            this.updateStateObjectByKey(visibleObject.id, { state: ERegisterObjectState.SELECTED });
+        }
+    }
+    _selectFirstNStateObjects(value) {
+        this.updateAllStateObjectsByState(ERegisterObjectState.UNSELECTED);
+        if (value > this.limit) {
+            const { sorter } = this.stateService;
+            const filter = this.buildFilter(value, this.offset, this._filterState, sorter.length > 0 ? sorter : undefined);
+            this.objectsSubscription({
+                filter,
+                callback: this._selectFirstNLoadingObjects.bind(this),
+                noSet: true,
+            });
+        }
+        else {
+            const firstNObjects = this.data.slice(0, value);
+            this._selectFirstNLoadingObjects(firstNObjects);
+        }
+    }
+    _selectFirstNLoadingObjects(objects) {
+        for (const object of objects) {
+            this.updateStateObjectByKey(object.id, { state: ERegisterObjectState.SELECTED, object });
+        }
+    }
+    filterToggle() {
+        this.stateService.toggle();
+    }
+    onPaginatorChange(paginatorChange) {
+        const { rows, first, page } = paginatorChange;
+        if (this.stateService.limit !== rows) {
+            this.stateService.setLimit(rows);
+            this._savePageRowsLimit(rows);
+        }
+        if (this.stateService.offset !== first - 1) {
+            this.stateService.setOffset(first - 1);
+        }
+        if (this.stateService.page !== page) {
+            this.stateService.setPage(page);
+        }
+    }
+    _savePageRowsLimit(pageRowsLimit) {
+        this.settingsService
+            .upsertReturningOne$(SETTINGS_TYPE.REGISTER_PAGE_ROWS_LIMIT)
+            .subscribe((setting) => {
+            this._pageRowsLimitSetting = setting || undefined;
+        });
+        this.settingsService.upsertUserSettingsByUserId({
+            settings: {
+                id: this._pageRowsLimitSetting?.id,
+                settings_type: SETTINGS_TYPE.REGISTER_PAGE_ROWS_LIMIT,
+                module_name: this._modulePath,
+                settings: { pageRowsLimit },
+            },
+            hidden: true,
+        });
+    }
+    updateColumnSettings({ settings }) {
+        if (settings) {
+            this.stickyLeftIds = this._getColumnIdsRecursive(settings.stickyLeft);
+            this.stickyRightIds = this._getColumnIdsRecursive(settings.stickyRight, (el) => el.status === EColumnStatus.DEFAULT);
+            this.columns = [
+                ...this.stickyLeftIds,
+                ...this._getColumnIdsRecursive(settings.columns, (el) => el.status === EColumnStatus.DEFAULT),
+                ...this.stickyRightIds,
+            ];
+        }
+        this.cdr.markForCheck();
+    }
+    _getColumnIdsRecursive(columns, predicate) {
+        const filteredColumns = predicate
+            ? columns.filter((col, index, array) => predicate(col, index, array))
+            : columns;
+        return filteredColumns.flatMap((column) => {
+            const { id, children } = column;
+            if (children) {
+                return [id, ...this._getColumnIdsRecursive(children, predicate)];
+            }
+            return [id];
+        });
+    }
+    updateSort(sort) {
+        this.stateService.setSorter(sort);
+    }
+    saveThsWidthToUserSettings(tableColumnsWidth) {
+        const settings = this._columnsSettings;
+        if (settings) {
+            settings.settings.tableColumnsWidth = tableColumnsWidth;
+        }
+        this.settingsService.upsertUserSettingsByUserId({
+            settings: {
+                id: this._columnsSettings?.id,
+                settings_type: SETTINGS_TYPE.COLUMNS,
+                module_name: this._modulePath,
+                settings: { ...this._columnsSettings?.settings, tableColumnsWidth },
+            },
+            hidden: true,
+            updateSettings: true,
+        });
+    }
+    get filtersAreOpened() {
+        return this.stateService.state.state !== EInputsState.HIDDEN;
+    }
+    _subscribeOnMutationCompleted() {
+        this.actionCompleted$
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => this.actionCompleted());
+    }
+    _initDefaultFilter(queryFilters) {
+        this.settingsService
+            .fetchUserSettings$({
+            id_user: {
+                _eq: this._user.id,
+            },
+            settings_type: {
+                _in: [SETTINGS_TYPE.FILTER, SETTINGS_TYPE.REGISTER_PINNED_INPUTS],
+            },
+            module_name: {
+                _eq: this._modulePath,
+            },
+        })
+            .pipe(take(1))
+            .subscribe((userSettings) => {
+            const pinnedFilter = userSettings.find(({ settings_type: type }) => type === SETTINGS_TYPE.REGISTER_PINNED_INPUTS);
+            const isPinned = !!pinnedFilter?.settings.pinned;
+            const favoriteFilter = userSettings.find(({ settings }) => settings.favorite);
+            if (isPinned) {
+                this.stateService.setPin(true);
+                this.stateService.setState({
+                    state: EInputsState.FILTER_LIST,
+                    action: EInputsAction.APPLY_SAVED_FILTER,
+                });
+            }
+            if (queryFilters || this.searchInput?.getRawValue()) {
+                this.applyFilters(queryFilters ?? []);
+            }
+            else if (pinnedFilter && isPinned) {
+                this._applyFilterSettings(pinnedFilter);
+            }
+            else if (favoriteFilter) {
+                this._applyFilterSettings(favoriteFilter);
+            }
+            this._defaultFilterApplied$.next(true);
+        });
+    }
+    _applyFilterSettings(settings) {
+        this.filtersService.setUserSettingsFilterValues(settings.settings.filter ?? []);
+        const { gqlFilter } = this.filtersService;
+        this.stateService.setGqlValues(gqlFilter);
+        this.stateService.setState({
+            state: EInputsState.HIDDEN,
+            action: EInputsAction.APPLY_SAVED_FILTER,
+        });
+    }
+    _selectChangedFilter(selection) {
+        let filter = null;
+        if (selection === null) {
+            this.clearSelections();
+            return;
+        }
+        if (selection === SelectionTypes.ALL || typeof selection === 'number') {
+            filter = this._handleAllOrNumberSelection(selection);
+        }
+        else if (selection === SelectionTypes.VISIBLE) {
+            this._selectVisibleItems();
+        }
+        else if (selection === SelectionTypes.INVERSE) {
+            filter = this._handleInverseSelection();
+        }
+        return filter;
+    }
+    _handleAllOrNumberSelection(selection) {
+        let filter = null;
+        const { sorter } = this.stateService;
+        if (selection === SelectionTypes.ALL) {
+            filter = this.buildFilter(undefined, undefined, this._filterState);
+        }
+        else if (typeof selection === 'number') {
+            if (selection > this.limit) {
+                filter = this.buildFilter(selection, 0, this._filterState, sorter.length > 0 ? sorter : undefined);
+            }
+            else {
+                this._selectFirstNItems(selection);
+            }
+        }
+        return filter;
+    }
+    _selectFirstNItems(count) {
+        this.selectedObjects = new Set(this.data.slice(0, count));
+        this.selectedIds = new Set(this.data.map((d) => d.id).slice(0, count));
+    }
+    _selectVisibleItems() {
+        this.selectedObjects = new Set(this.visibleData);
+        this.selectedIds = new Set(this.visibleData.map((d) => d.id));
+    }
+    _handleInverseSelection() {
+        const inverseFilter = { id: { _nin: [...this.selectedIds] } };
+        const updatedFilterState = Array.isArray(this._filterState)
+            ? [...this._filterState, inverseFilter]
+            : [this._filterState, inverseFilter];
+        return this.buildFilter(undefined, undefined, updatedFilterState);
+    }
+    _setSelected(data) {
+        this.selectedObjects = new Set(data);
+        this.selectedIds = new Set(data.map((d) => d.id));
+        this.selectedRecordsLoading$.next(false);
+    }
+    parseToFilters(input) {
+        return Object.entries(input).map(([key, value]) => ({
+            id: key,
+            value,
+        }));
+    }
+    get selectedCount() {
+        const selectedSize = this.selectedService?.selectedValues()?.size ?? null;
+        const unselectedSize = this.selectedService?.unselectedValues()?.size ?? 0;
+        const unfetchedObjects = this.selectedService?.stateUnfetchedObjects();
+        const isNotSelected = unfetchedObjects !== ERegisterObjectState.SELECTED;
+        if (selectedSize === null) {
+            return this.selectedIds.size;
+        }
+        return isNotSelected ? selectedSize : this.dataCount - unselectedSize;
+    }
+    _getDefaultColumnsRecursive(columnsData) {
+        return columnsData.flatMap((column) => {
+            const { name, children } = column;
+            if (children) {
+                return [name, ...this._getDefaultColumnsRecursive(children)];
+            }
+            return [name];
+        });
+    }
+    get notAllFetched() {
+        const unfetchedState = this.selectedService.stateUnfetchedObjects();
+        const allFetched = this.stateObjects().size === this.dataCount;
+        return unfetchedState === ERegisterObjectState.SELECTED && !allFetched;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RegisterBase, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: RegisterBase, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RegisterBase, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: undefined }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"register-base.js","sourceRoot":"","sources":["../../../../../../projects/ngx-register-base/src/lib/core/register-base/register-base.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectorRef,\n  DestroyRef,\n  Directive,\n  inject,\n  Injector,\n  OnDestroy,\n  OnInit,\n} from '@angular/core';\nimport { Router } from '@angular/router';\nimport {\n  BehaviorSubject,\n  catchError,\n  combineLatest,\n  debounceTime,\n  filter as rxjsFilter,\n  map,\n  Observable,\n  ReplaySubject,\n  Subscription,\n  switchMap,\n  take,\n  tap,\n  throwError,\n} from 'rxjs';\nimport {\n  ERegisterObjectState,\n  IRegisterBase,\n  IRegisterObject,\n  ITpUserSettings,\n  ITpUserSettingsSettingsFilter,\n  ObjectsSubscriptionConfig,\n  IUserProfile,\n  EInputsAction,\n  EInputsState,\n  GqlField,\n  GqlFields,\n} from '../../types';\nimport {\n  EColumnStatus,\n  IColumnSettings,\n  IColumnSettingsChanges,\n} from '../../components/column-settings/types/column-settings.types';\nimport {\n  IColumnData,\n  IHasuraQueryFilter,\n  RegisterTableCellSorter,\n  ThWidthEntry,\n} from '../../components';\nimport {\n  ApplySelectionTypes,\n  SelectionTypes,\n} from '../../components/checkbox-selector/checkbox-selector.types';\nimport {\n  FiltersStateService,\n  FiltersService,\n  FiltersTransmitService,\n  SelectedObjectsStateService,\n} from '../../services';\nimport {\n  SEARCH_INPUT_DEBOUNCE_TIME_MLS,\n  SETTINGS_TYPE,\n  USER_PROFILE_LOADER,\n  USER_SETTINGS_LOADER,\n} from '../../consts/register-base.consts';\nimport { getLastSegmentOfPathName, isNonNull } from '../../utils';\nimport { FormGroupWrapper } from '../form-group-wrapper';\nimport { DEFAULT_LIMIT } from '../../services/inputs-state.service';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport _ from 'lodash';\nimport { ScalarUUID } from 'hasura';\nimport { RegisterBaseStore } from './register-base.store';\n\n@Directive()\nexport abstract class RegisterBase<T extends IRegisterBase, Form = any>\n  implements OnInit, AfterViewInit, OnDestroy\n{\n  /** Сервисы управления фильтрами */\n  protected readonly filtersService = inject(FiltersService);\n  protected readonly stateService = inject(FiltersStateService);\n  protected readonly transmitter = inject(FiltersTransmitService, { optional: true });\n  /** Сервис управления пользователем */\n  protected readonly userService = inject(USER_PROFILE_LOADER);\n  /** Сервис управления данными в реестре */\n  protected readonly baseStore = inject(RegisterBaseStore<T>, { optional: true });\n  // TODO удалить optional: true после выполнения задачи SMA2-3134\n  protected readonly selectedService = inject(SelectedObjectsStateService<T>, {\n    optional: true,\n  });\n  // TODO protected readonly navigationService = inject(NavigationService);\n  protected readonly router = inject(Router);\n  protected readonly cdr = inject(ChangeDetectorRef);\n  protected readonly destroyRef = inject(DestroyRef);\n\n  private readonly settingsService = inject(USER_SETTINGS_LOADER);\n\n  public readonly filterApplied$: Observable<boolean> = this.stateService.gqlValues$.pipe(\n    map((filter) => Number(filter.length) > 0)\n  );\n  public readonly page$ = this.stateService.page$;\n  public readonly limit$ = this.stateService.limit$;\n  public readonly selectedRecordsLoading$ = new BehaviorSubject(false);\n\n  public columnsData: IColumnData[];\n  public columns: string[];\n  public data: T[] = [];\n  public visibleData: T[] = [];\n  public dataCount = 0;\n  /** @deprecated Используйте selectedObjectsFromState */\n  public selectedObjects = new Set<any>();\n  /** @deprecated Используйте selectedIdsFromState */\n  public selectedIds = new Set<ScalarUUID>();\n  public _user = this.userService.getUserProfile();\n  public stickyLeftIds: string[] = [];\n  public stickyRightIds: string[] = [];\n  public currentFilter: IHasuraQueryFilter<T> | null = null;\n  /**\n   * Форма фильтров\n   */\n  protected filtersForm!: FormGroupWrapper<Form>;\n  protected filterState: ITpUserSettingsSettingsFilter[] = [];\n\n  private _limit!: number;\n  private _offset!: number;\n  private _filterState!: GqlFields;\n  private _modulePath = getLastSegmentOfPathName(this.router.url);\n  private _defaultFilterApplied$ = new ReplaySubject<boolean>();\n  /**\n   * Всего записей, без учета фильтра\n   */\n  public abstract totalNotFiltered$: Observable<number>;\n  /**\n   * Маршруты для бредкрамба\n   */\n  public abstract routes: any[];\n  /**\n   * Контрол строки поиска\n   */\n  public searchInput = this.filtersService.searchInput!;\n  /**\n   * Действие завершено\n   */\n  public abstract actionCompleted$: ReplaySubject<boolean>;\n  /**\n   * Получение общего количества записей\n   */\n  public abstract fetchTotalObjects: (\n    observableOrValue: Record<string, any> | Observable<Record<string, any>>\n  ) => Subscription;\n  /**\n   * Запрос на количество отфильтрованных записей\n   */\n  public fetchTotalFilteredObjects:\n    | ((observableOrValue: Record<string, any> | Observable<Record<string, any>>) => Subscription)\n    | undefined;\n  /**\n   * Подписка на получение всех объектов и с обратным вызовом\n   */\n  public abstract objectsSubscription: (\n    observableOrValue: ObjectsSubscriptionConfig<T> | Observable<ObjectsSubscriptionConfig<T>>\n  ) => Subscription;\n  /**\n   * Базовый фильтр, по умолчанию\n   */\n  public abstract baseFilter: (user: IUserProfile | undefined) => Record<string, any>;\n\n  /**\n   * Сборка фильтра\n   */\n  public abstract buildFilter(\n    limit?: number,\n    offset?: number,\n    gqlFilter?: GqlFields,\n    sorter?: RegisterTableCellSorter<T>[]\n  ): any;\n\n  /**\n   * Сборка фильтров реестра\n   */\n  protected abstract get buildForm(): FormGroupWrapper<Form>;\n\n  public get limit(): number {\n    return this._limit;\n  }\n\n  public get offset(): number {\n    return this._offset;\n  }\n\n  /** Uuid'ы всех выбранных или исключаемых объектов реестра (зависит от состояния еще не загруженных объектов) */\n  public get idsFromState(): Set<ScalarUUID> {\n    const service: SelectedObjectsStateService<T> | null = this.selectedService;\n\n    if (!service) {\n      throw new Error('SelectedObjectsStateService не запровайжен');\n    }\n\n    return service.keys();\n  }\n\n  /** Все выбранные uuid'ы реестра */\n  public get selectedIdsFromState(): Set<ScalarUUID> {\n    const service: SelectedObjectsStateService<T> | null = this.selectedService;\n\n    if (!service) {\n      throw new Error('SelectedObjectsStateService не запровайжен');\n    }\n\n    return service.selectedKeys();\n  }\n\n  /** Все выбранные объекты реестра */\n  public get selectedObjectsFromState(): Set<T> {\n    const service: SelectedObjectsStateService<T> | null = this.selectedService;\n\n    if (!service) {\n      throw new Error('SelectedObjectsStateService не запровайжен');\n    }\n\n    return service.selectedValues();\n  }\n\n  private _columnsSettings: ITpUserSettings | undefined;\n  private _pageRowsLimitSetting: ITpUserSettings | undefined;\n\n  private readonly _defaultColumnsWidths: Map<string, string | undefined>;\n\n  private readonly _selectionType$ =\n    this.selectedService?.selectionType$ ?? new BehaviorSubject<ApplySelectionTypes>(null);\n\n  public readonly stateObjects = this.selectedService?.state;\n\n  protected constructor(\n    protected readonly injector: Injector,\n    columnsData: IColumnData[]\n  ) {\n    this.columnsData = columnsData;\n    this._defaultColumnsWidths = new Map(columnsData.map((col) => [col.name, col.width]));\n    this.columns = this._getDefaultColumnsRecursive(columnsData);\n    this._subscribeOnSettings();\n    this._fetchSavedPageRowsLimit();\n    const state = this.router.getCurrentNavigation()?.extras?.state;\n    if (state) {\n      this.filterState = this.parseToFilters(state);\n    }\n  }\n\n  private _subscribeOnSettings(): void {\n    this.settingsService.settings$\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe(([userSetting]) => {\n        const { tableColumnsWidth } = userSetting?.settings ?? {};\n        const type = userSetting?.settings_type;\n\n        if (type && type !== SETTINGS_TYPE.COLUMNS) {\n          return;\n        }\n\n        const cleanedCurrent = this._omitUndefined(\n          this._columnsSettings?.settings.tableColumnsWidth\n        );\n        const cleanedNew = this._omitUndefined(tableColumnsWidth);\n\n        if (!_.isEqual(cleanedCurrent, cleanedNew)) {\n          this._setColumnsWidth(tableColumnsWidth);\n        }\n\n        this._columnsSettings = userSetting;\n      });\n  }\n\n  private _omitUndefined(arr: ThWidthEntry[] | undefined) {\n    return _.map(arr ?? [], (obj) => _.omitBy(obj, _.isUndefined));\n  }\n\n  private _setColumnsWidth(columnsWidth: ThWidthEntry[] | undefined): void {\n    const thsWidthMap = new Map(columnsWidth?.map(({ name, width }) => [name, width]));\n\n    this.columnsData = this.columnsData.map((col) => {\n      const defaultWidth = this._defaultColumnsWidths.get(col.name)!;\n      const currentWidth = thsWidthMap.has(col.name) ? thsWidthMap.get(col.name) : null;\n\n      const width = currentWidth === null ? defaultWidth : currentWidth;\n\n      return {\n        ...col,\n        width,\n      };\n    });\n  }\n\n  private _fetchSavedPageRowsLimit(): void {\n    this.settingsService\n      .fetchUserSettings$(\n        {\n          id_user: {\n            _eq: this._user.id,\n          },\n          settings_type: {\n            _eq: SETTINGS_TYPE.REGISTER_PAGE_ROWS_LIMIT,\n          },\n          module_name: {\n            _eq: this._modulePath,\n          },\n        },\n        true\n      )\n      .subscribe(([firstSetting]) => {\n        this._pageRowsLimitSetting = firstSetting;\n        const { pageRowsLimit } = firstSetting?.settings ?? {};\n\n        this.stateService.setLimit(pageRowsLimit ?? DEFAULT_LIMIT);\n      });\n  }\n\n  public ngOnInit(): void {\n    this.filtersForm = this.buildForm;\n    this.filtersService.init(this.filtersForm);\n    this.stateService.setState({ state: EInputsState.HIDDEN, action: EInputsAction.OPEN });\n\n    this.fetchTotalObjects(this.baseFilter(this._user));\n    this._subscribeOnMutationCompleted();\n    this.subscribeOnPaging();\n\n    // TODO проверить нужна ли Перезагрузка страницы\n    // if (this.navigationService.previousUrl === null) {\n    //   this.stateService.setOffset(0);\n    //   this.stateService.setPage(1);\n    // }\n\n    this.baseStore?.count$?.subscribe((count) => {\n      this.dataCount = count;\n      this.stateService.setCount(count);\n    });\n  }\n\n  public ngAfterViewInit(searchLimiter = 2): void {\n    this._setFilters();\n    this.subscribeOnSearchChanges(searchLimiter);\n  }\n\n  private _setFilters(): void {\n    const queryFilters = this.transmitter?.filters;\n    const querySearch = this.transmitter?.search;\n    let filters: ITpUserSettingsSettingsFilter[] | undefined;\n\n    if (querySearch) {\n      this.searchInput.setValue(querySearch);\n    }\n\n    if (!queryFilters || queryFilters.length > 0) {\n      filters = queryFilters || [];\n    }\n\n    this.applyBaseFilter();\n    this._initDefaultFilter(filters);\n  }\n\n  protected applyBaseFilter(_data?: any): void {}\n\n  public ngOnDestroy(): void {\n    this.actionCompleted$.complete();\n    this.selectedRecordsLoading$.complete();\n    this.filtersService.clear();\n    this.stateService.setOffset(0);\n    this.stateService.setGqlValues({});\n\n    if (this.searchInput?.value) {\n      this.stateService.setSearchFilterValue('');\n      this.stateService.setGqlValues(this.filtersService.gqlFilter);\n    }\n  }\n\n  protected applyFilters(filters: ITpUserSettingsSettingsFilter[]): void {\n    this.filtersService.setUserSettingsFilterValues(filters);\n    this.stateService.setGqlValues(this.filtersService.gqlFilter);\n  }\n\n  protected setData(data: T[], count?: number): void {\n    this.data = data;\n\n    if (count !== undefined) {\n      this.dataCount = count;\n      this.stateService.setCount(count);\n    }\n\n    this.cdr.markForCheck();\n  }\n\n  protected updateAllStateObjectsByState(state: ERegisterObjectState): void {\n    this.selectedService?.setAllStateObjectsByState(state);\n  }\n\n  protected updateStateObjectByKey(key: ScalarUUID, updates: Partial<IRegisterObject<T>>): void {\n    this.selectedService?.setStateObjectByKey(key, updates);\n  }\n\n  protected clearSelections(data?: T[]): void {\n    this.selectedIds.clear();\n    this.selectedObjects.clear();\n\n    if (this.selectedService) {\n      this.selectedService?.resetState(data);\n      this.buildActions({\n        row: [],\n        count: 0,\n      });\n    }\n  }\n\n  protected actionCompleted(): void {\n    const filter = this.buildFilter(this.limit, this.offset, this._filterState);\n    this.currentFilter = filter;\n\n    this.clearSelections();\n    this.objectsSubscription({ filter });\n  }\n\n  protected buildActions(_data: { row: T[]; count: number }): void {}\n\n  protected subscribeOnSearchChanges(limiter: number): void {\n    this.searchInput?.valueChanges\n      .pipe(\n        rxjsFilter((value) => !value || value.length > limiter),\n        debounceTime(SEARCH_INPUT_DEBOUNCE_TIME_MLS),\n        takeUntilDestroyed(this.destroyRef)\n      )\n      .subscribe(() => {\n        this.stateService.setGqlValues(this.filtersService.gqlFilter);\n      });\n  }\n\n  public updateRegister(): void {\n    this.stateService.setLimit(this.stateService.limit);\n  }\n\n  public subscribeOnPaging(): void {\n    this._defaultFilterApplied$\n      .pipe(\n        take(1),\n        switchMap(() =>\n          combineLatest([\n            this.stateService.limit$.pipe(rxjsFilter(isNonNull)),\n            this.stateService.offset$,\n            this.stateService.gqlValues$.pipe(\n              tap((data) => {\n                if (Number(data.length) > 0) {\n                  this.selectChanged(null);\n                }\n              })\n            ),\n            this.stateService.sorter$,\n          ]).pipe(debounceTime(250))\n        ),\n        catchError((e) => {\n          console.error('pagination', e);\n\n          return throwError(() => new Error(e));\n        }),\n        takeUntilDestroyed(this.destroyRef)\n      )\n      .subscribe(([limit, offset, gqlFilter, sorter]) => {\n        const filter = this.buildFilter(limit, offset, gqlFilter, sorter);\n        const gqlFilterUpdated = !_.isEqual(this._filterState, gqlFilter);\n        this.currentFilter = filter;\n        this._filterState = gqlFilter;\n        this._limit = limit;\n        this._offset = offset;\n        if (this.stateObjects) {\n          if (gqlFilterUpdated) {\n            this.selectedService?.resetState();\n          }\n\n          this.objectsSubscription({ filter, callback: this._setStateObjects.bind(this) });\n        } else {\n          this.objectsSubscription({ filter });\n        }\n        this.fetchTotalFilteredObjects?.(filter.where);\n      });\n  }\n\n  private _setStateObjects(data: T[]): void {\n    this.selectedService?.loadStateObjects(data);\n  }\n\n  public selectChanged(value: ApplySelectionTypes): void {\n    this._selectionType$.next(value);\n\n    const stateObjects = this.stateObjects;\n\n    if (stateObjects) {\n      this._changeStateObjects(stateObjects(), value);\n\n      return;\n    }\n\n    const filter = this._selectChangedFilter(value);\n    this.currentFilter = filter;\n\n    this.buildActions({\n      row: [...(this.selectedObjects ?? [])],\n      count: this.selectedObjects ? this.selectedObjects.size : 0,\n    });\n\n    if (!filter) {\n      return;\n    }\n\n    this.selectedRecordsLoading$.next(true);\n    this.objectsSubscription({\n      filter,\n      callback: this._setSelected.bind(this),\n    });\n  }\n\n  private _changeStateObjects(\n    stateObjects: Map<ScalarUUID, IRegisterObject<T>>,\n    value: ApplySelectionTypes\n  ): void {\n    if (value === SelectionTypes.ALL) {\n      this.updateAllStateObjectsByState(ERegisterObjectState.SELECTED);\n    } else if (value === SelectionTypes.INVERSE) {\n      this._inverseStateObjects(stateObjects);\n    } else if (value === SelectionTypes.VISIBLE) {\n      this._selectVisibleStateObjects();\n    } else if (typeof value === 'number') {\n      this._selectFirstNStateObjects(value);\n    } else {\n      this.clearSelections(this.data);\n    }\n\n    this.buildActions({\n      row: [...this.selectedObjectsFromState],\n      count: this.selectedObjectsFromState.size,\n    });\n  }\n\n  private _inverseStateObjects(stateObjects: Map<ScalarUUID, IRegisterObject<T>>): void {\n    for (const [key, { state }] of stateObjects) {\n      const inverseState =\n        state === ERegisterObjectState.SELECTED\n          ? ERegisterObjectState.UNSELECTED\n          : ERegisterObjectState.SELECTED;\n\n      this.updateStateObjectByKey(key, { state: inverseState });\n    }\n  }\n\n  private _selectVisibleStateObjects(): void {\n    this.updateAllStateObjectsByState(ERegisterObjectState.UNSELECTED);\n    for (const visibleObject of this.visibleData) {\n      this.updateStateObjectByKey(visibleObject.id, { state: ERegisterObjectState.SELECTED });\n    }\n  }\n\n  private _selectFirstNStateObjects(value: number): void {\n    this.updateAllStateObjectsByState(ERegisterObjectState.UNSELECTED);\n\n    if (value > this.limit) {\n      const { sorter } = this.stateService;\n      const filter = this.buildFilter(\n        value,\n        this.offset,\n        this._filterState,\n        sorter.length > 0 ? sorter : undefined\n      );\n      this.objectsSubscription({\n        filter,\n        callback: this._selectFirstNLoadingObjects.bind(this),\n        noSet: true,\n      });\n    } else {\n      const firstNObjects = this.data.slice(0, value);\n      this._selectFirstNLoadingObjects(firstNObjects);\n    }\n  }\n\n  private _selectFirstNLoadingObjects(objects: T[]): void {\n    for (const object of objects) {\n      this.updateStateObjectByKey(object.id, { state: ERegisterObjectState.SELECTED, object });\n    }\n  }\n\n  public filterToggle(): void {\n    this.stateService.toggle();\n  }\n\n  public onPaginatorChange(paginatorChange: {\n    first: number;\n    page: number;\n    pagesCount: number | null;\n    rows: number;\n  }): void {\n    const { rows, first, page } = paginatorChange;\n\n    if (this.stateService.limit !== rows) {\n      this.stateService.setLimit(rows);\n      this._savePageRowsLimit(rows);\n    }\n\n    if (this.stateService.offset !== first - 1) {\n      this.stateService.setOffset(first - 1);\n    }\n\n    if (this.stateService.page !== page) {\n      this.stateService.setPage(page);\n    }\n  }\n\n  private _savePageRowsLimit(pageRowsLimit: number): void {\n    this.settingsService\n      .upsertReturningOne$(SETTINGS_TYPE.REGISTER_PAGE_ROWS_LIMIT)\n      .subscribe((setting) => {\n        this._pageRowsLimitSetting = setting || undefined;\n      });\n    this.settingsService.upsertUserSettingsByUserId({\n      settings: {\n        id: this._pageRowsLimitSetting?.id,\n        settings_type: SETTINGS_TYPE.REGISTER_PAGE_ROWS_LIMIT,\n        module_name: this._modulePath,\n        settings: { pageRowsLimit },\n      },\n      hidden: true,\n    });\n  }\n\n  public updateColumnSettings({ settings }: IColumnSettingsChanges): void {\n    if (settings) {\n      this.stickyLeftIds = this._getColumnIdsRecursive(settings.stickyLeft);\n      this.stickyRightIds = this._getColumnIdsRecursive(\n        settings.stickyRight,\n        (el) => el.status === EColumnStatus.DEFAULT\n      );\n      this.columns = [\n        ...this.stickyLeftIds,\n        ...this._getColumnIdsRecursive(\n          settings.columns,\n          (el) => el.status === EColumnStatus.DEFAULT\n        ),\n        ...this.stickyRightIds,\n      ];\n    }\n\n    this.cdr.markForCheck();\n  }\n\n  private _getColumnIdsRecursive(\n    columns: IColumnSettings[],\n    predicate?: (value: IColumnSettings, index: number, array: IColumnSettings[]) => unknown\n  ): string[] {\n    const filteredColumns = predicate\n      ? columns.filter((col, index, array) => predicate(col, index, array))\n      : columns;\n\n    return filteredColumns.flatMap((column) => {\n      const { id, children } = column;\n\n      if (children) {\n        return [id, ...this._getColumnIdsRecursive(children, predicate)];\n      }\n\n      return [id];\n    });\n  }\n\n  public updateSort(sort: RegisterTableCellSorter<any>[]): void {\n    this.stateService.setSorter(sort);\n  }\n\n  protected saveThsWidthToUserSettings(tableColumnsWidth: ThWidthEntry[]): void {\n    const settings = this._columnsSettings;\n    if (settings) {\n      settings.settings.tableColumnsWidth = tableColumnsWidth;\n    }\n\n    this.settingsService.upsertUserSettingsByUserId({\n      settings: {\n        id: this._columnsSettings?.id,\n        settings_type: SETTINGS_TYPE.COLUMNS,\n        module_name: this._modulePath,\n        settings: { ...this._columnsSettings?.settings, tableColumnsWidth },\n      },\n      hidden: true,\n      updateSettings: true,\n    });\n  }\n\n  protected get filtersAreOpened(): boolean {\n    return this.stateService.state.state !== EInputsState.HIDDEN;\n  }\n\n  private _subscribeOnMutationCompleted(): void {\n    this.actionCompleted$\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe(() => this.actionCompleted());\n  }\n\n  private _initDefaultFilter(queryFilters: ITpUserSettingsSettingsFilter[] | undefined): void {\n    this.settingsService\n      .fetchUserSettings$({\n        id_user: {\n          _eq: this._user.id,\n        },\n        settings_type: {\n          _in: [SETTINGS_TYPE.FILTER, SETTINGS_TYPE.REGISTER_PINNED_INPUTS],\n        },\n        module_name: {\n          _eq: this._modulePath,\n        },\n      })\n      .pipe(take(1))\n      .subscribe((userSettings) => {\n        const pinnedFilter = userSettings.find(\n          ({ settings_type: type }) => type === SETTINGS_TYPE.REGISTER_PINNED_INPUTS\n        );\n        const isPinned = !!pinnedFilter?.settings.pinned;\n        const favoriteFilter = userSettings.find(({ settings }) => settings.favorite);\n\n        if (isPinned) {\n          this.stateService.setPin(true);\n          this.stateService.setState({\n            state: EInputsState.FILTER_LIST,\n            action: EInputsAction.APPLY_SAVED_FILTER,\n          });\n        }\n\n        if (queryFilters || this.searchInput?.getRawValue()) {\n          this.applyFilters(queryFilters ?? []);\n        } else if (pinnedFilter && isPinned) {\n          this._applyFilterSettings(pinnedFilter);\n        } else if (favoriteFilter) {\n          this._applyFilterSettings(favoriteFilter);\n        }\n\n        this._defaultFilterApplied$.next(true);\n      });\n  }\n\n  private _applyFilterSettings(settings: ITpUserSettings): void {\n    this.filtersService.setUserSettingsFilterValues(settings.settings.filter ?? []);\n    const { gqlFilter } = this.filtersService;\n    this.stateService.setGqlValues(gqlFilter);\n    this.stateService.setState({\n      state: EInputsState.HIDDEN,\n      action: EInputsAction.APPLY_SAVED_FILTER,\n    });\n  }\n\n  private _selectChangedFilter(selection: ApplySelectionTypes): any {\n    let filter = null;\n\n    if (selection === null) {\n      this.clearSelections();\n      return;\n    }\n\n    if (selection === SelectionTypes.ALL || typeof selection === 'number') {\n      filter = this._handleAllOrNumberSelection(selection);\n    } else if (selection === SelectionTypes.VISIBLE) {\n      this._selectVisibleItems();\n    } else if (selection === SelectionTypes.INVERSE) {\n      filter = this._handleInverseSelection();\n    }\n\n    return filter;\n  }\n\n  private _handleAllOrNumberSelection(selection: ApplySelectionTypes): any {\n    let filter = null;\n    const { sorter } = this.stateService;\n\n    if (selection === SelectionTypes.ALL) {\n      filter = this.buildFilter(undefined, undefined, this._filterState);\n    } else if (typeof selection === 'number') {\n      if (selection > this.limit) {\n        filter = this.buildFilter(\n          selection,\n          0,\n          this._filterState,\n          sorter.length > 0 ? sorter : undefined\n        );\n      } else {\n        this._selectFirstNItems(selection);\n      }\n    }\n\n    return filter;\n  }\n\n  private _selectFirstNItems(count: number): void {\n    this.selectedObjects = new Set(this.data.slice(0, count));\n    this.selectedIds = new Set(this.data.map((d) => d.id).slice(0, count));\n  }\n\n  private _selectVisibleItems(): void {\n    this.selectedObjects = new Set(this.visibleData);\n    this.selectedIds = new Set(this.visibleData.map((d) => d.id));\n  }\n\n  private _handleInverseSelection(): any {\n    const inverseFilter = { id: { _nin: [...this.selectedIds] } } as GqlField;\n    const updatedFilterState = Array.isArray(this._filterState)\n      ? [...this._filterState, inverseFilter]\n      : [this._filterState, inverseFilter];\n\n    return this.buildFilter(undefined, undefined, updatedFilterState);\n  }\n\n  private _setSelected(data: T[]): void {\n    this.selectedObjects = new Set(data);\n    this.selectedIds = new Set(data.map((d) => d.id));\n    this.selectedRecordsLoading$.next(false);\n  }\n\n  protected parseToFilters(input: { [key: string]: any }): ITpUserSettingsSettingsFilter[] {\n    return Object.entries(input).map(([key, value]) => ({\n      id: key,\n      value,\n    }));\n  }\n\n  protected get selectedCount(): number {\n    const selectedSize = this.selectedService?.selectedValues()?.size ?? null;\n    const unselectedSize = this.selectedService?.unselectedValues()?.size ?? 0;\n    const unfetchedObjects = this.selectedService?.stateUnfetchedObjects();\n    const isNotSelected = unfetchedObjects !== ERegisterObjectState.SELECTED;\n\n    if (selectedSize === null) {\n      return this.selectedIds.size;\n    }\n\n    return isNotSelected ? selectedSize : this.dataCount - unselectedSize;\n  }\n\n  private _getDefaultColumnsRecursive(columnsData: IColumnData[]): string[] {\n    return columnsData.flatMap((column) => {\n      const { name, children } = column;\n\n      if (children) {\n        return [name, ...this._getDefaultColumnsRecursive(children)];\n      }\n\n      return [name];\n    });\n  }\n\n  protected get notAllFetched(): boolean {\n    const unfetchedState = this.selectedService!.stateUnfetchedObjects();\n    const allFetched = this.stateObjects!().size === this.dataCount;\n\n    return unfetchedState === ERegisterObjectState.SELECTED && !allFetched;\n  }\n}\n"]}