ngx-register-base 1.3.1 → 1.3.3

package/esm2022/lib/services/filter/filters.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable, Optional } from '@angular/core';
+import { InputsService } from '../inputs.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./filters-transmit.service";
+export class FiltersService extends InputsService {
+    constructor(injector, _transmitter) {
+        super(injector);
+        this._transmitter = _transmitter;
+    }
+    init(group) {
+        super.init(group);
+        this._transmitter?.setForm(this.inputs);
+        this._transmitter?.setSearchInput(this.searchInput);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FiltersService, deps: [{ token: i0.Injector }, { token: i1.FiltersTransmitService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FiltersService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FiltersService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.FiltersTransmitService, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVycy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJlZ2lzdGVyLWJhc2Uvc3JjL2xpYi9zZXJ2aWNlcy9maWx0ZXIvZmlsdGVycy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQVksUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQy9ELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQzs7O0FBS2xELE1BQU0sT0FBTyxjQUF5QixTQUFRLGFBQXVCO0lBQ25FLFlBQ0UsUUFBa0IsRUFDVyxZQUFvQztRQUVqRSxLQUFLLENBQUMsUUFBUSxDQUFDLENBQUM7UUFGYSxpQkFBWSxHQUFaLFlBQVksQ0FBd0I7SUFHbkUsQ0FBQztJQUVlLElBQUksQ0FBQyxLQUFpQztRQUNwRCxLQUFLLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBRWxCLElBQUksQ0FBQyxZQUFZLEVBQUUsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUN4QyxJQUFJLENBQUMsWUFBWSxFQUFFLGNBQWMsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDdEQsQ0FBQzsrR0FiVSxjQUFjO21IQUFkLGNBQWM7OzRGQUFkLGNBQWM7a0JBRDFCLFVBQVU7OzBCQUlOLFFBQVEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBJbmplY3RvciwgT3B0aW9uYWwgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IElucHV0c1NlcnZpY2UgfSBmcm9tICcuLi9pbnB1dHMuc2VydmljZSc7XG5pbXBvcnQgeyBGaWx0ZXJzVHJhbnNtaXRTZXJ2aWNlIH0gZnJvbSAnLi9maWx0ZXJzLXRyYW5zbWl0LnNlcnZpY2UnO1xuaW1wb3J0IHsgRm9ybUdyb3VwV3JhcHBlciB9IGZyb20gJy4uLy4uL2NvcmUvZm9ybS1ncm91cC13cmFwcGVyL2Zvcm0tZ3JvdXAtd3JhcHBlcic7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBGaWx0ZXJzU2VydmljZTxGb3JtVHlwZT4gZXh0ZW5kcyBJbnB1dHNTZXJ2aWNlPEZvcm1UeXBlPiB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIGluamVjdG9yOiBJbmplY3RvcixcbiAgICBAT3B0aW9uYWwoKSBwcml2YXRlIHJlYWRvbmx5IF90cmFuc21pdHRlcjogRmlsdGVyc1RyYW5zbWl0U2VydmljZVxuICApIHtcbiAgICBzdXBlcihpbmplY3Rvcik7XG4gIH1cblxuICBwdWJsaWMgb3ZlcnJpZGUgaW5pdChncm91cDogRm9ybUdyb3VwV3JhcHBlcjxGb3JtVHlwZT4pOiB2b2lkIHtcbiAgICBzdXBlci5pbml0KGdyb3VwKTtcblxuICAgIHRoaXMuX3RyYW5zbWl0dGVyPy5zZXRGb3JtKHRoaXMuaW5wdXRzKTtcbiAgICB0aGlzLl90cmFuc21pdHRlcj8uc2V0U2VhcmNoSW5wdXQodGhpcy5zZWFyY2hJbnB1dCk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/services/index.mjs

@@ -0,0 +1,8 @@
+export * from './dialog';
+export * from './date-time.service';
+export { FiltersService } from './filter/filters.service';
+export { FiltersStateService } from './filter/filters-state.service';
+export { FiltersTransmitService } from './filter/filters-transmit.service';
+export { ResizeWindowObserverService } from './resize-window-observer.service';
+export { SelectedObjectsStateService } from './selected-objects-state.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtcmVnaXN0ZXItYmFzZS9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzFELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQzNFLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQy9FLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kaWFsb2cnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRlLXRpbWUuc2VydmljZSc7XG5leHBvcnQgeyBGaWx0ZXJzU2VydmljZSB9IGZyb20gJy4vZmlsdGVyL2ZpbHRlcnMuc2VydmljZSc7XG5leHBvcnQgeyBGaWx0ZXJzU3RhdGVTZXJ2aWNlIH0gZnJvbSAnLi9maWx0ZXIvZmlsdGVycy1zdGF0ZS5zZXJ2aWNlJztcbmV4cG9ydCB7IEZpbHRlcnNUcmFuc21pdFNlcnZpY2UgfSBmcm9tICcuL2ZpbHRlci9maWx0ZXJzLXRyYW5zbWl0LnNlcnZpY2UnO1xuZXhwb3J0IHsgUmVzaXplV2luZG93T2JzZXJ2ZXJTZXJ2aWNlIH0gZnJvbSAnLi9yZXNpemUtd2luZG93LW9ic2VydmVyLnNlcnZpY2UnO1xuZXhwb3J0IHsgU2VsZWN0ZWRPYmplY3RzU3RhdGVTZXJ2aWNlIH0gZnJvbSAnLi9zZWxlY3RlZC1vYmplY3RzLXN0YXRlLnNlcnZpY2UnO1xuIl19

package/esm2022/lib/services/inputs-state.service.mjs

@@ -0,0 +1,130 @@
+import { DestroyRef, inject, Injectable } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { EInputsAction, EInputsState } from '../types';
+import { Router } from '@angular/router';
+import { getLastSegmentOfPathName } from '../utils';
+import * as i0 from "@angular/core";
+export const DEFAULT_LIMIT = 30;
+export class InputsStateService {
+    constructor() {
+        this.unsubscribe$ = new Subject();
+        this._page$ = new BehaviorSubject(1);
+        this._limit$ = new BehaviorSubject(null);
+        this._offset$ = new BehaviorSubject(0);
+        this._count$ = new BehaviorSubject(0);
+        this._sorter$ = new BehaviorSubject([]);
+        this._name$ = new BehaviorSubject('');
+        this._state$ = new BehaviorSubject({
+            state: EInputsState.HIDDEN,
+            action: EInputsAction.OPEN,
+        });
+        // TODO: заменить на нормальный тип
+        this._gqlValues$ = new BehaviorSubject([]);
+        this._pinned$ = new BehaviorSubject(false);
+        this.page$ = this._page$.asObservable();
+        this.limit$ = this._limit$.asObservable();
+        this.offset$ = this._offset$.asObservable();
+        this.count$ = this._count$.asObservable();
+        this.sorter$ = this._sorter$.asObservable();
+        this.name$ = this._name$.asObservable();
+        this.state$ = this._state$.asObservable();
+        this.gqlValues$ = this._gqlValues$.asObservable();
+        this.pinned$ = this._pinned$.asObservable();
+        this.destroyRef = inject(DestroyRef);
+        this.router = inject(Router);
+        this.modulePath = getLastSegmentOfPathName(this.router.url);
+        this.pinStorageKey = `@pin/${this.modulePath}`;
+        this.pinnedInputsStorageKey = `@pinned-inputs/${this.modulePath}`;
+    }
+    toggle() {
+        const isOpen = this.state.state !== EInputsState.HIDDEN;
+        // если фильтр был открыт, значит его закрывают - открепляем
+        if (isOpen) {
+            this.setPin(false);
+        }
+        this.setState({
+            state: isOpen ? EInputsState.HIDDEN : EInputsState.FILTER_LIST,
+            action: EInputsAction.OPEN,
+        });
+    }
+    togglePin() {
+        this.setPin(!this.isPin);
+    }
+    ngOnDestroy() {
+        this._page$.complete();
+        this._limit$.complete();
+        this._name$.complete();
+        this._offset$.complete();
+        this._count$.complete();
+        this._state$.complete();
+        this._sorter$.complete();
+        this._gqlValues$.complete();
+        this._pinned$.complete();
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+        this.onDestroy();
+    }
+    onDestroy() { }
+    setPage(page) {
+        this._page$.next(page);
+    }
+    setLimit(limit) {
+        this._limit$.next(limit);
+    }
+    setOffset(offset) {
+        this._offset$.next(offset);
+    }
+    setSorter(sort) {
+        this._sorter$.next(sort);
+    }
+    setName(name) {
+        this._name$.next(name);
+    }
+    setCount(count) {
+        this._count$.next(count);
+    }
+    setState(state) {
+        if (!(this.isPin && state.state === EInputsState.HIDDEN)) {
+            this._state$.next(state);
+        }
+    }
+    setGqlValues(values) {
+        this._gqlValues$.next(values);
+    }
+    setPin(isPin) {
+        this._pinned$.next(isPin);
+    }
+    get page() {
+        return this._page$.getValue();
+    }
+    get limit() {
+        return this._limit$.getValue() ?? DEFAULT_LIMIT;
+    }
+    get offset() {
+        return this._offset$.getValue();
+    }
+    get state() {
+        return this._state$.getValue();
+    }
+    get count() {
+        return this._count$.getValue();
+    }
+    get sorter() {
+        return this._sorter$.getValue();
+    }
+    get name() {
+        return this._name$.getValue();
+    }
+    get gqlValues() {
+        return this._gqlValues$.getValue();
+    }
+    get isPin() {
+        return this._pinned$.getValue();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputsStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputsStateService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputsStateService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inputs-state.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-register-base/src/lib/services/inputs-state.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, inject, Injectable, OnDestroy } from '@angular/core';\nimport { BehaviorSubject, Subject } from 'rxjs';\nimport { EInputsAction, EInputsState, GqlFields, IInputsState } from '../types';\nimport { Router } from '@angular/router';\nimport { getLastSegmentOfPathName } from '../utils';\nimport { RegisterTableCellSorter } from '../components/register-table/model/schema';\n\nexport const DEFAULT_LIMIT = 30;\n\n@Injectable()\nexport class InputsStateService<T = any> implements OnDestroy {\n  protected readonly unsubscribe$ = new Subject<void>();\n\n  protected readonly _page$ = new BehaviorSubject<number>(1);\n  protected readonly _limit$ = new BehaviorSubject<number | null>(null);\n  protected readonly _offset$ = new BehaviorSubject<number>(0);\n  protected readonly _count$ = new BehaviorSubject<number>(0);\n  protected readonly _sorter$ = new BehaviorSubject<RegisterTableCellSorter<T>[]>([]);\n  protected readonly _name$ = new BehaviorSubject<string>('');\n  protected readonly _state$ = new BehaviorSubject<IInputsState>({\n    state: EInputsState.HIDDEN,\n    action: EInputsAction.OPEN,\n  });\n  // TODO: заменить на нормальный тип\n  protected readonly _gqlValues$ = new BehaviorSubject<GqlFields>([]);\n  protected readonly _pinned$ = new BehaviorSubject<boolean>(false);\n\n  public readonly page$ = this._page$.asObservable();\n  public readonly limit$ = this._limit$.asObservable();\n  public readonly offset$ = this._offset$.asObservable();\n  public readonly count$ = this._count$.asObservable();\n  public readonly sorter$ = this._sorter$.asObservable();\n  public readonly name$ = this._name$.asObservable();\n  public readonly state$ = this._state$.asObservable();\n  public readonly gqlValues$ = this._gqlValues$.asObservable();\n  public readonly pinned$ = this._pinned$.asObservable();\n\n  protected readonly destroyRef = inject(DestroyRef);\n\n  protected readonly router = inject(Router);\n\n  protected readonly modulePath = getLastSegmentOfPathName(this.router.url);\n\n  public readonly pinStorageKey = `@pin/${this.modulePath}`;\n  public readonly pinnedInputsStorageKey = `@pinned-inputs/${this.modulePath}`;\n\n  public toggle(): void {\n    const isOpen = this.state.state !== EInputsState.HIDDEN;\n\n    // если фильтр был открыт, значит его закрывают - открепляем\n    if (isOpen) {\n      this.setPin(false);\n    }\n\n    this.setState({\n      state: isOpen ? EInputsState.HIDDEN : EInputsState.FILTER_LIST,\n      action: EInputsAction.OPEN,\n    });\n  }\n\n  public togglePin(): void {\n    this.setPin(!this.isPin);\n  }\n\n  public ngOnDestroy(): void {\n    this._page$.complete();\n    this._limit$.complete();\n    this._name$.complete();\n    this._offset$.complete();\n    this._count$.complete();\n    this._state$.complete();\n    this._sorter$.complete();\n    this._gqlValues$.complete();\n    this._pinned$.complete();\n\n    this.unsubscribe$.next();\n    this.unsubscribe$.complete();\n\n    this.onDestroy();\n  }\n\n  protected onDestroy(): void {}\n\n  public setPage(page: number): void {\n    this._page$.next(page);\n  }\n\n  public setLimit(limit: number): void {\n    this._limit$.next(limit);\n  }\n\n  public setOffset(offset: number): void {\n    this._offset$.next(offset);\n  }\n\n  public setSorter(sort: RegisterTableCellSorter<T>[]): void {\n    this._sorter$.next(sort);\n  }\n\n  public setName(name: string): void {\n    this._name$.next(name);\n  }\n\n  public setCount(count: number): void {\n    this._count$.next(count);\n  }\n\n  public setState(state: IInputsState): void {\n    if (!(this.isPin && state.state === EInputsState.HIDDEN)) {\n      this._state$.next(state);\n    }\n  }\n\n  public setGqlValues(values: GqlFields): void {\n    this._gqlValues$.next(values);\n  }\n\n  public setPin(isPin: boolean): void {\n    this._pinned$.next(isPin);\n  }\n\n  public get page(): number {\n    return this._page$.getValue();\n  }\n\n  public get limit(): number {\n    return this._limit$.getValue() ?? DEFAULT_LIMIT;\n  }\n\n  public get offset(): number {\n    return this._offset$.getValue();\n  }\n\n  public get state(): IInputsState {\n    return this._state$.getValue();\n  }\n\n  public get count(): number {\n    return this._count$.getValue();\n  }\n\n  public get sorter(): RegisterTableCellSorter<T>[] {\n    return this._sorter$.getValue();\n  }\n\n  public get name(): string {\n    return this._name$.getValue();\n  }\n\n  public get gqlValues(): GqlFields {\n    return this._gqlValues$.getValue();\n  }\n\n  public get isPin(): boolean {\n    return this._pinned$.getValue();\n  }\n}\n"]}

package/esm2022/lib/services/inputs.service.mjs

@@ -0,0 +1,88 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { InputControl } from '../core/input-control/input-control';
+import { INPUTS_STATE_CONFIG_KEY, WARN_SEARCH_INPUT_UNDEFINED } from '../consts/inputs.consts';
+import * as i0 from "@angular/core";
+export class InputsService {
+    constructor(injector) {
+        this.injector = injector;
+        this.unsubscribe$ = new Subject();
+        this.config = this.injector.get(INPUTS_STATE_CONFIG_KEY, {});
+        const { searchInput } = this.config;
+        if (searchInput) {
+            this._searchInput = new InputControl(null);
+        }
+    }
+    get searchInput() {
+        if (!this._searchInput) {
+            console.warn(WARN_SEARCH_INPUT_UNDEFINED);
+        }
+        return this._searchInput;
+    }
+    get searchValue() {
+        return this.searchInput?.getRawValue();
+    }
+    init(group) {
+        this.inputs = group;
+    }
+    get values() {
+        return this.inputs.getRawValue();
+    }
+    get dirtyValues() {
+        return this.inputs.getDirtyValues();
+    }
+    clear() {
+        this.inputs.reset();
+    }
+    setUserSettingsFilterValues(values) {
+        this.clear();
+        for (const { id, value } of values) {
+            const key = id;
+            const control = this._control(key);
+            if (control?.saved_value$) {
+                control.saved_value$.next(value);
+            }
+            else {
+                console.warn(`Не найдено поле: ${id} для установки значения:`, value);
+            }
+        }
+    }
+    _control(key) {
+        return this.inputs.controls[key];
+    }
+    get userSettingsFilter() {
+        return Object.entries(this.inputs.controls).map(([id, abstractControl]) => {
+            const control = abstractControl;
+            const value = control.saved_value$.getValue();
+            const savedValue = value === null ? null : value;
+            return {
+                id,
+                value: savedValue,
+            };
+        });
+    }
+    get gqlFilter() {
+        const filter = [];
+        for (const abstractControl of Object.values(this.inputs.controls)) {
+            const control = abstractControl;
+            if (control.gql_value) {
+                filter.push(control.gql_value);
+            }
+            control.applied?.set(!!control.gql_value);
+        }
+        if (this.searchValue && this.searchInput?.gql_value) {
+            filter.push(this.searchInput.gql_value);
+        }
+        return filter;
+    }
+    ngOnDestroy() {
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputsService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputsService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inputs.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-register-base/src/lib/services/inputs.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, OnDestroy } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { FormGroupWrapper } from '../core/form-group-wrapper/form-group-wrapper';\nimport { ITpUserSettingsSettingsFilter } from '../types/register-base.types';\nimport { ExtractForm } from '../types/sub-types';\nimport { IInputControl, IInputsStateConfig } from '../types/inputs.types';\nimport { InputControl } from '../core/input-control/input-control';\nimport { INPUTS_STATE_CONFIG_KEY, WARN_SEARCH_INPUT_UNDEFINED } from '../consts/inputs.consts';\n\n@Injectable()\nexport class InputsService<FormType> implements OnDestroy {\n  protected readonly config: IInputsStateConfig;\n  protected readonly unsubscribe$ = new Subject<void>();\n\n  private readonly _searchInput: IInputControl<string | null> | undefined;\n  public inputs!: FormGroupWrapper<FormType>;\n\n  constructor(private readonly injector: Injector) {\n    this.config = this.injector.get(INPUTS_STATE_CONFIG_KEY, {});\n\n    const { searchInput } = this.config;\n\n    if (searchInput) {\n      this._searchInput = new InputControl<string | null>(null);\n    }\n  }\n\n  public get searchInput(): IInputControl<string | null> | undefined {\n    if (!this._searchInput) {\n      console.warn(WARN_SEARCH_INPUT_UNDEFINED);\n    }\n\n    return this._searchInput;\n  }\n\n  public get searchValue(): string | null | undefined {\n    return this.searchInput?.getRawValue();\n  }\n\n  public init(group: FormGroupWrapper<FormType>): void {\n    this.inputs = group;\n  }\n\n  public get values(): ExtractForm<FormType> {\n    return this.inputs.getRawValue() as ExtractForm<FormType>;\n  }\n\n  public get dirtyValues(): Partial<ExtractForm<FormType>> {\n    return this.inputs.getDirtyValues();\n  }\n\n  public clear(): void {\n    this.inputs.reset();\n  }\n\n  public setUserSettingsFilterValues(values: ITpUserSettingsSettingsFilter[]): void {\n    this.clear();\n\n    for (const { id, value } of values) {\n      const key = id as keyof FormType;\n      const control = this._control<any, any>(key);\n\n      if (control?.saved_value$) {\n        control.saved_value$.next(value);\n      } else {\n        console.warn(`Не найдено поле: ${id} для установки значения:`, value);\n      }\n    }\n  }\n\n  private _control<ValueType extends FormType[keyof FormType], SavedValueType>(\n    key: keyof FormType\n  ): IInputControl<ValueType, SavedValueType> {\n    return this.inputs.controls[key] as IInputControl<ValueType, SavedValueType>;\n  }\n\n  public get userSettingsFilter(): ITpUserSettingsSettingsFilter[] {\n    return Object.entries(this.inputs.controls).map(([id, abstractControl]) => {\n      const control = abstractControl as IInputControl;\n      const value = control.saved_value$.getValue();\n      const savedValue = value === null ? null : value;\n\n      return {\n        id,\n        value: savedValue,\n      };\n    });\n  }\n\n  public get gqlFilter(): Record<string, any>[] {\n    const filter: Record<string, any>[] = [];\n\n    for (const abstractControl of Object.values(this.inputs.controls)) {\n      const control = abstractControl as IInputControl;\n\n      if (control.gql_value) {\n        filter.push(control.gql_value);\n      }\n\n      control.applied?.set(!!control.gql_value);\n    }\n\n    if (this.searchValue && this.searchInput?.gql_value) {\n      filter.push(this.searchInput.gql_value);\n    }\n\n    return filter;\n  }\n\n  public ngOnDestroy(): void {\n    this.unsubscribe$.next();\n    this.unsubscribe$.complete();\n  }\n}\n"]}

package/esm2022/lib/services/key-pressed.service.mjs

@@ -0,0 +1,37 @@
+import { inject, Injectable, InjectionToken } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export const KEY_PRESSED = new InjectionToken('KEY_PRESSED_TOKEN');
+export class KeyPressedService {
+    constructor() {
+        this._keyName = inject(KEY_PRESSED);
+        this._isPressed$ = new BehaviorSubject(false);
+        this.isPressed$ = this._isPressed$.asObservable();
+        this._keydownListener = (event) => {
+            if (event.key === this._keyName) {
+                this._isPressed$.next(true);
+            }
+        };
+        this._keyupListener = (event) => {
+            if (event.key === this._keyName) {
+                this._isPressed$.next(false);
+            }
+        };
+        window.addEventListener('keydown', this._keydownListener);
+        window.addEventListener('keyup', this._keyupListener);
+    }
+    isPressed() {
+        return this._isPressed$.getValue();
+    }
+    ngOnDestroy() {
+        this._isPressed$.complete();
+        window.removeEventListener('keydown', this._keydownListener);
+        window.removeEventListener('keyup', this._keyupListener);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KeyPressedService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KeyPressedService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KeyPressedService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/resize-window-observer.service.mjs

@@ -0,0 +1,33 @@
+import { afterNextRender, DestroyRef, inject, Injectable, NgZone, signal } from '@angular/core';
+import { debounceTime, distinctUntilChanged, fromEvent, map } from 'rxjs';
+import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+const RESIZE_WINDOW_DEBOUNCE_MLS = 100;
+export class ResizeWindowObserverService {
+    constructor() {
+        this._zone = inject(NgZone);
+        this._destroyRef = inject(DestroyRef);
+        this.innerHeight = signal(window.innerHeight);
+        this.innerWidth = signal(window.innerWidth);
+        this.innerHeight$ = toObservable(this.innerHeight);
+        afterNextRender(() => {
+            this._zone.runOutsideAngular(() => {
+                fromEvent(window, 'resize')
+                    .pipe(debounceTime(RESIZE_WINDOW_DEBOUNCE_MLS), map(() => ({
+                    height: window.innerHeight,
+                    width: window.innerWidth,
+                })), distinctUntilChanged(), takeUntilDestroyed(this._destroyRef))
+                    .subscribe(({ height, width }) => {
+                    this.innerHeight.set(height);
+                    this.innerWidth.set(width);
+                });
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ResizeWindowObserverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ResizeWindowObserverService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ResizeWindowObserverService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/selected-objects-state.service.mjs

@@ -0,0 +1,123 @@
+import { computed, DestroyRef, inject, Injectable, signal } from '@angular/core';
+import { BehaviorSubject, skip, take } from 'rxjs';
+import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
+import { ERegisterObjectState } from '../types/register-base.types';
+import { invertState } from '../consts/register-base.consts';
+import { isDefined } from '../utils';
+import { SelectionTypes, } from '../components/checkbox-selector/checkbox-selector.types';
+import * as i0 from "@angular/core";
+/** Сервис хранения состояния выбранных в реестре объектов */
+export class SelectedObjectsStateService {
+    constructor() {
+        /** Состояние всех загруженных объектов реестра */
+        this.state = signal(new Map());
+        /** Ключи всех выбранных объектов реестра */
+        this.selectedKeys = computed(() => {
+            const selected = this._filterStateObjectsByState(this.state(), ERegisterObjectState.SELECTED);
+            return new Set(selected.keys());
+        });
+        /** Ключи всех выбранных или не выбранных объектов реестра (зависит от stateUnfetchedObjects) */
+        this.keys = computed(() => {
+            const unfetchedState = this.stateUnfetchedObjects();
+            return new Set(this._filterStateObjectsByState(this.state(), invertState(unfetchedState)).keys());
+        });
+        /** Значения всех выбранных объектов реестра */
+        this.selectedValues = computed(() => {
+            const selected = this._filterStateObjectsByState(this.state(), ERegisterObjectState.SELECTED);
+            return new Set([...selected.values()].map(({ object }) => object).filter((object) => isDefined(object)));
+        });
+        /** Значения всех не выбранных объектов реестра */
+        this.unselectedValues = computed(() => {
+            const selected = this._filterStateObjectsByState(this.state(), ERegisterObjectState.UNSELECTED);
+            return new Set([...selected.values()].map(({ object }) => object).filter((object) => isDefined(object)));
+        });
+        /** Значения всех выбранных или не выбранных объектов реестра (зависит от stateUnfetchedObjects) */
+        this.values = computed(() => {
+            const unfetchedState = this.stateUnfetchedObjects();
+            return new Set([...this._filterStateObjectsByState(this.state(), invertState(unfetchedState)).values()]
+                .map(({ object }) => object)
+                .filter((object) => isDefined(object)));
+        });
+        this.selectionType$ = new BehaviorSubject(null);
+        this.stateUnfetchedObjects$ = new BehaviorSubject(ERegisterObjectState.UNSELECTED);
+        this.stateUnfetchedObjects = toSignal(this.stateUnfetchedObjects$.asObservable(), {
+            initialValue: ERegisterObjectState.UNSELECTED,
+        });
+        this._dr = inject(DestroyRef);
+        this._subscribeOnSelectionType();
+    }
+    /**
+     * Установить состояние всем загруженным объектам
+     *
+     * @param nextState - устанавливаемое состояние
+     * */
+    setAllStateObjectsByState(nextState) {
+        if (nextState === ERegisterObjectState.UNSELECTED) {
+            this.stateUnfetchedObjects$.next(ERegisterObjectState.UNSELECTED);
+        }
+        for (const key of this.state().keys()) {
+            this.setStateObjectByKey(key, { state: nextState });
+        }
+        this._refresh();
+    }
+    /**
+     * Обновить свойства загруженного объекта по ключу
+     *
+     * @param key - ключ загруженного объекта
+     * @param updates - обновление, содержащее свойства которые нужно обновить
+     * */
+    setStateObjectByKey(key, updates) {
+        const objects = new Map(this.state());
+        const stateObject = objects.get(key) ?? { state: ERegisterObjectState.UNSELECTED };
+        objects.set(key, { ...stateObject, ...updates });
+        this.state.set(objects);
+    }
+    loadStateObjects(data) {
+        const state = this.stateUnfetchedObjects$?.getValue();
+        for (const object of data) {
+            if (!this.state().has(object.id)) {
+                this.setStateObjectByKey(object.id, { object, state });
+            }
+        }
+        this._refresh();
+    }
+    _refresh() {
+        this.state.update((state) => new Map(state));
+    }
+    resetState(data) {
+        this.stateUnfetchedObjects$
+            .asObservable()
+            .pipe(skip(1), take(1))
+            .subscribe(() => {
+            this.state.set(new Map());
+            if (data) {
+                this.loadStateObjects(data);
+            }
+        });
+        this.selectionType$.next(null);
+    }
+    _filterStateObjectsByState(stateObjects, filterState) {
+        return new Map([...stateObjects].filter(([_, { state }]) => state === filterState));
+    }
+    _subscribeOnSelectionType() {
+        this.selectionType$
+            .asObservable()
+            .pipe(takeUntilDestroyed(this._dr))
+            .subscribe((type) => {
+            let newState = ERegisterObjectState.UNSELECTED;
+            if (type === SelectionTypes.ALL) {
+                newState = ERegisterObjectState.SELECTED;
+            }
+            else if (type === SelectionTypes.INVERSE) {
+                newState = invertState(this.stateUnfetchedObjects$.getValue());
+            }
+            this.stateUnfetchedObjects$.next(newState);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectedObjectsStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectedObjectsStateService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectedObjectsStateService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selected-objects-state.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-register-base/src/lib/services/selected-objects-state.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { computed, DestroyRef, inject, Injectable, signal } from '@angular/core';\nimport { ScalarUUID } from 'hasura';\nimport { BehaviorSubject, skip, take } from 'rxjs';\nimport { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';\nimport { ERegisterObjectState, IRegisterObject } from '../types/register-base.types';\nimport { invertState } from '../consts/register-base.consts';\nimport { isDefined } from '../utils';\nimport {\n  ApplySelectionTypes,\n  SelectionTypes,\n} from '../components/checkbox-selector/checkbox-selector.types';\n\n/** Сервис хранения состояния выбранных в реестре объектов */\n@Injectable()\nexport class SelectedObjectsStateService<T extends { id: ScalarUUID } = any> {\n  /** Состояние всех загруженных объектов реестра */\n  public readonly state = signal(new Map<ScalarUUID, IRegisterObject<T>>());\n  /** Ключи всех выбранных объектов реестра */\n  public readonly selectedKeys = computed(() => {\n    const selected = this._filterStateObjectsByState(this.state(), ERegisterObjectState.SELECTED);\n\n    return new Set(selected.keys());\n  });\n  /** Ключи всех выбранных или не выбранных объектов реестра (зависит от stateUnfetchedObjects) */\n  public readonly keys = computed(() => {\n    const unfetchedState = this.stateUnfetchedObjects();\n\n    return new Set(\n      this._filterStateObjectsByState(this.state(), invertState(unfetchedState)).keys()\n    );\n  });\n  /** Значения всех выбранных объектов реестра */\n  public readonly selectedValues = computed(() => {\n    const selected = this._filterStateObjectsByState(this.state(), ERegisterObjectState.SELECTED);\n\n    return new Set(\n      [...selected.values()].map(({ object }) => object).filter((object) => isDefined(object))\n    );\n  });\n  /** Значения всех не выбранных объектов реестра */\n  public readonly unselectedValues = computed(() => {\n    const selected = this._filterStateObjectsByState(this.state(), ERegisterObjectState.UNSELECTED);\n\n    return new Set(\n      [...selected.values()].map(({ object }) => object).filter((object) => isDefined(object))\n    );\n  });\n  /** Значения всех выбранных или не выбранных объектов реестра (зависит от stateUnfetchedObjects) */\n  public readonly values = computed(() => {\n    const unfetchedState = this.stateUnfetchedObjects();\n\n    return new Set(\n      [...this._filterStateObjectsByState(this.state(), invertState(unfetchedState)).values()]\n        .map(({ object }) => object)\n        .filter((object) => isDefined(object))\n    );\n  });\n\n  public readonly selectionType$ = new BehaviorSubject<ApplySelectionTypes>(null);\n  public readonly stateUnfetchedObjects$ = new BehaviorSubject<ERegisterObjectState>(\n    ERegisterObjectState.UNSELECTED\n  );\n\n  public readonly stateUnfetchedObjects = toSignal(this.stateUnfetchedObjects$.asObservable(), {\n    initialValue: ERegisterObjectState.UNSELECTED,\n  });\n\n  private readonly _dr = inject(DestroyRef);\n\n  constructor() {\n    this._subscribeOnSelectionType();\n  }\n\n  /**\n   * Установить состояние всем загруженным объектам\n   *\n   * @param nextState - устанавливаемое состояние\n   * */\n  public setAllStateObjectsByState(nextState: ERegisterObjectState): void {\n    if (nextState === ERegisterObjectState.UNSELECTED) {\n      this.stateUnfetchedObjects$.next(ERegisterObjectState.UNSELECTED);\n    }\n\n    for (const key of this.state().keys()) {\n      this.setStateObjectByKey(key, { state: nextState });\n    }\n\n    this._refresh();\n  }\n\n  /**\n   * Обновить свойства загруженного объекта по ключу\n   *\n   * @param key - ключ загруженного объекта\n   * @param updates - обновление, содержащее свойства которые нужно обновить\n   * */\n  public setStateObjectByKey(key: ScalarUUID, updates: Partial<IRegisterObject<T>>): void {\n    const objects = new Map(this.state());\n\n    const stateObject = objects.get(key) ?? { state: ERegisterObjectState.UNSELECTED };\n    objects.set(key, { ...stateObject, ...updates });\n\n    this.state.set(objects);\n  }\n\n  public loadStateObjects(data: T[]): void {\n    const state = this.stateUnfetchedObjects$?.getValue();\n\n    for (const object of data) {\n      if (!this.state().has(object.id)) {\n        this.setStateObjectByKey(object.id, { object, state });\n      }\n    }\n\n    this._refresh();\n  }\n\n  private _refresh(): void {\n    this.state.update((state) => new Map(state));\n  }\n\n  public resetState(data?: T[]): void {\n    this.stateUnfetchedObjects$\n      .asObservable()\n      .pipe(skip(1), take(1))\n      .subscribe(() => {\n        this.state.set(new Map());\n\n        if (data) {\n          this.loadStateObjects(data);\n        }\n      });\n    this.selectionType$.next(null);\n  }\n\n  private _filterStateObjectsByState(\n    stateObjects: Map<ScalarUUID, IRegisterObject<T>>,\n    filterState: ERegisterObjectState\n  ) {\n    return new Map([...stateObjects].filter(([_, { state }]) => state === filterState));\n  }\n\n  private _subscribeOnSelectionType(): void {\n    this.selectionType$\n      .asObservable()\n      .pipe(takeUntilDestroyed(this._dr))\n      .subscribe((type) => {\n        let newState = ERegisterObjectState.UNSELECTED;\n\n        if (type === SelectionTypes.ALL) {\n          newState = ERegisterObjectState.SELECTED;\n        } else if (type === SelectionTypes.INVERSE) {\n          newState = invertState(this.stateUnfetchedObjects$.getValue());\n        }\n\n        this.stateUnfetchedObjects$.next(newState);\n      });\n  }\n}\n"]}