ngx-register-base 1.3.1 → 1.3.2

package/esm2022/lib/services/date-time.service.mjs

@@ -0,0 +1,314 @@
+import { Injectable } from '@angular/core';
+import { format } from 'date-fns';
+import moment from 'moment-timezone';
+import { BehaviorSubject } from 'rxjs';
+import { STORED_TIMEZONE } from '../consts/date-time.consts';
+import { EDatePattern, ETimezone } from '../directives/date/date-time.types';
+import { PrizmDateTimeRange, PrizmDay, PrizmDayRange, PrizmTime, PrizmTimeRange, } from '@prizm-ui/components';
+import { TuiDay } from '@taiga-ui/cdk';
+import * as i0 from "@angular/core";
+// Не менять формат, названия и ' ' оставлять всегда
+// 'UTC ' - оставлять
+// Eсли менять,изменить фильтры в ДО
+export const timezoneSelectItems = [
+    'UTC +00:00',
+    'Europe/Moscow +03:00',
+    'Asia/Aqtau +05:00',
+    'Asia/Yekaterinburg +05:00',
+    'Asia/Novosibirsk +07:00',
+    'Asia/Krasnoyarsk +07:00',
+    'Asia/Irkutsk +08:00',
+    'Asia/Yakutsk +09:00',
+];
+export const TIME_ZONES = [
+    {
+        value: 'Etc/GMT',
+        string: '+00:00 UTC',
+        time_diff: ETimezone.UTC,
+    },
+    {
+        value: 'Europe/Moscow',
+        string: '+03:00 Москва',
+        time_diff: ETimezone.MSK,
+    },
+    {
+        value: 'Asia/Aqtau',
+        string: '+05:00 Тюмень',
+        time_diff: ETimezone.AQT,
+    },
+    {
+        value: 'Asia/Novosibirsk',
+        string: '+07:00 Томск',
+        time_diff: ETimezone.NVS,
+    },
+    {
+        value: 'Asia/Irkutsk',
+        string: '+08:00 Иркутск',
+        time_diff: ETimezone.IRK,
+    },
+    {
+        value: 'Asia/Yakutsk',
+        string: '+09:00 Якутск',
+        time_diff: ETimezone.YAK,
+    },
+];
+export const TIME_ZONE_HINTS = {
+    '+00:00': '+00:00 UTC',
+    '+03:00': 'ГПН-БС, ГПН-ГЕО, ГПН-НС, ГПН-ТП, ГПН-Щ, МНГП, НТЦ, Парадная, СПД',
+    '+05:00': 'ГПН-А, ГПН-БГП, ГПН-З, ГПН-ИТО, ГПН-М, ГПН-Н, ГПН-О, ГПН-Р, ГПН-С, ГПН-Х, ГПН-Я, МРТ, МсНГ, МЭН, ННГГФ, НТН, НЭН, СН-МНГ',
+    '+07:00': 'ГПН-В, МНГ-Г, ИН-ВНК',
+    '+08:00': 'Игнялинское м/р',
+    '+09:00': 'Чаяндинское м/р, Тымпучиканское м/р, Вакунайское м/р, Тас-Юряхское м/р',
+};
+export class DateTimeService {
+    constructor() {
+        this.currentTimeTZ = {
+            picked_time_zone: TIME_ZONES[1],
+            current_time: new Date().toISOString(),
+        };
+        this._isTimeZoneChanged = new BehaviorSubject(this.currentTimeTZ.picked_time_zone);
+        this.isTimeZoneChanged$ = this._isTimeZoneChanged.asObservable();
+        const storedTimeZone = localStorage.getItem(STORED_TIMEZONE);
+        if (storedTimeZone) {
+            this.currentTimeTZ.picked_time_zone = JSON.parse(storedTimeZone);
+        }
+        else {
+            this.currentTimeTZ.current_time = this.getCurrentTime();
+        }
+    }
+    updateTimezone(time_zone) {
+        localStorage.setItem(STORED_TIMEZONE, JSON.stringify(time_zone));
+        this.currentTimeTZ.picked_time_zone = time_zone;
+        this.currentTimeTZ.current_time = this.getCurrentTime();
+        this._isTimeZoneChanged.next(this.currentTimeTZ.picked_time_zone);
+    }
+    refreshDatePicked() {
+        this._isTimeZoneChanged.next(this.currentTimeTZ.picked_time_zone);
+    }
+    getCurrentTime() {
+        const options = {
+            timeZone: this.currentTimeTZ.picked_time_zone.value,
+            hour12: false,
+            hour: '2-digit',
+            minute: '2-digit',
+        };
+        return new Date().toLocaleString('en-GB', options);
+    }
+    triggerTimeUpdate(timeZone) {
+        this._isTimeZoneChanged.next(timeZone);
+    }
+    /**
+     * @param utc время в UTC
+     * @param pattern
+     * Строка состоящая из:
+     *dd - день,
+     *MM - месяц,
+     *yyyy - год,
+     *HH - часы в 24ч-формате,
+     *hh - часы в 12ч-формате,
+     *mm - минуты,
+     *ss - секунды,
+     *sss - миллисекунды,
+     */
+    parseDate(utc, pattern) {
+        const date = this.isoToLocalDate(utc);
+        return format(date, pattern);
+    }
+    /** @deprecated use parseDate(iso: string, pattern: string): string method */
+    parseDateToMMYYYY(iso) {
+        const options = {
+            hour12: false,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+        };
+        const date = this.isoToLocalDate(iso).toLocaleString('en-GB', options);
+        const [_, month, year] = date.split('/');
+        return `${month}.${year}`;
+    }
+    /** @deprecated use parseDate(iso: string, pattern: string): string method */
+    parseDateToDDMMYYYY(iso) {
+        const options = {
+            hour12: false,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+        };
+        const date = this.isoToLocalDate(iso).toLocaleString('en-GB', options);
+        const [day, month, year] = date.split('/');
+        return `${day}.${month}.${year}`;
+    }
+    isoToLocalDate(iso, tzDiff) {
+        const date = this.isoToUTCDate(iso);
+        let diffTZ = tzDiff;
+        if (!tzDiff) {
+            diffTZ = this.currentTimeTZ.picked_time_zone.time_diff;
+        }
+        const hours = Number.parseInt(diffTZ, 10);
+        date.setHours(date.getHours() + hours);
+        return date;
+    }
+    isoToUTCDate(iso) {
+        let dateString = iso;
+        // Перевод из таймзоны сервера к UTC
+        if (this._hasTimeZone(iso)) {
+            dateString = new Date(iso).toISOString();
+        }
+        if (dateString.includes('Z')) {
+            dateString = dateString.slice(0, dateString.lastIndexOf('Z'));
+        }
+        return new Date(dateString);
+    }
+    _hasTimeZone(iso) {
+        const timeZoneRegex = /[+-]\d{2}(:\d{2})?$/;
+        return timeZoneRegex.test(iso);
+    }
+    /**
+     * Возвращает дату конвертированную в ISO формат без учета таймзоны
+     * */
+    dateToIsoWithoutTimeZone(date) {
+        let result = null;
+        if (date) {
+            const timestamp = date.getTime() - date.getTimezoneOffset() * 60_000;
+            const correctDate = new Date(timestamp);
+            result = correctDate.toISOString();
+        }
+        return result;
+    }
+    formatDateSave(date, option) {
+        let result = '';
+        if (date) {
+            result = option ? format(date, 'yyyy-MM-dd') : format(date, EDatePattern.DATE);
+        }
+        return result;
+    }
+    formatTimeSave(date) {
+        const dateTime = new Date(date);
+        const result = [dateTime.getHours(), dateTime.getMinutes(), dateTime.getSeconds()]
+            .map((time) => (time < 10 ? `0${time}` : time))
+            .join(':');
+        return result;
+    }
+    toISOString(date, tzDiff) {
+        let diffTZ = tzDiff;
+        if (!tzDiff) {
+            diffTZ = this.currentTimeTZ.picked_time_zone.time_diff;
+        }
+        const m = this._momentWithTZ(date, diffTZ);
+        return m.toISOString();
+    }
+    _momentWithTZ(date, timezone) {
+        const iso = this._dateToISOSliceZ(date);
+        let tz = timezone;
+        if (timezone === ETimezone.UTC) {
+            tz = 'Z';
+        }
+        return moment.parseZone(`${iso}${tz}`);
+    }
+    _dateToISOSliceZ(date) {
+        const iso = this.dateToIsoWithoutTimeZone(date);
+        return iso.includes('Z') ? iso.slice(0, iso.lastIndexOf('Z')) : iso;
+    }
+    convertDateToISOWithTZ(date, tz) {
+        const pad = (str) => str.toString().padStart(2, '0');
+        const datePart = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+        const timePart = `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+        return `${datePart}T${timePart}${tz}`;
+    }
+    now() {
+        const date = new Date();
+        const [hour, minutes] = this.currentTimeTZ.current_time
+            .split(':')
+            .map((value) => Number.parseInt(value, 10));
+        date.setHours(hour);
+        date.setMinutes(minutes);
+        return date;
+    }
+    /**
+     * return объект типа moment с таймзоной выбранной в приложении
+     * */
+    momentNowWithLocalTimezone() {
+        return moment.tz(this.currentTimeTZ.picked_time_zone.value);
+    }
+    nowUTC() {
+        return new Date(moment.utc().format());
+    }
+    getWorkingDatesCount(startDate, endDate) {
+        const sunday = 0;
+        const saturday = 6;
+        let count = 0;
+        const currentDate = new Date(startDate);
+        while (currentDate <= endDate) {
+            const dayOfWeek = currentDate.getDay();
+            if (dayOfWeek !== sunday && dayOfWeek !== saturday) {
+                count += 1;
+            }
+            currentDate.setDate(currentDate.getDate() + 1);
+        }
+        return count;
+    }
+    getCurrentDateWithoutTime() {
+        const currentDate = new Date();
+        currentDate.setHours(0);
+        currentDate.setMinutes(0);
+        currentDate.setSeconds(0);
+        currentDate.setMilliseconds(0);
+        return currentDate;
+    }
+    getDateWithoutTime(date) {
+        date.setHours(0);
+        date.setMinutes(0);
+        date.setSeconds(0);
+        date.setMilliseconds(0);
+        return date;
+    }
+    getXMonthBackDate(monthBackNumber) {
+        const currentDate = new Date();
+        currentDate.setMonth(currentDate.getMonth() - monthBackNumber);
+        return currentDate;
+    }
+    prizmDateTimeRangeToNativeDates(range) {
+        const { dayRange, timeRange } = range;
+        const from = this.prizmDateTimeToNativeDate([dayRange.from, timeRange?.from]);
+        const to = this.prizmDateTimeToNativeDate([dayRange.to, timeRange?.to]);
+        return { from, to };
+    }
+    prizmDateTimeRangeFromNativeDates(from, to) {
+        return new PrizmDateTimeRange(PrizmDayRange.fromLocalNativeDate(from, to), new PrizmTimeRange(PrizmTime.fromLocalNativeDate(from), PrizmTime.fromLocalNativeDate(to)));
+    }
+    prizmDateTimeToNativeDate(prizmDateTime) {
+        const [day, time] = prizmDateTime;
+        const date = new Date(day.toLocalNativeDate());
+        if (time) {
+            date.setHours(time.hours, time.minutes, time.seconds, time.ms);
+        }
+        return date;
+    }
+    getTuiDayFromString(date) {
+        const localDate = this.isoToLocalDate(date);
+        return new TuiDay(localDate.getFullYear(), localDate.getMonth(), localDate.getDate());
+    }
+    getTuiDayFromDate(date) {
+        return new TuiDay(date.getFullYear(), date.getMonth(), date.getDate());
+    }
+    transferTuiDayToString(date, pattern) {
+        return date ? format(date.toLocalNativeDate(), pattern ?? EDatePattern.YEAR_MONTH_DAY) : null;
+    }
+    toSmaPrizmDateTime(dateString) {
+        const date = new Date(dateString);
+        const hours = date.getHours();
+        const min = date.getMinutes();
+        const day = PrizmDay.fromLocalNativeDate(date);
+        const time = new PrizmTime(hours, min);
+        return [day, time];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DateTimeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DateTimeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DateTimeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-register-base/src/lib/services/date-time.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { format } from 'date-fns';\nimport moment, { Moment } from 'moment-timezone';\nimport { BehaviorSubject } from 'rxjs';\nimport { STORED_TIMEZONE } from '../consts/date-time.consts';\nimport { EDatePattern, ETimezone, SmaPrizmDateTime } from '../directives/date/date-time.types';\nimport {\n  PrizmDateTimeRange,\n  PrizmDay,\n  PrizmDayRange,\n  PrizmTime,\n  PrizmTimeRange,\n} from '@prizm-ui/components';\nimport { TuiDay } from '@taiga-ui/cdk';\n\nexport interface ITimeZone {\n  time_diff: string;\n  string: string;\n  value: string;\n}\n\nexport interface ICurrentTime_TZ {\n  current_time: string;\n  picked_time_zone: ITimeZone;\n}\n\n// Не менять формат, названия и ' ' оставлять всегда\n// 'UTC ' - оставлять\n// Eсли менять,изменить фильтры в ДО\nexport const timezoneSelectItems = [\n  'UTC +00:00',\n  'Europe/Moscow +03:00',\n  'Asia/Aqtau +05:00',\n  'Asia/Yekaterinburg +05:00',\n  'Asia/Novosibirsk +07:00',\n  'Asia/Krasnoyarsk +07:00',\n  'Asia/Irkutsk +08:00',\n  'Asia/Yakutsk +09:00',\n];\nexport const TIME_ZONES: ITimeZone[] = [\n  {\n    value: 'Etc/GMT',\n    string: '+00:00 UTC',\n    time_diff: ETimezone.UTC,\n  },\n  {\n    value: 'Europe/Moscow',\n    string: '+03:00 Москва',\n    time_diff: ETimezone.MSK,\n  },\n  {\n    value: 'Asia/Aqtau',\n    string: '+05:00 Тюмень',\n    time_diff: ETimezone.AQT,\n  },\n  {\n    value: 'Asia/Novosibirsk',\n    string: '+07:00 Томск',\n    time_diff: ETimezone.NVS,\n  },\n  {\n    value: 'Asia/Irkutsk',\n    string: '+08:00 Иркутск',\n    time_diff: ETimezone.IRK,\n  },\n  {\n    value: 'Asia/Yakutsk',\n    string: '+09:00 Якутск',\n    time_diff: ETimezone.YAK,\n  },\n];\n\nexport const TIME_ZONE_HINTS: Record<string, string> = {\n  '+00:00': '+00:00 UTC',\n  '+03:00': 'ГПН-БС, ГПН-ГЕО, ГПН-НС, ГПН-ТП, ГПН-Щ, МНГП, НТЦ, Парадная, СПД',\n  '+05:00':\n    'ГПН-А, ГПН-БГП, ГПН-З, ГПН-ИТО, ГПН-М, ГПН-Н, ГПН-О, ГПН-Р, ГПН-С, ГПН-Х, ГПН-Я, МРТ, МсНГ, МЭН, ННГГФ, НТН, НЭН, СН-МНГ',\n  '+07:00': 'ГПН-В, МНГ-Г, ИН-ВНК',\n  '+08:00': 'Игнялинское м/р',\n  '+09:00': 'Чаяндинское м/р, Тымпучиканское м/р, Вакунайское м/р, Тас-Юряхское м/р',\n};\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class DateTimeService {\n  public readonly currentTimeTZ: ICurrentTime_TZ = {\n    picked_time_zone: TIME_ZONES[1],\n    current_time: new Date().toISOString(),\n  };\n\n  private readonly _isTimeZoneChanged = new BehaviorSubject<ITimeZone>(\n    this.currentTimeTZ.picked_time_zone\n  );\n  public isTimeZoneChanged$ = this._isTimeZoneChanged.asObservable();\n\n  public constructor() {\n    const storedTimeZone = localStorage.getItem(STORED_TIMEZONE);\n\n    if (storedTimeZone) {\n      this.currentTimeTZ.picked_time_zone = JSON.parse(storedTimeZone) as ITimeZone;\n    } else {\n      this.currentTimeTZ.current_time = this.getCurrentTime();\n    }\n  }\n\n  public updateTimezone(time_zone: ITimeZone): void {\n    localStorage.setItem(STORED_TIMEZONE, JSON.stringify(time_zone));\n\n    this.currentTimeTZ.picked_time_zone = time_zone;\n    this.currentTimeTZ.current_time = this.getCurrentTime();\n    this._isTimeZoneChanged.next(this.currentTimeTZ.picked_time_zone);\n  }\n\n  public refreshDatePicked(): void {\n    this._isTimeZoneChanged.next(this.currentTimeTZ.picked_time_zone);\n  }\n\n  public getCurrentTime(): string {\n    const options: Intl.DateTimeFormatOptions = {\n      timeZone: this.currentTimeTZ.picked_time_zone.value,\n      hour12: false,\n      hour: '2-digit',\n      minute: '2-digit',\n    };\n    return new Date().toLocaleString('en-GB', options);\n  }\n\n  public triggerTimeUpdate(timeZone: ITimeZone): void {\n    this._isTimeZoneChanged.next(timeZone);\n  }\n\n  /**\n   * @param utc время в UTC\n   * @param pattern\n   * Строка состоящая из:\n   *dd - день,\n   *MM - месяц,\n   *yyyy - год,\n   *HH - часы в 24ч-формате,\n   *hh - часы в 12ч-формате,\n   *mm - минуты,\n   *ss - секунды,\n   *sss - миллисекунды,\n   */\n  public parseDate(utc: string, pattern: string): string {\n    const date: Date = this.isoToLocalDate(utc);\n\n    return format(date, pattern);\n  }\n\n  /** @deprecated use parseDate(iso: string, pattern: string): string method */\n  public parseDateToMMYYYY(iso: string): string {\n    const options: Intl.DateTimeFormatOptions = {\n      hour12: false,\n      year: 'numeric',\n      month: '2-digit',\n      day: '2-digit',\n    };\n\n    const date = this.isoToLocalDate(iso).toLocaleString('en-GB', options);\n    const [_, month, year] = date.split('/');\n\n    return `${month}.${year}`;\n  }\n\n  /** @deprecated use parseDate(iso: string, pattern: string): string method */\n  public parseDateToDDMMYYYY(iso: string): string {\n    const options: Intl.DateTimeFormatOptions = {\n      hour12: false,\n      year: 'numeric',\n      month: '2-digit',\n      day: '2-digit',\n    };\n\n    const date = this.isoToLocalDate(iso).toLocaleString('en-GB', options);\n    const [day, month, year] = date.split('/');\n\n    return `${day}.${month}.${year}`;\n  }\n\n  public isoToLocalDate(iso: string, tzDiff?: string): Date {\n    const date = this.isoToUTCDate(iso);\n    let diffTZ = tzDiff;\n    if (!tzDiff) {\n      diffTZ = this.currentTimeTZ.picked_time_zone.time_diff;\n    }\n\n    const hours = Number.parseInt(diffTZ!, 10);\n    date.setHours(date.getHours() + hours);\n\n    return date;\n  }\n\n  public isoToUTCDate(iso: string): Date {\n    let dateString = iso;\n\n    // Перевод из таймзоны сервера к UTC\n    if (this._hasTimeZone(iso)) {\n      dateString = new Date(iso).toISOString();\n    }\n\n    if (dateString.includes('Z')) {\n      dateString = dateString.slice(0, dateString.lastIndexOf('Z'));\n    }\n\n    return new Date(dateString);\n  }\n\n  private _hasTimeZone(iso: string): boolean {\n    const timeZoneRegex = /[+-]\\d{2}(:\\d{2})?$/;\n\n    return timeZoneRegex.test(iso);\n  }\n\n  /**\n   * Возвращает дату конвертированную в ISO формат без учета таймзоны\n   * */\n  public dateToIsoWithoutTimeZone(date: Date): string | null {\n    let result = null;\n\n    if (date) {\n      const timestamp = date.getTime() - date.getTimezoneOffset() * 60_000;\n      const correctDate = new Date(timestamp);\n\n      result = correctDate.toISOString();\n    }\n\n    return result;\n  }\n\n  public formatDateSave(date?: string | null, option?: 'YMD'): string {\n    let result = '';\n    if (date) {\n      result = option ? format(date, 'yyyy-MM-dd') : format(date, EDatePattern.DATE);\n    }\n    return result;\n  }\n\n  public formatTimeSave(date?: string): string {\n    const dateTime: Date = new Date(date!);\n    const result = [dateTime.getHours(), dateTime.getMinutes(), dateTime.getSeconds()]\n      .map((time) => (time < 10 ? `0${time}` : time))\n      .join(':');\n    return result;\n  }\n\n  public toISOString(date: Date, tzDiff?: string): string {\n    let diffTZ = tzDiff;\n    if (!tzDiff) {\n      diffTZ = this.currentTimeTZ.picked_time_zone.time_diff;\n    }\n\n    const m = this._momentWithTZ(date, diffTZ!);\n\n    return m.toISOString();\n  }\n\n  public _momentWithTZ(date: Date, timezone: string): Moment {\n    const iso = this._dateToISOSliceZ(date);\n    let tz = timezone;\n    if (timezone === ETimezone.UTC) {\n      tz = 'Z';\n    }\n\n    return moment.parseZone(`${iso}${tz}`);\n  }\n\n  private _dateToISOSliceZ(date: Date): string {\n    const iso = this.dateToIsoWithoutTimeZone(date)!;\n\n    return iso.includes('Z') ? iso.slice(0, iso.lastIndexOf('Z')) : iso;\n  }\n\n  public convertDateToISOWithTZ(date: Date, tz: string): string {\n    const pad = (str: number) => str.toString().padStart(2, '0');\n    const datePart = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;\n    const timePart = `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;\n\n    return `${datePart}T${timePart}${tz}`;\n  }\n\n  public now(): Date {\n    const date = new Date();\n    const [hour, minutes] = this.currentTimeTZ.current_time\n      .split(':')\n      .map((value) => Number.parseInt(value, 10));\n    date.setHours(hour);\n    date.setMinutes(minutes);\n\n    return date;\n  }\n\n  /**\n   * return объект типа moment с таймзоной выбранной в приложении\n   * */\n  public momentNowWithLocalTimezone(): Moment {\n    return moment.tz(this.currentTimeTZ.picked_time_zone.value);\n  }\n\n  public nowUTC(): Date {\n    return new Date(moment.utc().format());\n  }\n\n  public getWorkingDatesCount(startDate: Date, endDate: Date): number {\n    const sunday = 0;\n    const saturday = 6;\n\n    let count = 0;\n    const currentDate = new Date(startDate);\n\n    while (currentDate <= endDate) {\n      const dayOfWeek = currentDate.getDay();\n\n      if (dayOfWeek !== sunday && dayOfWeek !== saturday) {\n        count += 1;\n      }\n\n      currentDate.setDate(currentDate.getDate() + 1);\n    }\n\n    return count;\n  }\n\n  public getCurrentDateWithoutTime(): Date {\n    const currentDate = new Date();\n\n    currentDate.setHours(0);\n    currentDate.setMinutes(0);\n    currentDate.setSeconds(0);\n    currentDate.setMilliseconds(0);\n\n    return currentDate;\n  }\n\n  public getDateWithoutTime(date: Date): Date {\n    date.setHours(0);\n    date.setMinutes(0);\n    date.setSeconds(0);\n    date.setMilliseconds(0);\n\n    return date;\n  }\n\n  public getXMonthBackDate(monthBackNumber: number): Date {\n    const currentDate = new Date();\n    currentDate.setMonth(currentDate.getMonth() - monthBackNumber);\n    return currentDate;\n  }\n\n  public prizmDateTimeRangeToNativeDates(range: PrizmDateTimeRange): { from: Date; to: Date } {\n    const { dayRange, timeRange } = range;\n\n    const from = this.prizmDateTimeToNativeDate([dayRange.from, timeRange?.from]);\n    const to = this.prizmDateTimeToNativeDate([dayRange.to, timeRange?.to]);\n\n    return { from, to };\n  }\n\n  public prizmDateTimeRangeFromNativeDates(from: Date, to: Date): PrizmDateTimeRange {\n    return new PrizmDateTimeRange(\n      PrizmDayRange.fromLocalNativeDate(from, to),\n      new PrizmTimeRange(PrizmTime.fromLocalNativeDate(from), PrizmTime.fromLocalNativeDate(to))\n    );\n  }\n\n  public prizmDateTimeToNativeDate(prizmDateTime: SmaPrizmDateTime): Date {\n    const [day, time] = prizmDateTime;\n    const date = new Date(day.toLocalNativeDate());\n\n    if (time) {\n      date.setHours(time.hours, time.minutes, time.seconds, time.ms);\n    }\n\n    return date;\n  }\n\n  public getTuiDayFromString(date: string): TuiDay {\n    const localDate = this.isoToLocalDate(date);\n    return new TuiDay(localDate.getFullYear(), localDate.getMonth(), localDate.getDate());\n  }\n\n  public getTuiDayFromDate(date: Date): TuiDay {\n    return new TuiDay(date.getFullYear(), date.getMonth(), date.getDate());\n  }\n\n  public transferTuiDayToString(date: TuiDay | null, pattern?: EDatePattern): string | null {\n    return date ? format(date.toLocalNativeDate(), pattern ?? EDatePattern.YEAR_MONTH_DAY) : null;\n  }\n\n  public toSmaPrizmDateTime(dateString: string): SmaPrizmDateTime {\n    const date = new Date(dateString);\n    const hours = date.getHours();\n    const min = date.getMinutes();\n    const day = PrizmDay.fromLocalNativeDate(date);\n    const time = new PrizmTime(hours, min);\n    return [day, time];\n  }\n}\n"]}

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

@@ -0,0 +1,53 @@
+import { inject, Injectable } from '@angular/core';
+import { PrizmDialogService } from '@prizm-ui/components';
+import { DialogOverlayInsidePlacement } from './dialog.types';
+import { tuiDialog, TuiDialogService } from '@taiga-ui/core';
+import * as i0 from "@angular/core";
+export class DialogService {
+    constructor() {
+        this._dialogService = inject(PrizmDialogService);
+        this._tuiDialogService = inject(TuiDialogService);
+    }
+    openModal(template, config) {
+        return this._dialogService.open(template, {
+            closeable: false,
+            width: 440,
+            position: DialogOverlayInsidePlacement.CENTER,
+            backdrop: true,
+            ...config,
+        });
+    }
+    openModalTaiga(component, context, injector) {
+        const dialog = tuiDialog(component, {
+            injector,
+            closeable: context.closeable ?? false,
+            dismissible: context.dismissible ?? true,
+            size: context.size ?? 'auto',
+        });
+        return dialog({
+            ...context,
+        });
+    }
+    /**
+     * Универсальная функция открытия диалога
+     *
+     * @param content - контент (компонент, ng-template или функция)
+     * @param context - данные для передачи в контент
+     * @param options - доп. настройки диалога (ширина, заголовок и т.д.)
+     */
+    openTuiDialogWithTemplate(content, context, options) {
+        return this._tuiDialogService.open(content, {
+            ...context,
+            ...options,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DialogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DialogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/dialog/dialog.types.mjs

@@ -0,0 +1,2 @@
+export { PrizmOverlayInsidePlacement as DialogOverlayInsidePlacement } from '@prizm-ui/components';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJlZ2lzdGVyLWJhc2Uvc3JjL2xpYi9zZXJ2aWNlcy9kaWFsb2cvZGlhbG9nLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sRUFBRSwyQkFBMkIsSUFBSSw0QkFBNEIsRUFBRSxNQUFNLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUHJpem1EaWFsb2dPcHRpb25zIH0gZnJvbSAnQHByaXptLXVpL2NvbXBvbmVudHMnO1xuaW1wb3J0IHsgVHVpRGlhbG9nU2l6ZSB9IGZyb20gJ0B0YWlnYS11aS9jb3JlJztcblxuZXhwb3J0IHsgUHJpem1PdmVybGF5SW5zaWRlUGxhY2VtZW50IGFzIERpYWxvZ092ZXJsYXlJbnNpZGVQbGFjZW1lbnQgfSBmcm9tICdAcHJpem0tdWkvY29tcG9uZW50cyc7XG5cbmV4cG9ydCB0eXBlIERpYWxvZ09wdGlvbnM8TywgREFUQT4gPSBQcml6bURpYWxvZ09wdGlvbnM8TywgREFUQT47XG5cbmV4cG9ydCB0eXBlIERpYWxvZ1NpemUgPSBUdWlEaWFsb2dTaXplO1xuXG5leHBvcnQgaW50ZXJmYWNlIERpYWxvZ0NvbnRleHQge1xuICBjbG9zZWFibGU/OiBib29sZWFuO1xuICBkaXNtaXNzaWJsZT86IGJvb2xlYW47XG4gIHdpZHRoPzogbnVtYmVyO1xuICBzaXplPzogRGlhbG9nU2l6ZTtcbn1cbiJdfQ==

package/esm2022/lib/services/dialog/index.mjs

@@ -0,0 +1,3 @@
+export { DialogService } from './dialog.service';
+export * from './dialog.types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtcmVnaXN0ZXItYmFzZS9zcmMvbGliL3NlcnZpY2VzL2RpYWxvZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDakQsY0FBYyxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IERpYWxvZ1NlcnZpY2UgfSBmcm9tICcuL2RpYWxvZy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZGlhbG9nLnR5cGVzJztcbiJdfQ==

package/esm2022/lib/services/dom-intersection.service.mjs

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { Observable, distinctUntilChanged, map, mergeMap } from 'rxjs';
+import * as i0 from "@angular/core";
+export class DomIntersectionService {
+    createAndObserve(element) {
+        return new Observable((observer) => {
+            const intersectionObserver = new IntersectionObserver((entries) => {
+                observer.next(entries);
+            });
+            intersectionObserver.observe(element.nativeElement);
+            return () => {
+                intersectionObserver.disconnect();
+            };
+        }).pipe(mergeMap((entries) => entries), map((entry) => entry.isIntersecting), distinctUntilChanged());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DomIntersectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DomIntersectionService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DomIntersectionService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,65 @@
+import { inject, Injectable } from '@angular/core';
+import { BehaviorSubject, filter, filter as rxjsFilter, ReplaySubject, skip, take } from 'rxjs';
+import { InputsStateService } from '../inputs-state.service';
+import { FiltersTransmitService } from './filters-transmit.service';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { NavigationStart } from '@angular/router';
+import { isNonNull } from '../../utils';
+import { getFirstSegmentOfPathName } from '../../utils/get-url-segment';
+import * as i0 from "@angular/core";
+export class FiltersStateService extends InputsStateService {
+    constructor() {
+        super();
+        this._transmitter = inject(FiltersTransmitService, { optional: true });
+        this._selectedSavedFilter = new BehaviorSubject(null);
+        this._isFilterNameChanged$ = new BehaviorSubject(false);
+        this._searchFilterValue$ = new ReplaySubject();
+        this.selectedSavedFilter = this._selectedSavedFilter.asObservable();
+        this.searchFilterValue$ = this._searchFilterValue$.asObservable();
+        this.pageStorageKey = `@page/${this.modulePath}`;
+        this._transmitter?.subscribeOnApplyFormValues(this.gqlValues$);
+        this._cachePage();
+    }
+    _cachePage() {
+        this.limit$.pipe(filter(isNonNull), take(1)).subscribe((limit) => {
+            const cachedPage = localStorage.getItem(this.pageStorageKey);
+            if (cachedPage) {
+                const page = Number(cachedPage);
+                this.setPage(page);
+                this.setOffset(limit * (page - 1));
+            }
+        });
+        this.page$.pipe(skip(1), takeUntilDestroyed(this.destroyRef)).subscribe((page) => {
+            localStorage.setItem(this.pageStorageKey, page.toString());
+        });
+        this._subscribeOnNavigateToOtherModules();
+    }
+    _subscribeOnNavigateToOtherModules() {
+        this.router.events
+            .pipe(rxjsFilter((event) => event instanceof NavigationStart &&
+            getFirstSegmentOfPathName(event.url) !== this.modulePath), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            localStorage.removeItem(this.pageStorageKey);
+        });
+    }
+    setSelectedSavedFilter(value) {
+        this._selectedSavedFilter.next(value);
+    }
+    setSearchFilterValue(value) {
+        this._searchFilterValue$.next(value);
+    }
+    getSelectedSavedFilter() {
+        return this._selectedSavedFilter.getValue();
+    }
+    onDestroy() {
+        this._selectedSavedFilter.complete();
+        this._isFilterNameChanged$.complete();
+        this._searchFilterValue$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FiltersStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FiltersStateService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FiltersStateService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,82 @@
+import { Injectable } from '@angular/core';
+import { filter, map, Subject, takeUntil } from 'rxjs';
+import { distinctUntilChangedJSONs } from '../../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export const FILTERS_QUERY_PARAMS_KEY = 'filters';
+export const FILTERS_QUERY_PARAMS_VALUE_EMPTY = 'empty';
+export const SEARCH_QUERY_PARAMS_KEY = 'search';
+export class FiltersTransmitService {
+    constructor(_router, _route) {
+        this._router = _router;
+        this._route = _route;
+        this._unsubscribe$ = new Subject();
+    }
+    setForm(formGroup) {
+        this.formGroup = formGroup;
+    }
+    setSearchInput(searchInput) {
+        this.searchInput = searchInput;
+    }
+    subscribeOnApplyFormValues(observable) {
+        observable
+            .pipe(distinctUntilChangedJSONs(), filter(() => !!this.formGroup), map(() => this.formGroup), takeUntil(this._unsubscribe$))
+            .subscribe((formGroup) => {
+            const filtersEmpty = Object.values(formGroup.getRawValue()).every((val) => val === null);
+            const filters = filtersEmpty ? FILTERS_QUERY_PARAMS_VALUE_EMPTY : this.stringifyValues;
+            const search = this.searchInput?.getRawValue() || undefined;
+            this._setQueryParams({
+                [SEARCH_QUERY_PARAMS_KEY]: search,
+                [FILTERS_QUERY_PARAMS_KEY]: filters,
+            });
+        });
+    }
+    get stringifyValues() {
+        const values = Object.entries(this.formGroup?.controls ?? {})
+            .map(([id, abstractControl]) => {
+            const control = abstractControl;
+            const value = control.saved_value$.getValue();
+            const savedValue = value === null ? null : value;
+            return {
+                id,
+                value: savedValue,
+            };
+        })
+            .filter(({ value }) => value !== null);
+        if (values.length > 0) {
+            return JSON.stringify(values);
+        }
+        return;
+    }
+    get filters() {
+        const param = this._route.snapshot.queryParams[FILTERS_QUERY_PARAMS_KEY];
+        if (param === FILTERS_QUERY_PARAMS_VALUE_EMPTY) {
+            return;
+        }
+        if (param) {
+            return JSON.parse(param);
+        }
+        return [];
+    }
+    get search() {
+        return this._route.snapshot.queryParams[SEARCH_QUERY_PARAMS_KEY];
+    }
+    _setQueryParams(queryParams) {
+        this._router.navigate([], {
+            relativeTo: this._route,
+            queryParams,
+            queryParamsHandling: 'merge',
+            replaceUrl: true,
+        });
+    }
+    ngOnDestroy() {
+        this._unsubscribe$.next();
+        this._unsubscribe$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FiltersTransmitService, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FiltersTransmitService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FiltersTransmitService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i1.ActivatedRoute }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filters-transmit.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-register-base/src/lib/services/filter/filters-transmit.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAa,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,GAAG,EAAc,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAInE,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;;;AAGxD,MAAM,CAAC,MAAM,wBAAwB,GAAG,SAAS,CAAC;AAClD,MAAM,CAAC,MAAM,gCAAgC,GAAG,OAAO,CAAC;AACxD,MAAM,CAAC,MAAM,uBAAuB,GAAG,QAAQ,CAAC;AAGhD,MAAM,OAAO,sBAAsB;IAMjC,YACmB,OAAe,EACf,MAAsB;QADtB,YAAO,GAAP,OAAO,CAAQ;QACf,WAAM,GAAN,MAAM,CAAgB;QAPtB,kBAAa,GAAG,IAAI,OAAO,EAAQ,CAAC;IAQpD,CAAC;IAEG,OAAO,CAAC,SAAgC;QAC7C,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAEM,cAAc,CAAC,WAAqD;QACzE,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IACjC,CAAC;IAEM,0BAA0B,CAAC,UAA+B;QAC/D,UAAU;aACP,IAAI,CACH,yBAAyB,EAAE,EAC3B,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,EAC9B,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAU,CAAC,EAC1B,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,CAC9B;aACA,SAAS,CAAC,CAAC,SAAS,EAAE,EAAE;YACvB,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC;YACzF,MAAM,OAAO,GAAG,YAAY,CAAC,CAAC,CAAC,gCAAgC,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC;YACvF,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,SAAS,CAAC;YAE5D,IAAI,CAAC,eAAe,CAAC;gBACnB,CAAC,uBAAuB,CAAC,EAAE,MAAM;gBACjC,CAAC,wBAAwB,CAAC,EAAE,OAAO;aACpC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IAAW,eAAe;QACxB,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,IAAI,EAAE,CAAC;aAC1D,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC,EAAE,EAAE;YAC7B,MAAM,OAAO,GAAG,eAAgC,CAAC;YACjD,MAAM,KAAK,GAAG,OAAO,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;YAC9C,MAAM,UAAU,GAAG,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;YAEjD,OAAO;gBACL,EAAE;gBACF,KAAK,EAAE,UAAU;aAClB,CAAC;QACJ,CAAC,CAAC;aACD,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC;QAEzC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAChC,CAAC;QAED,OAAO;IACT,CAAC;IAED,IAAW,OAAO;QAChB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,wBAAwB,CAAC,CAAC;QAEzE,IAAI,KAAK,KAAK,gCAAgC,EAAE,CAAC;YAC/C,OAAO;QACT,CAAC;QAED,IAAI,KAAK,EAAE,CAAC;YACV,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,uBAAuB,CAAC,CAAC;IACnE,CAAC;IAEO,eAAe,CAAC,WAA+C;QACrE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE;YACxB,UAAU,EAAE,IAAI,CAAC,MAAM;YACvB,WAAW;YACX,mBAAmB,EAAE,OAAO;YAC5B,UAAU,EAAE,IAAI;SACjB,CAAC,CAAC;IACL,CAAC;IAEM,WAAW;QAChB,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QAC1B,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;IAChC,CAAC;+GA1FU,sBAAsB;mHAAtB,sBAAsB;;4FAAtB,sBAAsB;kBADlC,UAAU","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport { filter, map, Observable, Subject, takeUntil } from 'rxjs';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { IInputControl } from '../../types/inputs.types';\nimport { FormGroupWrapper } from '../../core/form-group-wrapper/form-group-wrapper';\nimport { distinctUntilChangedJSONs } from '../../utils';\nimport { ITpUserSettingsSettingsFilter } from '../../types/register-base.types';\n\nexport const FILTERS_QUERY_PARAMS_KEY = 'filters';\nexport const FILTERS_QUERY_PARAMS_VALUE_EMPTY = 'empty';\nexport const SEARCH_QUERY_PARAMS_KEY = 'search';\n\n@Injectable()\nexport class FiltersTransmitService implements OnDestroy {\n  protected readonly _unsubscribe$ = new Subject<void>();\n\n  protected formGroup?: FormGroupWrapper<any>;\n  protected searchInput?: IInputControl<string | null>;\n\n  constructor(\n    private readonly _router: Router,\n    private readonly _route: ActivatedRoute\n  ) {}\n\n  public setForm(formGroup: FormGroupWrapper<any>): void {\n    this.formGroup = formGroup;\n  }\n\n  public setSearchInput(searchInput: IInputControl<string | null> | undefined): void {\n    this.searchInput = searchInput;\n  }\n\n  public subscribeOnApplyFormValues(observable: Observable<unknown>): void {\n    observable\n      .pipe(\n        distinctUntilChangedJSONs(),\n        filter(() => !!this.formGroup),\n        map(() => this.formGroup!),\n        takeUntil(this._unsubscribe$)\n      )\n      .subscribe((formGroup) => {\n        const filtersEmpty = Object.values(formGroup.getRawValue()).every((val) => val === null);\n        const filters = filtersEmpty ? FILTERS_QUERY_PARAMS_VALUE_EMPTY : this.stringifyValues;\n        const search = this.searchInput?.getRawValue() || undefined;\n\n        this._setQueryParams({\n          [SEARCH_QUERY_PARAMS_KEY]: search,\n          [FILTERS_QUERY_PARAMS_KEY]: filters,\n        });\n      });\n  }\n\n  public get stringifyValues(): string | undefined {\n    const values = Object.entries(this.formGroup?.controls ?? {})\n      .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      .filter(({ value }) => value !== null);\n\n    if (values.length > 0) {\n      return JSON.stringify(values);\n    }\n\n    return;\n  }\n\n  public get filters(): ITpUserSettingsSettingsFilter[] | undefined {\n    const param = this._route.snapshot.queryParams[FILTERS_QUERY_PARAMS_KEY];\n\n    if (param === FILTERS_QUERY_PARAMS_VALUE_EMPTY) {\n      return;\n    }\n\n    if (param) {\n      return JSON.parse(param);\n    }\n\n    return [];\n  }\n\n  public get search(): string | undefined {\n    return this._route.snapshot.queryParams[SEARCH_QUERY_PARAMS_KEY];\n  }\n\n  private _setQueryParams(queryParams: Record<string, string | undefined>): void {\n    this._router.navigate([], {\n      relativeTo: this._route,\n      queryParams,\n      queryParamsHandling: 'merge',\n      replaceUrl: true,\n    });\n  }\n\n  public ngOnDestroy(): void {\n    this._unsubscribe$.next();\n    this._unsubscribe$.complete();\n  }\n}\n"]}