ngx-register-base 1.3.1 → 1.3.2

package/lib/consts/register-base.consts.d.ts

@@ -0,0 +1,19 @@
+import { ERegisterObjectState, ITpUserSettings, IUserProfileLoader, IUserSettingsLoader } from '../types/register-base.types';
+import { InjectionToken } from '@angular/core';
+import { IUserProfile } from '../types/user-profile.types';
+export declare const SEARCH_INPUT_DEBOUNCE_TIME_MLS = 1000;
+export declare const THS_WIDTH_CHANGES_DEBOUNCE_TIME_MLS = 2000;
+export declare const invertState: (state: ERegisterObjectState) => ERegisterObjectState;
+export declare enum EOrder {
+    ASC = "asc",
+    DESC = "desc"
+}
+export declare enum SETTINGS_TYPE {
+    FILTER = 0,
+    COLUMNS = 1,
+    PAGE_MENU_STATE = 2,
+    REGISTER_PAGE_ROWS_LIMIT = 4,
+    REGISTER_PINNED_INPUTS = 5
+}
+export declare const USER_SETTINGS_LOADER: InjectionToken<IUserSettingsLoader<ITpUserSettings>>;
+export declare const USER_PROFILE_LOADER: InjectionToken<IUserProfileLoader<IUserProfile<any>, unknown>>;

package/lib/core/form-group-wrapper/errors-consts.d.ts

@@ -0,0 +1,5 @@
+export declare enum ERuntimeErrorCode {
+    NO_CONTROLS = 1000,
+    MISSING_CONTROL = 1001,
+    MISSING_CONTROL_VALUE = 1002
+}

package/lib/core/form-group-wrapper/form-group-wrapper.d.ts

@@ -0,0 +1,15 @@
+import { FormGroup, ɵFormGroupRawValue, ɵFormGroupValue } from '@angular/forms';
+import { ControlsWrapper, ExtractForm } from '../../types/sub-types';
+export declare function assertControlPresent(parent: any, isGroup: boolean, key: string | number): void;
+/** @deprecated заменить на FormGroup */
+export declare class FormGroupWrapper<TItem> extends FormGroup<ControlsWrapper<TItem>> {
+    setValue(value: TItem & ɵFormGroupRawValue<any>, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    patchValue(value: Partial<TItem> | ɵFormGroupValue<any>, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    getDirtyValues(): Partial<ExtractForm<TItem>>;
+}

package/lib/core/input-control/input-control.d.ts

@@ -0,0 +1,11 @@
+import { AsyncValidatorFn, FormControl, FormControlOptions, FormControlState, ValidatorFn } from '@angular/forms';
+import { BehaviorSubject } from 'rxjs';
+import { IInputControl, InputControlGqlValue } from '../../types/inputs.types';
+import { WritableSignal } from '@angular/core';
+export declare class InputControl<ValueType = any, SavedValueType = any> extends FormControl implements IInputControl<ValueType, SavedValueType> {
+    saved_value$: BehaviorSubject<SavedValueType | null>;
+    gql_value: InputControlGqlValue;
+    /** По полю применена фильтрация */
+    applied?: WritableSignal<boolean>;
+    constructor(value: FormControlState<ValueType> | ValueType, validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
+}

package/lib/core/param/param-base.d.ts

@@ -0,0 +1,68 @@
+import { AfterContentInit, AfterViewInit, ChangeDetectorRef, DestroyRef, Injector, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { IInputControl, InputControlGqlValue, InputControlSaveValue } from '../../types';
+import { FormatterGqlValueType, FormatterSavedValueType, ParserSavedValueType } from '../../types/params.types';
+import * as i0 from "@angular/core";
+export declare abstract class ParamBase<ValueType extends any | null, SavedValueType extends InputControlSaveValue> implements ControlValueAccessor, OnInit, AfterViewInit, AfterContentInit {
+    private _injector;
+    /** Название */
+    label: string;
+    /** Текст при пустом значении control (null) */
+    placeholder: import("@angular/core").InputSignal<string>;
+    /** Режим просмотра, по умолчанию выключен */
+    readmode: boolean;
+    /** Кнопка быстрой очистки поля, по умолчанию включена */
+    forceClear: boolean;
+    /** Текст при наведении на значение control */
+    hint: string | null;
+    /** Готовые стили для использования поля в панели фильтров/параметров или на карточке, по умолчанию стили для карточки */
+    paramStyle: 'filter' | 'card';
+    /** Метод для конвертации значения control при сохранении (используется при сохранении фильтров в БД) */
+    set formatSavedValue(formatter: FormatterSavedValueType<ValueType, SavedValueType> | undefined);
+    /** Метод для конвертации сохраненного значения в control (используется при установке сохраненных фильтров из БД) */
+    set parseSavedValue(parser: ParserSavedValueType<SavedValueType, ValueType> | undefined);
+    /** Метод для конвертации значения control в GQL-значение (используется при вычислении gql_value control) */
+    set formatGqlValue(formatter: FormatterGqlValueType<ValueType> | undefined);
+    /** Метод для отображения значения в режиме просмотра */
+    buildShowedValue: import("@angular/core").InputSignal<(_: ValueType) => string>;
+    set required(required: boolean);
+    get required(): boolean;
+    set disabled(disabled: boolean);
+    get disabled(): boolean;
+    private readonly _ngControl;
+    protected readonly cdr: ChangeDetectorRef;
+    protected readonly dr: DestroyRef;
+    protected control: IInputControl<ValueType, SavedValueType>;
+    protected formatterSavedValue: (value: ValueType, injector?: Injector) => SavedValueType;
+    protected parserSavedValue: (value: SavedValueType, injector?: Injector) => ValueType;
+    protected formatterGqlValue: (value: ValueType, injector?: Injector) => InputControlGqlValue;
+    private _required;
+    private _disabled;
+    private _isOuterUpdatingSavedValue;
+    protected showedValue: string;
+    protected readonly applied: import("@angular/core").Signal<boolean>;
+    constructor(_injector: Injector);
+    get value(): ValueType | undefined;
+    writeValue(value: ValueType): void;
+    clear(): void;
+    registerOnChange(onChange: (value: ValueType) => void): void;
+    protected onChange: (value: ValueType) => void;
+    registerOnTouched(onTouched: () => void): void;
+    protected onTouched: () => void;
+    ngOnInit(): void;
+    protected onInit(): void;
+    ngAfterViewInit(): void;
+    protected afterViewInit(): void;
+    protected get isInvalidAndNotPristine(): boolean;
+    protected isNotEmpty(): boolean;
+    ngAfterContentInit(): void;
+    private _subscribeOnValue;
+    private _updateShowedValue;
+    private _updateSavedValue;
+    private _subscribeOnSavedValue;
+    protected afterContentInit(): void;
+    private _setControlRequired;
+    private _setControlDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamBase<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ParamBase<any, any>, never, never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readmode": { "alias": "readmode"; "required": false; }; "forceClear": { "alias": "forceClear"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "paramStyle": { "alias": "paramStyle"; "required": false; }; "formatSavedValue": { "alias": "formatSavedValue"; "required": false; }; "parseSavedValue": { "alias": "parseSavedValue"; "required": false; }; "formatGqlValue": { "alias": "formatGqlValue"; "required": false; }; "buildShowedValue": { "alias": "buildShowedValue"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/core/param/param-date-base.d.ts

@@ -0,0 +1,18 @@
+import { Injector } from '@angular/core';
+import { DateTimeService } from '../../services/date-time.service';
+import { ParamBase } from './param-base';
+import { PrizmDateTypes } from '../../utils/prizm.shared.module';
+import { InputControlSaveValue } from '../../types';
+import { EDatePattern, ETimezone } from '../../directives/date/date-time.types';
+import * as i0 from "@angular/core";
+export declare abstract class ParamDateBase<ValueType extends PrizmDateTypes | null, SavedValueType extends InputControlSaveValue> extends ParamBase<ValueType, SavedValueType> {
+    private _dateInjector;
+    protected readonly ETimezone: typeof ETimezone;
+    protected readonly EDatePattern: typeof EDatePattern;
+    protected readonly _dts: DateTimeService;
+    protected readonly timezoneChange: import("rxjs").Observable<import("../../services/date-time.service").ITimeZone>;
+    constructor(_dateInjector: Injector);
+    protected rebuildDateInNewTimezone(date: Date, prevDiff: string, currDiff: string): Date;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamDateBase<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ParamDateBase<any, any>, never, never, {}, {}, never, never, false, never>;
+}

package/lib/core/param/param-select-base.d.ts

@@ -0,0 +1,42 @@
+import { Injector } from '@angular/core';
+import { ParamBase } from './param-base';
+import { PolymorphContent } from '@prizm-ui/components';
+import { InputControlSaveValue } from '../../types';
+import { InferArrayType } from '../../types/sub-types';
+import { MetaQuery } from '../../types/params.types';
+import { FastQueryStore } from '../../store/fast-query-store.service';
+import * as i0 from "@angular/core";
+export declare abstract class ParamSelectBase<ValueType, SavedValueType extends InputControlSaveValue> extends ParamBase<ValueType, SavedValueType> {
+    private _selectInjector;
+    items: NonNullable<InferArrayType<ValueType>>[];
+    searchable: boolean;
+    maxDropdownHeight: number;
+    valueTemplate?: PolymorphContent;
+    listItemTemplate?: PolymorphContent;
+    nullContent: PolymorphContent | string | null;
+    /** Массив полей по которым будет производиться фильтрация _or */
+    searchSubfields: string[];
+    /** Флаг строгого поиска: строгий - _eq, не строгий - _ilike */
+    strictSearch: boolean;
+    selectClasses?: string;
+    limit: number;
+    /** форматтер для задания кастомного отображения значения в поле */
+    formatShowedValue: (value: any, field: string) => string;
+    /** мета для автоматической подргузки значений из таблицы */
+    set meta(meta: MetaQuery | null);
+    get meta(): MetaQuery | null;
+    itemsChange: import("@angular/core").OutputEmitterRef<NonNullable<InferArrayType<ValueType>>[]>;
+    private readonly _meta$;
+    protected readonly meta$: import("rxjs").Observable<MetaQuery<any> | null>;
+    protected readonly store: FastQueryStore;
+    loading: boolean;
+    constructor(_selectInjector: Injector);
+    protected buildWhere(searchValue?: string): object | undefined;
+    protected buildNestedCondition(field: string, value: string, strict: boolean): object;
+    protected get metaFields(): {
+        idField: string | null;
+        valueField: string | null;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamSelectBase<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ParamSelectBase<any, any>, never, never, { "items": { "alias": "items"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "maxDropdownHeight": { "alias": "maxDropdownHeight"; "required": false; }; "valueTemplate": { "alias": "valueTemplate"; "required": false; }; "listItemTemplate": { "alias": "listItemTemplate"; "required": false; }; "nullContent": { "alias": "nullContent"; "required": false; }; "searchSubfields": { "alias": "searchSubfields"; "required": false; }; "strictSearch": { "alias": "strictSearch"; "required": false; }; "selectClasses": { "alias": "selectClasses"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; "formatShowedValue": { "alias": "formatShowedValue"; "required": false; }; "meta": { "alias": "meta"; "required": false; }; }, { "itemsChange": "itemsChange"; }, never, never, false, never>;
+}

package/lib/core/param/param-text-base.d.ts

@@ -0,0 +1,15 @@
+import { ParamBase } from './param-base';
+import * as i0 from "@angular/core";
+export declare abstract class ParamTextBase extends ParamBase<string | null, string | null> {
+    private readonly _initMaxLength;
+    placeholder: import("@angular/core").InputSignal<string>;
+    buildShowedValue: import("@angular/core").InputSignal<(value: string | null) => string>;
+    /**
+     * Максимальное кол-во символов
+     *
+     * @default 1000
+     * */
+    maxLength: import("@angular/core").InputSignal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamTextBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ParamTextBase, never, never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "buildShowedValue": { "alias": "buildShowedValue"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}

package/{src/lib/core/param/param.tokens.ts → lib/core/param/param.tokens.d.ts}

@@ -1,4 +1,3 @@
 import { InjectionToken } from '@angular/core';
-
 /** Максимальное кол-во символов в текстовых полях */
-export const MAX_LENGTH_TEXT_PARAMS = new InjectionToken<number>('MAX_LENGTH_TEXT_PARAMS');
+export declare const MAX_LENGTH_TEXT_PARAMS: InjectionToken<number>;

package/lib/core/register-base/register-base.d.ts

@@ -0,0 +1,168 @@
+import { AfterViewInit, ChangeDetectorRef, DestroyRef, Injector, OnDestroy, OnInit } from '@angular/core';
+import { Router } from '@angular/router';
+import { BehaviorSubject, Observable, ReplaySubject, Subscription } from 'rxjs';
+import { ERegisterObjectState, IRegisterBase, IRegisterObject, ITpUserSettingsSettingsFilter, ObjectsSubscriptionConfig, IUserProfile, GqlFields } from '../../types';
+import { IColumnSettingsChanges } from '../../components/column-settings/types/column-settings.types';
+import { IColumnData, IHasuraQueryFilter, RegisterTableCellSorter, ThWidthEntry } from '../../components';
+import { ApplySelectionTypes } from '../../components/checkbox-selector/checkbox-selector.types';
+import { FiltersStateService, FiltersService, FiltersTransmitService, SelectedObjectsStateService } from '../../services';
+import { FormGroupWrapper } from '../form-group-wrapper';
+import { ScalarUUID } from 'hasura';
+import { RegisterBaseStore } from './register-base.store';
+import * as i0 from "@angular/core";
+export declare abstract class RegisterBase<T extends IRegisterBase, Form = any> implements OnInit, AfterViewInit, OnDestroy {
+    protected readonly injector: Injector;
+    /** Сервисы управления фильтрами */
+    protected readonly filtersService: FiltersService<any>;
+    protected readonly stateService: FiltersStateService<any>;
+    protected readonly transmitter: FiltersTransmitService | null;
+    /** Сервис управления пользователем */
+    protected readonly userService: import("../../types").IUserProfileLoader<IUserProfile<any>, unknown>;
+    /** Сервис управления данными в реестре */
+    protected readonly baseStore: RegisterBaseStore<T, import("../../types").IBaseRegisterStoreState<T>> | null;
+    protected readonly selectedService: SelectedObjectsStateService<any> | null;
+    protected readonly router: Router;
+    protected readonly cdr: ChangeDetectorRef;
+    protected readonly destroyRef: DestroyRef;
+    private readonly settingsService;
+    readonly filterApplied$: Observable<boolean>;
+    readonly page$: Observable<number>;
+    readonly limit$: Observable<number | null>;
+    readonly selectedRecordsLoading$: BehaviorSubject<boolean>;
+    columnsData: IColumnData[];
+    columns: string[];
+    data: T[];
+    visibleData: T[];
+    dataCount: number;
+    /** @deprecated Используйте selectedObjectsFromState */
+    selectedObjects: Set<any>;
+    /** @deprecated Используйте selectedIdsFromState */
+    selectedIds: Set<ScalarUUID>;
+    _user: IUserProfile<any>;
+    stickyLeftIds: string[];
+    stickyRightIds: string[];
+    currentFilter: IHasuraQueryFilter<T> | null;
+    /**
+     * Форма фильтров
+     */
+    protected filtersForm: FormGroupWrapper<Form>;
+    protected filterState: ITpUserSettingsSettingsFilter[];
+    private _limit;
+    private _offset;
+    private _filterState;
+    private _modulePath;
+    private _defaultFilterApplied$;
+    /**
+     * Всего записей, без учета фильтра
+     */
+    abstract totalNotFiltered$: Observable<number>;
+    /**
+     * Маршруты для бредкрамба
+     */
+    abstract routes: any[];
+    /**
+     * Контрол строки поиска
+     */
+    searchInput: import("../../types").IInputControl<string | null, any>;
+    /**
+     * Действие завершено
+     */
+    abstract actionCompleted$: ReplaySubject<boolean>;
+    /**
+     * Получение общего количества записей
+     */
+    abstract fetchTotalObjects: (observableOrValue: Record<string, any> | Observable<Record<string, any>>) => Subscription;
+    /**
+     * Запрос на количество отфильтрованных записей
+     */
+    fetchTotalFilteredObjects: ((observableOrValue: Record<string, any> | Observable<Record<string, any>>) => Subscription) | undefined;
+    /**
+     * Подписка на получение всех объектов и с обратным вызовом
+     */
+    abstract objectsSubscription: (observableOrValue: ObjectsSubscriptionConfig<T> | Observable<ObjectsSubscriptionConfig<T>>) => Subscription;
+    /**
+     * Базовый фильтр, по умолчанию
+     */
+    abstract baseFilter: (user: IUserProfile | undefined) => Record<string, any>;
+    /**
+     * Сборка фильтра
+     */
+    abstract buildFilter(limit?: number, offset?: number, gqlFilter?: GqlFields, sorter?: RegisterTableCellSorter<T>[]): any;
+    /**
+     * Сборка фильтров реестра
+     */
+    protected abstract get buildForm(): FormGroupWrapper<Form>;
+    get limit(): number;
+    get offset(): number;
+    /** Uuid'ы всех выбранных или исключаемых объектов реестра (зависит от состояния еще не загруженных объектов) */
+    get idsFromState(): Set<ScalarUUID>;
+    /** Все выбранные uuid'ы реестра */
+    get selectedIdsFromState(): Set<ScalarUUID>;
+    /** Все выбранные объекты реестра */
+    get selectedObjectsFromState(): Set<T>;
+    private _columnsSettings;
+    private _pageRowsLimitSetting;
+    private readonly _defaultColumnsWidths;
+    private readonly _selectionType$;
+    readonly stateObjects: import("@angular/core").WritableSignal<Map<ScalarUUID, IRegisterObject<any>>> | undefined;
+    protected constructor(injector: Injector, columnsData: IColumnData[]);
+    private _subscribeOnSettings;
+    private _omitUndefined;
+    private _setColumnsWidth;
+    private _fetchSavedPageRowsLimit;
+    ngOnInit(): void;
+    ngAfterViewInit(searchLimiter?: number): void;
+    private _setFilters;
+    protected applyBaseFilter(_data?: any): void;
+    ngOnDestroy(): void;
+    protected applyFilters(filters: ITpUserSettingsSettingsFilter[]): void;
+    protected setData(data: T[], count?: number): void;
+    protected updateAllStateObjectsByState(state: ERegisterObjectState): void;
+    protected updateStateObjectByKey(key: ScalarUUID, updates: Partial<IRegisterObject<T>>): void;
+    protected clearSelections(data?: T[]): void;
+    protected actionCompleted(): void;
+    protected buildActions(_data: {
+        row: T[];
+        count: number;
+    }): void;
+    protected subscribeOnSearchChanges(limiter: number): void;
+    updateRegister(): void;
+    subscribeOnPaging(): void;
+    private _setStateObjects;
+    selectChanged(value: ApplySelectionTypes): void;
+    private _changeStateObjects;
+    private _inverseStateObjects;
+    private _selectVisibleStateObjects;
+    private _selectFirstNStateObjects;
+    private _selectFirstNLoadingObjects;
+    filterToggle(): void;
+    onPaginatorChange(paginatorChange: {
+        first: number;
+        page: number;
+        pagesCount: number | null;
+        rows: number;
+    }): void;
+    private _savePageRowsLimit;
+    updateColumnSettings({ settings }: IColumnSettingsChanges): void;
+    private _getColumnIdsRecursive;
+    updateSort(sort: RegisterTableCellSorter<any>[]): void;
+    protected saveThsWidthToUserSettings(tableColumnsWidth: ThWidthEntry[]): void;
+    protected get filtersAreOpened(): boolean;
+    private _subscribeOnMutationCompleted;
+    private _initDefaultFilter;
+    private _applyFilterSettings;
+    private _selectChangedFilter;
+    private _handleAllOrNumberSelection;
+    private _selectFirstNItems;
+    private _selectVisibleItems;
+    private _handleInverseSelection;
+    private _setSelected;
+    protected parseToFilters(input: {
+        [key: string]: any;
+    }): ITpUserSettingsSettingsFilter[];
+    protected get selectedCount(): number;
+    private _getDefaultColumnsRecursive;
+    protected get notAllFetched(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterBase<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RegisterBase<any, any>, never, never, {}, {}, never, never, false, never>;
+}

package/lib/core/register-base/register-base.store.d.ts

@@ -0,0 +1,35 @@
+import { ComponentStore } from '@ngrx/component-store';
+import { PrizmTableCellSorter } from '@prizm-ui/components';
+import { Apollo, MutationResult } from 'apollo-angular';
+import { Observable, ReplaySubject, Subscription } from 'rxjs';
+import { IHasuraQueryFilter } from '../../components/register-table/model/schema';
+import { GqlFields } from '../../types/inputs.types';
+import { IBaseRegisterStore, IBaseRegisterStoreState } from '../../types/register-base.types';
+import { HasuraError } from '../../types/hasura.types';
+import * as i0 from "@angular/core";
+export declare abstract class RegisterBaseStore<Type extends Record<string, any>, State extends IBaseRegisterStoreState<Type> = IBaseRegisterStoreState<Type>> extends ComponentStore<State> implements IBaseRegisterStore<Type> {
+    protected apollo: Apollo;
+    readonly error: (e: HasuraError) => void;
+    getBaseFilter(params?: any): Record<string, any>;
+    readonly mutationCompleted$: ReplaySubject<boolean>;
+    readonly loading$: Observable<boolean>;
+    readonly count$: Observable<number>;
+    readonly total$: Observable<number>;
+    readonly objects$: Observable<Type[]>;
+    readonly setObjects: (observableOrValue: Type[] | Observable<Type[]>) => Subscription;
+    readonly setLoading: (observableOrValue: boolean | Observable<boolean>) => Subscription;
+    readonly setCount: (observableOrValue: number | Observable<number>) => Subscription;
+    readonly setTotal: (observableOrValue: number | Observable<number>) => Subscription;
+    abstract readonly deleteByIds: (ids: string[], ...args: unknown[]) => Observable<MutationResult<Type[]> | null>;
+    abstract readonly fetchTotal: (observableOrValue: Record<string, any> | Observable<Record<string, any>>) => Subscription;
+    abstract readonly fetchObjects: (observableOrValue: {
+        filter: IHasuraQueryFilter<Type>;
+        callback?: (data: Type[]) => void;
+    } | Observable<{
+        filter: IHasuraQueryFilter<Type>;
+        callback?: (data: Type[]) => void;
+    }>) => Subscription;
+    abstract buildFilter(limit: number | undefined, offset: number | undefined, gqlFilter: GqlFields | undefined, sorter?: PrizmTableCellSorter<Type>[]): IHasuraQueryFilter<Type>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterBaseStore<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RegisterBaseStore<any, any>>;
+}

package/lib/directives/date/date-time.types.d.ts

@@ -0,0 +1,32 @@
+import { PrizmDay, PrizmTime } from '@prizm-ui/components';
+export declare enum EDatePattern {
+    MONTH_YEAR = "MM.yyyy",
+    DATE = "dd.MM.yyyy",
+    SHORT_YEAR_DATE = "dd.MM.yy",
+    DATE_TIME_WITHOUT_SECONDS = "dd.MM.yyyy HH:mm",
+    DATE_TIME = "dd.MM.yyyy HH:mm:ss",
+    YEAR_MONTH_DAY = "yyyy-MM-dd",
+    DD_MM_YYYY = "dd-MM-yyyy",
+    DATE_TIME_ISO_MARKED_TIMEZONE = "yyyy-MM-dd'T'HH:mm:ss",
+    YYYY_MM_DD = "yyyy/MM/dd",
+    MMMM_YYYY = "MMMM YYYY",
+    DATE_TIME_ISO_PATTERN = "YYYY-MM-DDTHH:mm:ss",
+    DATE_TIME_FOR_TRACKER = "YYYY-MM-DD HH:mm:ss",
+    DATE_TIME_FOR_TRACKER_NOT_SIMPLE = "yyyy-MM-dd HH:mm:ss",
+    TUI_YMD = "YMD",
+    DAY = "d",
+    HOUR_MINUTE = "HH:mm"
+}
+export declare enum EMomentPattern {
+    YYYY_MM_DD = "YYYY-MM-DD",
+    YYYYMMDD = "yyyy/MM/DD"
+}
+export declare enum ETimezone {
+    UTC = "+00:00",
+    MSK = "+03:00",
+    AQT = "+05:00",
+    NVS = "+07:00",
+    IRK = "+08:00",
+    YAK = "+09:00"
+}
+export type SmaPrizmDateTime = [PrizmDay, PrizmTime | undefined];

package/lib/directives/date/format-date.pipe.d.ts

@@ -0,0 +1,10 @@
+import { PipeTransform } from '@angular/core';
+import { DateTimeService, ITimeZone } from '../../services/date-time.service';
+import * as i0 from "@angular/core";
+export declare class FormatDatePipe implements PipeTransform {
+    private readonly _dateTimeService;
+    constructor(_dateTimeService: DateTimeService);
+    transform(value: unknown, valueTZ: string, pattern: string, _?: ITimeZone | null): unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatDatePipe, "formatDate", true>;
+}

package/lib/directives/number/number-only.directive.d.ts

@@ -0,0 +1,10 @@
+import { InputElementEvent } from '../../types';
+import * as i0 from "@angular/core";
+/** Ввод только числовых выражений */
+export declare class NumberOnlyDirective {
+    /** Разрешать пользователю вводить дробные числа (возможность использовать точку или запятую) */
+    allowFractional: import("@angular/core").InputSignal<boolean>;
+    onInput(event: InputElementEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberOnlyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NumberOnlyDirective, "[numberOnly]", never, { "allowFractional": { "alias": "allowFractional"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/directives/sticky/sticky-relative.directive.d.ts

@@ -0,0 +1,13 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class StickyRelativeDirective implements OnInit {
+    columns: import("@angular/core").InputSignal<unknown[]>;
+    private _columnsChanges$;
+    private readonly _stickyRelativeService;
+    private readonly _dr;
+    private readonly _elRef;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StickyRelativeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StickyRelativeDirective, "[stickyRelative]", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/directives/sticky/sticky-relative.service.d.ts

@@ -0,0 +1,15 @@
+import { OnDestroy } from '@angular/core';
+import { StickyDirective } from './sticky.directive';
+import * as i0 from "@angular/core";
+export declare class StickyRelativeService implements OnDestroy {
+    element: HTMLElement;
+    private readonly _changesChildren$;
+    private readonly _resizeObserver;
+    readonly changesChildren$: import("rxjs").Observable<void>;
+    add(item: StickyDirective): void;
+    delete(item: StickyDirective): void;
+    nextChangesChildren(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StickyRelativeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StickyRelativeService>;
+}

package/lib/directives/sticky/sticky.directive.d.ts

@@ -0,0 +1,27 @@
+import { ElementRef, OnChanges, OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class StickyDirective implements OnChanges, OnDestroy, OnInit {
+    stickyLeft: import("@angular/core").InputSignal<boolean | undefined>;
+    stickyRight: import("@angular/core").InputSignal<boolean | undefined>;
+    stickyTop: import("@angular/core").InputSignal<boolean | undefined>;
+    stickyBottom: import("@angular/core").InputSignal<boolean | undefined>;
+    stickyRelative: import("@angular/core").InputSignal<HTMLElement | undefined>;
+    position: import("@angular/core").InputSignal<string>;
+    stylesOnSticky: import("@angular/core").InputSignal<Record<string, unknown> | undefined>;
+    get applySticky(): string;
+    readonly elRef: ElementRef<any>;
+    private readonly _relativeService;
+    private readonly _renderer;
+    private readonly _destroyRef;
+    private readonly _destroyPrevious;
+    private readonly _changedSides;
+    private _setActiveStyle;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(): void;
+    private _init;
+    private _clearStylesIfSet;
+    private _setStylesIfExist;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StickyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StickyDirective, "[stickyLeft], [stickyRight], [stickyTop], [stickyBottom]", never, { "stickyLeft": { "alias": "stickyLeft"; "required": false; "isSignal": true; }; "stickyRight": { "alias": "stickyRight"; "required": false; "isSignal": true; }; "stickyTop": { "alias": "stickyTop"; "required": false; "isSignal": true; }; "stickyBottom": { "alias": "stickyBottom"; "required": false; "isSignal": true; }; "stickyRelative": { "alias": "stickyRelative"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "stylesOnSticky": { "alias": "stylesOnSticky"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/services/date-time.service.d.ts

@@ -0,0 +1,80 @@
+import { Moment } from 'moment-timezone';
+import { EDatePattern, SmaPrizmDateTime } from '../directives/date/date-time.types';
+import { PrizmDateTimeRange } from '@prizm-ui/components';
+import { TuiDay } from '@taiga-ui/cdk';
+import * as i0 from "@angular/core";
+export interface ITimeZone {
+    time_diff: string;
+    string: string;
+    value: string;
+}
+export interface ICurrentTime_TZ {
+    current_time: string;
+    picked_time_zone: ITimeZone;
+}
+export declare const timezoneSelectItems: string[];
+export declare const TIME_ZONES: ITimeZone[];
+export declare const TIME_ZONE_HINTS: Record<string, string>;
+export declare class DateTimeService {
+    readonly currentTimeTZ: ICurrentTime_TZ;
+    private readonly _isTimeZoneChanged;
+    isTimeZoneChanged$: import("rxjs").Observable<ITimeZone>;
+    constructor();
+    updateTimezone(time_zone: ITimeZone): void;
+    refreshDatePicked(): void;
+    getCurrentTime(): string;
+    triggerTimeUpdate(timeZone: ITimeZone): void;
+    /**
+     * @param utc время в UTC
+     * @param pattern
+     * Строка состоящая из:
+     *dd - день,
+     *MM - месяц,
+     *yyyy - год,
+     *HH - часы в 24ч-формате,
+     *hh - часы в 12ч-формате,
+     *mm - минуты,
+     *ss - секунды,
+     *sss - миллисекунды,
+     */
+    parseDate(utc: string, pattern: string): string;
+    /** @deprecated use parseDate(iso: string, pattern: string): string method */
+    parseDateToMMYYYY(iso: string): string;
+    /** @deprecated use parseDate(iso: string, pattern: string): string method */
+    parseDateToDDMMYYYY(iso: string): string;
+    isoToLocalDate(iso: string, tzDiff?: string): Date;
+    isoToUTCDate(iso: string): Date;
+    private _hasTimeZone;
+    /**
+     * Возвращает дату конвертированную в ISO формат без учета таймзоны
+     * */
+    dateToIsoWithoutTimeZone(date: Date): string | null;
+    formatDateSave(date?: string | null, option?: 'YMD'): string;
+    formatTimeSave(date?: string): string;
+    toISOString(date: Date, tzDiff?: string): string;
+    _momentWithTZ(date: Date, timezone: string): Moment;
+    private _dateToISOSliceZ;
+    convertDateToISOWithTZ(date: Date, tz: string): string;
+    now(): Date;
+    /**
+     * return объект типа moment с таймзоной выбранной в приложении
+     * */
+    momentNowWithLocalTimezone(): Moment;
+    nowUTC(): Date;
+    getWorkingDatesCount(startDate: Date, endDate: Date): number;
+    getCurrentDateWithoutTime(): Date;
+    getDateWithoutTime(date: Date): Date;
+    getXMonthBackDate(monthBackNumber: number): Date;
+    prizmDateTimeRangeToNativeDates(range: PrizmDateTimeRange): {
+        from: Date;
+        to: Date;
+    };
+    prizmDateTimeRangeFromNativeDates(from: Date, to: Date): PrizmDateTimeRange;
+    prizmDateTimeToNativeDate(prizmDateTime: SmaPrizmDateTime): Date;
+    getTuiDayFromString(date: string): TuiDay;
+    getTuiDayFromDate(date: Date): TuiDay;
+    transferTuiDayToString(date: TuiDay | null, pattern?: EDatePattern): string | null;
+    toSmaPrizmDateTime(dateString: string): SmaPrizmDateTime;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateTimeService>;
+}

package/lib/services/dialog/dialog.service.d.ts

@@ -0,0 +1,22 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DialogContext, DialogOptions } from './dialog.types';
+import { TuiDialogOptions } from '@taiga-ui/core';
+import { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare class DialogService {
+    private readonly _dialogService;
+    private readonly _tuiDialogService;
+    openModal(template: unknown, config: Partial<DialogOptions<unknown, unknown>>): Observable<any>;
+    openModalTaiga<Context extends DialogContext, Result = any>(component: new (...args: any[]) => unknown, context: Context, injector?: Injector): Observable<Result>;
+    /**
+     * Универсальная функция открытия диалога
+     *
+     * @param content - контент (компонент, ng-template или функция)
+     * @param context - данные для передачи в контент
+     * @param options - доп. настройки диалога (ширина, заголовок и т.д.)
+     */
+    openTuiDialogWithTemplate<T = void>(content: PolymorpheusContent<TuiDialogOptions<T>>, context?: Partial<TuiDialogOptions<T>>, options?: Partial<TuiDialogOptions<T>>): Observable<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
+}