@rt-tools/utils 0.0.1

package/fesm2022/rt-tools-utils.mjs

@@ -0,0 +1,1567 @@
+import * as i0 from '@angular/core';
+import { input, HostBinding, Directive, effect, inject, booleanAttribute, InjectionToken, Injectable, Injector, signal, computed, HostListener, DestroyRef, output, Pipe } from '@angular/core';
+import { isNil, WINDOW, PlatformService } from '@rt-tools/core';
+export { MessageBus, PlatformService, WINDOW, isNil } from '@rt-tools/core';
+import { Validators, FormControl } from '@angular/forms';
+import { MatTooltip } from '@angular/material/tooltip';
+import { Router, ActivatedRoute } from '@angular/router';
+import { DOCUMENT } from '@angular/common';
+import { BreakpointObserver } from '@angular/cdk/layout';
+import { toSignal, toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { distinctUntilChanged, switchMap, map, filter, take } from 'rxjs/operators';
+import { DomSanitizer } from '@angular/platform-browser';
+
+const OVERLAY_POSITIONS = Object.freeze([
+    {
+        originX: 'start',
+        originY: 'bottom',
+        overlayX: 'start',
+        overlayY: 'top',
+    },
+    {
+        originX: 'end',
+        originY: 'bottom',
+        overlayX: 'end',
+        overlayY: 'top',
+    },
+    {
+        originX: 'start',
+        originY: 'bottom',
+        overlayX: 'start',
+        overlayY: 'top',
+    },
+    {
+        originX: 'start',
+        originY: 'top',
+        overlayX: 'start',
+        overlayY: 'bottom',
+    },
+]);
+
+const DASH = '—';
+
+class RtIconOutlinedDirective {
+    constructor() {
+        this.isOutlined = input(false, { ...(ngDevMode ? { debugName: "isOutlined" } : {}), alias: 'rtIconOutlined',
+            transform: (value) => {
+                return Boolean(value);
+            } });
+    }
+    get fontVariationSettings() {
+        // eslint-disable-next-line quotes
+        return this.isOutlined() ? "'FILL' 0, 'wght' 700, 'GRAD' 0, 'opsz' 48" : "'FILL' 1, 'wght' 700, 'GRAD' 0, 'opsz' 48";
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtIconOutlinedDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.1", type: RtIconOutlinedDirective, isStandalone: true, selector: "mat-icon[rtIconOutlined]", inputs: { isOutlined: { classPropertyName: "isOutlined", publicName: "rtIconOutlined", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "style.fontVariationSettings": "this.fontVariationSettings" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtIconOutlinedDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'mat-icon[rtIconOutlined]',
+                }]
+        }], propDecorators: { isOutlined: [{ type: i0.Input, args: [{ isSignal: true, alias: "rtIconOutlined", required: false }] }], fontVariationSettings: [{
+                type: HostBinding,
+                args: ['style.fontVariationSettings']
+            }] } });
+
+/**
+ * Date formatting and parsing utilities (replacement for date-fns)
+ *
+ * Supported format tokens:
+ * - yyyy: 4-digit year (2024)
+ * - yy: 2-digit year (24)
+ * - MM: 2-digit month (01-12)
+ * - M: month (1-12)
+ * - dd: 2-digit day (01-31)
+ * - d: day (1-31)
+ * - HH: 2-digit hour 24h (00-23)
+ * - H: hour 24h (0-23)
+ * - hh: 2-digit hour 12h (01-12)
+ * - h: hour 12h (1-12)
+ * - mm: 2-digit minutes (00-59)
+ * - m: minutes (0-59)
+ * - ss: 2-digit seconds (00-59)
+ * - s: seconds (0-59)
+ * - SSS: milliseconds (000-999)
+ * - a: AM/PM
+ * - EEEE: full weekday name (Monday)
+ * - EEE: short weekday name (Mon)
+ * - MMMM: full month name (January)
+ * - MMM: short month name (Jan)
+ */
+const WEEKDAYS_SHORT = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const WEEKDAYS_LONG = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const MONTHS_SHORT = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const MONTHS_LONG = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+];
+/**
+ * Escapes special regex characters in a string
+ */
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Pads a number with leading zeros
+ */
+function padStart(value, length) {
+    return String(value).padStart(length, '0');
+}
+/**
+ * Checks if a value is a valid Date object
+ */
+function isDate(value) {
+    return value instanceof Date && !isNaN(value.getTime());
+}
+/**
+ * Formats a Date object according to the specified format string
+ *
+ * @param date - The date to format
+ * @param formatStr - The format string (e.g., 'dd.MM.yyyy', 'yyyy-MM-dd HH:mm:ss')
+ * @returns Formatted date string
+ *
+ * @example
+ * formatDate(new Date(2024, 0, 15), 'dd.MM.yyyy') // '15.01.2024'
+ * formatDate(new Date(2024, 0, 15, 14, 30), 'yyyy-MM-dd HH:mm') // '2024-01-15 14:30'
+ */
+function formatDate(date, formatStr) {
+    if (!isDate(date)) {
+        return '';
+    }
+    const year = date.getFullYear();
+    const month = date.getMonth();
+    const day = date.getDate();
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    const seconds = date.getSeconds();
+    const milliseconds = date.getMilliseconds();
+    const dayOfWeek = date.getDay();
+    const hours12 = hours % 12 || 12;
+    const ampm = hours < 12 ? 'AM' : 'PM';
+    // Use placeholders to avoid partial replacements
+    const placeholders = new Map();
+    let placeholderIndex = 0;
+    const createPlaceholder = (value) => {
+        const placeholder = `\x00${placeholderIndex++}\x00`;
+        placeholders.set(placeholder, value);
+        return placeholder;
+    };
+    // Order matters: longer tokens must be replaced first
+    // Use exact token matching to prevent partial replacements
+    let result = formatStr;
+    // Replace tokens with placeholders (longest first)
+    result = result.replace(/yyyy/g, createPlaceholder(String(year)));
+    result = result.replace(/yy/g, createPlaceholder(String(year).slice(-2)));
+    result = result.replace(/MMMM/g, createPlaceholder(MONTHS_LONG[month]));
+    result = result.replace(/MMM/g, createPlaceholder(MONTHS_SHORT[month]));
+    result = result.replace(/MM/g, createPlaceholder(padStart(month + 1, 2)));
+    result = result.replace(/M/g, createPlaceholder(String(month + 1)));
+    result = result.replace(/EEEE/g, createPlaceholder(WEEKDAYS_LONG[dayOfWeek]));
+    result = result.replace(/EEE/g, createPlaceholder(WEEKDAYS_SHORT[dayOfWeek]));
+    result = result.replace(/dd/g, createPlaceholder(padStart(day, 2)));
+    result = result.replace(/d/g, createPlaceholder(String(day)));
+    result = result.replace(/HH/g, createPlaceholder(padStart(hours, 2)));
+    result = result.replace(/H/g, createPlaceholder(String(hours)));
+    result = result.replace(/hh/g, createPlaceholder(padStart(hours12, 2)));
+    result = result.replace(/h/g, createPlaceholder(String(hours12)));
+    result = result.replace(/mm/g, createPlaceholder(padStart(minutes, 2)));
+    result = result.replace(/m/g, createPlaceholder(String(minutes)));
+    result = result.replace(/SSS/g, createPlaceholder(padStart(milliseconds, 3)));
+    result = result.replace(/ss/g, createPlaceholder(padStart(seconds, 2)));
+    result = result.replace(/s/g, createPlaceholder(String(seconds)));
+    result = result.replace(/a/g, createPlaceholder(ampm));
+    // Replace placeholders with actual values
+    for (const [placeholder, value] of placeholders) {
+        result = result.replace(placeholder, value);
+    }
+    return result;
+}
+/**
+ * Parses an ISO 8601 date string into a Date object
+ *
+ * @param dateString - ISO date string (e.g., '2024-01-15', '2024-01-15T14:30:00.000Z')
+ * @returns Date object or Invalid Date if parsing fails
+ *
+ * @example
+ * parseISO('2024-01-15') // Date object for Jan 15, 2024
+ * parseISO('2024-01-15T14:30:00.000Z') // Date object with time
+ */
+function parseISO(dateString) {
+    if (!dateString || typeof dateString !== 'string') {
+        return new Date(NaN);
+    }
+    const date = new Date(dateString);
+    return date;
+}
+/**
+ * Parses a date string according to the specified format
+ *
+ * @param dateString - The date string to parse
+ * @param formatStr - The format string describing the input
+ * @param referenceDate - Reference date for missing parts (defaults to current date)
+ * @returns Date object or Invalid Date if parsing fails
+ *
+ * @example
+ * parseDate('15.01.2024', 'dd.MM.yyyy') // Date object for Jan 15, 2024
+ * parseDate('2024/01/15 14:30', 'yyyy/MM/dd HH:mm') // Date with time
+ */
+function parseDate(dateString, formatStr, referenceDate = new Date()) {
+    if (!dateString || typeof dateString !== 'string') {
+        return new Date(NaN);
+    }
+    let year = referenceDate.getFullYear();
+    let month = referenceDate.getMonth();
+    let day = referenceDate.getDate();
+    let hours = 0;
+    let minutes = 0;
+    let seconds = 0;
+    let milliseconds = 0;
+    let isPM = false;
+    let hasAMPM = false;
+    const tokenPatterns = [
+        {
+            token: 'yyyy',
+            pattern: '(\\d{4})',
+            handler: (val) => {
+                year = parseInt(val, 10);
+            },
+        },
+        {
+            token: 'yy',
+            pattern: '(\\d{2})',
+            handler: (val) => {
+                const parsed = parseInt(val, 10);
+                year = parsed >= 70 ? 1900 + parsed : 2000 + parsed;
+            },
+        },
+        {
+            token: 'MMMM',
+            pattern: `(${MONTHS_LONG.join('|')})`,
+            handler: (val) => {
+                month = MONTHS_LONG.findIndex((m) => m.toLowerCase() === val.toLowerCase());
+            },
+        },
+        {
+            token: 'MMM',
+            pattern: `(${MONTHS_SHORT.join('|')})`,
+            handler: (val) => {
+                month = MONTHS_SHORT.findIndex((m) => m.toLowerCase() === val.toLowerCase());
+            },
+        },
+        {
+            token: 'MM',
+            pattern: '(\\d{2})',
+            handler: (val) => {
+                month = parseInt(val, 10) - 1;
+            },
+        },
+        {
+            token: 'M',
+            pattern: '(\\d{1,2})',
+            handler: (val) => {
+                month = parseInt(val, 10) - 1;
+            },
+        },
+        {
+            token: 'dd',
+            pattern: '(\\d{2})',
+            handler: (val) => {
+                day = parseInt(val, 10);
+            },
+        },
+        {
+            token: 'd',
+            pattern: '(\\d{1,2})',
+            handler: (val) => {
+                day = parseInt(val, 10);
+            },
+        },
+        {
+            token: 'HH',
+            pattern: '(\\d{2})',
+            handler: (val) => {
+                hours = parseInt(val, 10);
+            },
+        },
+        {
+            token: 'H',
+            pattern: '(\\d{1,2})',
+            handler: (val) => {
+                hours = parseInt(val, 10);
+            },
+        },
+        {
+            token: 'hh',
+            pattern: '(\\d{2})',
+            handler: (val) => {
+                hours = parseInt(val, 10);
+            },
+        },
+        {
+            token: 'h',
+            pattern: '(\\d{1,2})',
+            handler: (val) => {
+                hours = parseInt(val, 10);
+            },
+        },
+        {
+            token: 'mm',
+            pattern: '(\\d{2})',
+            handler: (val) => {
+                minutes = parseInt(val, 10);
+            },
+        },
+        {
+            token: 'm',
+            pattern: '(\\d{1,2})',
+            handler: (val) => {
+                minutes = parseInt(val, 10);
+            },
+        },
+        {
+            token: 'SSS',
+            pattern: '(\\d{3})',
+            handler: (val) => {
+                milliseconds = parseInt(val, 10);
+            },
+        },
+        {
+            token: 'ss',
+            pattern: '(\\d{2})',
+            handler: (val) => {
+                seconds = parseInt(val, 10);
+            },
+        },
+        {
+            token: 's',
+            pattern: '(\\d{1,2})',
+            handler: (val) => {
+                seconds = parseInt(val, 10);
+            },
+        },
+        {
+            token: 'a',
+            pattern: '(AM|PM|am|pm)',
+            handler: (val) => {
+                hasAMPM = true;
+                isPM = val.toUpperCase() === 'PM';
+            },
+        },
+    ];
+    // Sort by token length (longer first) to avoid partial matches
+    const sortedPatterns = [...tokenPatterns].sort((a, b) => b.token.length - a.token.length);
+    // Build regex from format string using placeholders to avoid double-replacement
+    // First, replace all tokens in the original format string with placeholders
+    let workingFormat = formatStr;
+    const placeholderList = [];
+    let placeholderIndex = 0;
+    for (const { token, pattern, handler } of sortedPatterns) {
+        if (workingFormat.includes(token)) {
+            const placeholder = `\x00${placeholderIndex++}\x00`;
+            workingFormat = workingFormat.split(token).join(placeholder);
+            placeholderList.push({ placeholder, pattern, handler });
+        }
+    }
+    // Now escape the remaining literal characters
+    let regexStr = escapeRegExp(workingFormat);
+    // Replace placeholders with actual regex patterns
+    for (const { placeholder, pattern } of placeholderList) {
+        regexStr = regexStr.replace(escapeRegExp(placeholder), pattern);
+    }
+    // Sort handlers by their placeholder position in the original working format
+    // to match capture group order (left-to-right in the regex)
+    const sortedByPosition = placeholderList
+        .map((item) => ({
+        placeholder: item.placeholder,
+        handler: item.handler,
+        position: escapeRegExp(workingFormat).indexOf(escapeRegExp(item.placeholder)),
+    }))
+        .sort((a, b) => a.position - b.position);
+    const handlers = sortedByPosition.map((item) => item.handler);
+    const regex = new RegExp(`^${regexStr}$`, 'i');
+    const match = dateString.match(regex);
+    if (!match) {
+        return new Date(NaN);
+    }
+    // Apply handlers in order
+    for (let i = 0; i < handlers.length; i++) {
+        if (match[i + 1]) {
+            handlers[i](match[i + 1]);
+        }
+    }
+    // Apply AM/PM adjustment after all handlers
+    if (hasAMPM) {
+        if (isPM && hours < 12) {
+            hours += 12;
+        }
+        else if (!isPM && hours === 12) {
+            hours = 0;
+        }
+    }
+    return new Date(year, month, day, hours, minutes, seconds, milliseconds);
+}
+
+const MAX_YEAR = 3000;
+function dateStringToDate(date) {
+    if (date instanceof Date) {
+        return date;
+    }
+    const firstItem = 1;
+    const parsedDate = (date || '')
+        .replace(/^(\d)/, '0$1')
+        .replace(/\.(\d)\./, '.0$1.')
+        .replace('..', '.01.')
+        .replace(/^\./, '01.')
+        .replace(/(\d{3})\./g, (str) => str.slice(firstItem))
+        .replace(/(\d{2}).(\d{2}).(\d{4})/, '$2/$1/$3')
+        .replace(/00\//g, '01/');
+    const dateValue = new Date(parsedDate);
+    if (dateValue.getFullYear() > MAX_YEAR) {
+        return new Date();
+    }
+    return isNaN(dateValue.getTime()) ? new Date() : dateValue;
+}
+
+function isDateValid(date) {
+    return date instanceof Date && Boolean(date.getTime());
+}
+
+/**
+ * Indicates if the arguments are equal
+ *
+ * @param f first parameter to compare
+ * @param s second parameter to compare
+ */
+function isEqual(f, s) {
+    const s1 = JSON.stringify(f).split('').sort().join('');
+    const s2 = JSON.stringify(s).split('').sort().join('');
+    return s1 === s2;
+}
+/**
+ * Indicates if the content of two arrays is identical
+ *
+ * @param f first array
+ * @param s second array
+ */
+function areArraysEqual(f, s) {
+    if (!Array.isArray(f) || !Array.isArray(s)) {
+        return false;
+    }
+    if (f.length !== s.length) {
+        return false;
+    }
+    for (let i = 0; i < f.length; i++) {
+        const valueF = f[i];
+        const valueS = s[i];
+        if (Array.isArray(valueF) && Array.isArray(valueS)) {
+            if (!areArraysEqual(valueF, valueS)) {
+                return false;
+            }
+        }
+        if (typeof valueF === 'object' && valueF != null && typeof valueS === 'object' && valueS != null) {
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            if (!areObjectsEqual(valueF, valueS)) {
+                return false;
+            }
+        }
+        else if (valueF !== valueS) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Indicates if the content of two objects is identical
+ *
+ * @param f first object
+ * @param s second object
+ */
+function areObjectsEqual(f, s) {
+    /** If it's just the same object - no need to compare */
+    if (f === s) {
+        return true;
+    }
+    if (Array.isArray(f) && Array.isArray(s)) {
+        return areArraysEqual(f, s);
+    }
+    /** If one of the objects is null or undefined - no need to compare */
+    if (typeof f === 'object' && f != null && typeof s === 'object' && s != null) {
+        const keysF = Object.keys(f);
+        const keysS = Object.keys(s);
+        if (keysF.length != keysS.length) {
+            return false;
+        }
+        for (const key in f) {
+            if (!areObjectsEqual(f[key], s[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks whether two arrays are equal regardless of the order of their elements.
+ * Supports deep comparison of nested arrays and objects.
+ *
+ * @template T The type of elements in the arrays
+ * @param f first array
+ * @param s second array
+ * @returns True if the arrays contain the same elements in any order, false otherwise
+ */
+function areArraysEqualUnordered(f, s) {
+    if (!Array.isArray(f) || !Array.isArray(s)) {
+        return false;
+    }
+    if (f.length !== s.length) {
+        return false;
+    }
+    const used = new Array(s.length).fill(false);
+    for (const valueF of f) {
+        let found = false;
+        for (let i = 0; i < s.length; i++) {
+            if (used[i]) {
+                continue;
+            }
+            const valueS = s[i];
+            if (Array.isArray(valueF) && Array.isArray(valueS)) {
+                if (areArraysEqualUnordered(valueF, valueS)) {
+                    used[i] = true;
+                    found = true;
+                    break;
+                }
+            }
+            else if (typeof valueF === 'object' && valueF != null && typeof valueS === 'object' && valueS != null) {
+                if (areObjectsEqual(valueF, valueS)) {
+                    used[i] = true;
+                    found = true;
+                    break;
+                }
+            }
+            else if (valueF === valueS) {
+                used[i] = true;
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function isNumber(value) {
+    return typeof value === 'number';
+}
+
+function isRecord(value) {
+    return value?.constructor === Object;
+}
+
+function isString(value) {
+    return typeof value === 'string';
+}
+
+function initToday() {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    return today;
+}
+function isToday(date) {
+    const today = initToday();
+    return date.getDate() === today.getDate() && date.getMonth() === today.getMonth() && date.getFullYear() === today.getFullYear();
+}
+
+/** Makes shallow copy of passed object */
+function removeFieldFromObject(obj, key) {
+    const result = { ...obj };
+    if (key in obj) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        delete result[key];
+    }
+    return result;
+}
+
+/**
+ * Allow to compare two values by provided comparator
+ *
+ * @param a - T
+ * @param b - T
+ * @param comparator - ComparatorType<T>
+ */
+function safeCompare(a, b, comparator) {
+    if (a == null) {
+        if (b == null) {
+            return 0;
+        }
+        else {
+            return 1;
+        }
+    }
+    else {
+        if (b == null) {
+            return -1;
+        }
+        else {
+            return comparator(a, b);
+        }
+    }
+}
+/**
+ * Allow to safely compare two string values
+ *
+ * @param a string
+ * @param b string
+ */
+function safeStrCompare(a, b) {
+    return safeCompare(a, b, () => a.localeCompare(b));
+}
+/**
+ * Allow to safely compare two number values
+ *
+ * @param a number
+ * @param b number
+ */
+function safeNumCompare(a, b) {
+    return safeCompare(a, b, () => a - b);
+}
+/**
+ * Allow composing comparison chain of several comparators
+ * that delegate comparison by the chain to the next comparators if current comparator returns 0
+ *
+ * @param comparators - Array<() => number>
+ */
+function safeComparatorPipe(...comparators) {
+    let result = 0;
+    for (let i = 0, len = comparators.length; i < len; i++) {
+        result = comparators[i]();
+        if (result !== 0) {
+            break;
+        }
+    }
+    return result;
+}
+
+const sortByAlphabet = (a, b, field) => {
+    if (a[field] && typeof a[field] === 'string' && b[field] && typeof b[field] === 'string') {
+        if (a[field].toLowerCase() < b[field].toLowerCase()) {
+            return -1;
+        }
+        if (a[field].toLowerCase() > b[field].toLowerCase()) {
+            return 1;
+        }
+    }
+    return 0;
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const sortByDate = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+a, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+b, field) => new Date(a[field]).getTime() - new Date(b[field]).getTime();
+
+function stringifyHttpLikeParams(params) {
+    return Object.keys(params).reduce((stringParams, key) => ({
+        ...stringParams,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        [key]: encodeURI(params[key]),
+    }), {});
+}
+
+function transformArrayInput(array) {
+    if (Array.isArray(array) && array.length) {
+        return array;
+    }
+    else {
+        return [];
+    }
+}
+
+function transformStringInput(value) {
+    return isString(value) ? value : '';
+}
+
+function checkIsEntityInArrayByKey(selectedEntities, entity, keyExp) {
+    return !!selectedEntities.find((selectedEntity) => {
+        return (Object.prototype.hasOwnProperty.call(selectedEntity, keyExp) &&
+            Object.prototype.hasOwnProperty.call(entity, keyExp) &&
+            selectedEntity[keyExp] === entity[keyExp]);
+    });
+}
+
+function emptyToDash(value) {
+    return isNil(value) || value === '' ? DASH : value;
+}
+
+/**
+ * Check if the email is valid
+ * @param email
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isEmail(email) {
+    return !Boolean(Validators.email(new FormControl(email)));
+}
+
+function isEmptyArray(value) {
+    return value.length === 0;
+}
+
+function isEmptyObject(value) {
+    return isEmptyArray(Object.keys(value));
+}
+
+function isEmptyString(value) {
+    return value.length === 0;
+}
+
+function isObject(value) {
+    return typeof value === 'object';
+}
+
+function isEmpty(value) {
+    if (isNil(value)) {
+        return true;
+    }
+    if (isObject(value)) {
+        if (Array.isArray(value)) {
+            return isEmptyArray(value);
+        }
+        if (!(value instanceof Date)) {
+            return isEmptyObject(value);
+        }
+    }
+    if (isString(value)) {
+        return isEmptyString(value);
+    }
+    return false;
+}
+
+function debounce(timeout = 300) {
+    return function (_target, _key, descriptor) {
+        const timeoutRefs = new WeakMap();
+        const { value } = descriptor;
+        descriptor.value = function (...args) {
+            const timeoutRef = timeoutRefs.get(this);
+            if (timeoutRef !== undefined) {
+                clearTimeout(timeoutRef);
+            }
+            timeoutRefs.set(this, setTimeout(() => value.apply(this, args), timeout));
+        };
+        return descriptor;
+    };
+}
+
+var HAS_OWN_SCOPE_ENUM;
+(function (HAS_OWN_SCOPE_ENUM) {
+    HAS_OWN_SCOPE_ENUM["ANY"] = "any";
+    HAS_OWN_SCOPE_ENUM["OWN"] = "own";
+    HAS_OWN_SCOPE_ENUM["INHERITED"] = "inherited";
+})(HAS_OWN_SCOPE_ENUM || (HAS_OWN_SCOPE_ENUM = {}));
+const safetyHasOwn = (o, k) => {
+    const native = Object.hasOwn;
+    return typeof native === 'function' ? native(o, k) : Object.prototype.hasOwnProperty.call(o, k);
+};
+/**
+ * Safe property existence check with configurable scope.
+ *
+ * - Returns `false` for `null`/`undefined`.
+ * - Boxes primitives (e.g., strings, numbers) so prototype checks work.
+ * - Does **not** invoke getters; relies on `in` and an own-check helper.
+ * - Uses `Object.hasOwn` when available; **falls back** to
+ *   `Object.prototype.hasOwnProperty.call` on older runtimes.
+ *
+ * @param obj {unknown} - Value to check. `null`/`undefined` short-circuit to `false`.
+ * @param key {PropertyKey} - Property key (string | number | symbol).
+ * @param scope {IHasScopeType} - Check mode: `'any'` (default), `'own'`, or `'inherited'`.
+ *
+ * @returns `true` if the property exists under the selected scope.
+ *
+ * @example
+ * hasPropertyInChain({ a: 1 }, 'a'); // true (ANY)
+ * hasPropertyInChain(Object.create({ a: 1 }), 'a', HAS_OWN_SCOPE_ENUM.INHERITED); // true
+ * hasPropertyInChain({ a: 1 }, 'b', HAS_OWN_SCOPE_ENUM.OWN); // false
+ */
+function hasPropertyInChain(obj, key, scope = HAS_OWN_SCOPE_ENUM.OWN) {
+    if (obj === undefined || obj === null) {
+        return false;
+    }
+    const o = Object(obj);
+    switch (scope) {
+        case HAS_OWN_SCOPE_ENUM.OWN:
+            return safetyHasOwn(o, key);
+        case HAS_OWN_SCOPE_ENUM.INHERITED:
+            return key in o && !safetyHasOwn(o, key);
+        default:
+            return key in o;
+    }
+}
+
+class RtScrollToElementDirective {
+    constructor() {
+        this.rtScrollToElement = input.required({ ...(ngDevMode ? { debugName: "rtScrollToElement" } : {}) });
+        this.elements = input.required({ ...(ngDevMode ? { debugName: "elements" } : {}), transform: (value) => transformArrayInput(value) });
+        effect(() => {
+            if (this.elements()?.length && this.rtScrollToElement()) {
+                this.#scrollToTarget();
+            }
+        });
+    }
+    #scrollToTarget() {
+        const targetId = this.rtScrollToElement();
+        const targetElement = document.getElementById(targetId.toString());
+        targetElement?.scrollIntoView({ behavior: 'smooth', block: 'start' });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtScrollToElementDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.1", type: RtScrollToElementDirective, isStandalone: true, selector: "[rtScrollToElement]", inputs: { rtScrollToElement: { classPropertyName: "rtScrollToElement", publicName: "rtScrollToElement", isSignal: true, isRequired: true, transformFunction: null }, elements: { classPropertyName: "elements", publicName: "elements", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtScrollToElementDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rtScrollToElement]',
+                }]
+        }], ctorParameters: () => [], propDecorators: { rtScrollToElement: [{ type: i0.Input, args: [{ isSignal: true, alias: "rtScrollToElement", required: true }] }], elements: [{ type: i0.Input, args: [{ isSignal: true, alias: "elements", required: true }] }] } });
+
+class RtHideTooltipDirective {
+    #matTooltip;
+    /** Set tooltip state by 'isTooltipShown' */
+    constructor() {
+        this.#matTooltip = inject(MatTooltip);
+        /** Current HTMLElement */
+        this.element = input.required({ ...(ngDevMode ? { debugName: "element" } : {}), alias: 'rtHideTooltipDirective' });
+        /** Indicates is tooltip shown */
+        this.isTooltipShown = input.required({ ...(ngDevMode ? { debugName: "isTooltipShown" } : {}), transform: booleanAttribute });
+        effect(() => {
+            if (this.isTooltipShown()) {
+                this.#setTooltipState();
+            }
+            else {
+                this.#matTooltip.disabled = true;
+            }
+        });
+    }
+    ngAfterViewInit() {
+        const element = this.element();
+        /** Set tooltip state when HTMLElement changed */
+        if (element) {
+            const observer = new MutationObserver(() => {
+                if (this.isTooltipShown()) {
+                    this.#setTooltipState();
+                }
+            });
+            observer.observe(element, {
+                childList: true,
+                characterData: true,
+                subtree: true,
+            });
+            if (this.isTooltipShown()) {
+                this.#setTooltipState();
+            }
+        }
+    }
+    /** Set tooltip state by container and content width */
+    #setTooltipState() {
+        this.#matTooltip.disabled = this.element()?.offsetWidth === this.element()?.scrollWidth;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtHideTooltipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.1", type: RtHideTooltipDirective, isStandalone: true, selector: "[rtHideTooltipDirective]", inputs: { element: { classPropertyName: "element", publicName: "rtHideTooltipDirective", isSignal: true, isRequired: true, transformFunction: null }, isTooltipShown: { classPropertyName: "isTooltipShown", publicName: "isTooltipShown", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtHideTooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rtHideTooltipDirective]',
+                }]
+        }], ctorParameters: () => [], propDecorators: { element: [{ type: i0.Input, args: [{ isSignal: true, alias: "rtHideTooltipDirective", required: true }] }], isTooltipShown: [{ type: i0.Input, args: [{ isSignal: true, alias: "isTooltipShown", required: true }] }] } });
+
+class AsideRef {
+    constructor(answer, overlayRef, component, position, data) {
+        this.answer = answer;
+        this.overlayRef = overlayRef;
+        this.component = component;
+        this.position = position;
+        this.data = data;
+    }
+    close(answer) {
+        this.answer.next(answer ?? null);
+    }
+}
+const ASIDE_REF = new InjectionToken('ASIDE_REF');
+const ddServices = [
+    { provide: 'ddData', useValue: undefined },
+    { provide: 'ddAnswer', useValue: undefined },
+    { provide: 'ddOverlay', useValue: undefined },
+];
+
+const NAVIGATOR = new InjectionToken('An injection token for global navigator object', {
+    factory: () => {
+        const { defaultView } = inject(DOCUMENT);
+        if (!defaultView || !defaultView?.navigator) {
+            throw new Error('Navigator is not available');
+        }
+        return defaultView.navigator;
+    },
+});
+
+var OSTypes;
+(function (OSTypes) {
+    OSTypes.WINDOWS = 'Windows';
+    OSTypes.MAC_OS = 'Mac OS';
+    OSTypes.LINUX = 'Linux';
+    OSTypes.ANDROID = 'Android';
+    OSTypes.IOS = 'iOS';
+    OSTypes.UNKNOWN = 'Unknown';
+})(OSTypes || (OSTypes = {}));
+class DeviceDetectorService {
+    #windowRef;
+    #navigatorRef;
+    #platformService;
+    constructor() {
+        this.#windowRef = inject(WINDOW);
+        this.#navigatorRef = inject(NAVIGATOR);
+        this.#platformService = inject(PlatformService);
+        this.userAgent = null;
+        if (this.#platformService.isPlatformBrowser &&
+            typeof this.#windowRef !== 'undefined' &&
+            typeof this.#navigatorRef !== 'undefined' &&
+            this.#navigatorRef?.userAgent) {
+            this.userAgent = this.#navigatorRef.userAgent;
+        }
+    }
+    isMobile() {
+        return this.userAgent ? /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(this.userAgent) : false;
+    }
+    isTablet() {
+        return this.userAgent ? /iPad|Android|Tablet/i.test(this.userAgent) : false;
+    }
+    isDesktop() {
+        return !this.isMobile() && !this.isTablet();
+    }
+    getOS() {
+        let os;
+        if (this.userAgent && /Windows/i.test(this.userAgent)) {
+            os = OSTypes.WINDOWS;
+        }
+        else if (this.userAgent && /Macintosh|Mac OS/i.test(this.userAgent)) {
+            os = OSTypes.MAC_OS;
+        }
+        else if (this.userAgent && /Linux/i.test(this.userAgent)) {
+            os = OSTypes.LINUX;
+        }
+        else if (this.userAgent && /Android/i.test(this.userAgent)) {
+            os = OSTypes.ANDROID;
+        }
+        else if (this.userAgent && /iOS/i.test(this.userAgent)) {
+            os = OSTypes.IOS;
+        }
+        else {
+            os = OSTypes.UNKNOWN;
+        }
+        return os;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: DeviceDetectorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: DeviceDetectorService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: DeviceDetectorService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class Breakpoints {
+    constructor() {
+        this.xl = '1920px';
+        this.lg = '1280px';
+        this.md = '960px';
+        this.sm = '720px';
+        this.xs = '600px';
+    }
+}
+
+/**
+ * A service that manages responsive design breakpoints using Angular's `BreakpointObserver`.
+ * This service provides signals for different screen sizes and allows dynamic
+ * breakpoint management.
+ *
+ * @Injectable
+ */
+class BreakpointService {
+    constructor() {
+        /**
+         * Private instance of BreakpointObserver used to observe screen size changes.
+         */
+        this.#breakpointObserver = inject(BreakpointObserver);
+        /**
+         * Private instance of Injector.
+         */
+        this.#injector = inject(Injector);
+        /**
+         * Instance of a lass containing the breakpoint values for different screen sizes.
+         */
+        this.#breakpoints = signal(new Breakpoints(), { ...(ngDevMode ? { debugName: "#breakpoints" } : {}) });
+        this.#desktopQuery = computed(() => `(min-width: ${this.#breakpoints().xl})`, { ...(ngDevMode ? { debugName: "#desktopQuery" } : {}) });
+        this.#smallDesktopQuery = computed(() => `(min-width: ${this.#breakpoints().lg})`, { ...(ngDevMode ? { debugName: "#smallDesktopQuery" } : {}) });
+        this.#tabletQuery = computed(() => `(min-width: ${this.#breakpoints().md})`, { ...(ngDevMode ? { debugName: "#tabletQuery" } : {}) });
+        this.#smallTabletQuery = computed(() => `(min-width: ${this.#breakpoints().sm})`, { ...(ngDevMode ? { debugName: "#smallTabletQuery" } : {}) });
+        this.#mobileQuery = computed(() => `(max-width: ${this.decrementOnePixel(this.#breakpoints().xs)})`, { ...(ngDevMode ? { debugName: "#mobileQuery" } : {}) });
+        this.isDesktop = toSignal(toObservable(this.#desktopQuery, { injector: this.#injector }).pipe(distinctUntilChanged(), switchMap((query) => this.#breakpointObserver.observe(query)), map(({ matches }) => matches)));
+        this.isSmallDesktop = toSignal(toObservable(this.#smallDesktopQuery, { injector: this.#injector }).pipe(distinctUntilChanged(), switchMap((query) => this.#breakpointObserver.observe(query)), map(({ matches }) => matches)));
+        this.isMobile = toSignal(toObservable(this.#mobileQuery, { injector: this.#injector }).pipe(distinctUntilChanged(), switchMap((query) => this.#breakpointObserver.observe(query)), map(({ matches }) => matches)));
+        this.isTablet = toSignal(toObservable(this.#tabletQuery, { injector: this.#injector }).pipe(distinctUntilChanged(), switchMap((query) => this.#breakpointObserver.observe(query)), map(({ matches }) => !matches)));
+        this.isSmallTablet = toSignal(toObservable(this.#smallTabletQuery, { injector: this.#injector }).pipe(distinctUntilChanged(), switchMap((query) => this.#breakpointObserver.observe(query)), map(({ matches }) => matches)));
+    }
+    /**
+     * Private instance of BreakpointObserver used to observe screen size changes.
+     */
+    #breakpointObserver;
+    /**
+     * Private instance of Injector.
+     */
+    #injector;
+    /**
+     * Instance of a lass containing the breakpoint values for different screen sizes.
+     */
+    #breakpoints;
+    #desktopQuery;
+    #smallDesktopQuery;
+    #tabletQuery;
+    #smallTabletQuery;
+    #mobileQuery;
+    /**
+     * Allows setting custom breakpoints for different screen sizes.
+     *
+     * @param breakpoints - The custom breakpoints to apply.
+     */
+    setBreakpoints(breakpoints) {
+        this.#breakpoints.set(breakpoints);
+    }
+    /**
+     * Helper function to decrement the pixel value by 1.
+     * Used to exclude the exact pixel value in media queries.
+     *
+     * @usageNotes
+     *
+     * This function is useful for setting correct media queries.
+     * E.g. for mobile devices: media query should be `(max-width: 599px)`,
+     * and from `(min-width: 600px)` it should be considered as a tablet.
+     *
+     * @param value - The pixel value to decrement.
+     * @returns The adjusted pixel value as a string.
+     */
+    decrementOnePixel(value) {
+        return Number(value.split('px')[0]) - 1 + 'px';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: BreakpointService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: BreakpointService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: BreakpointService, decorators: [{
+            type: Injectable
+        }] });
+
+class RtNavigationDirective {
+    constructor() {
+        this.#router = inject(Router);
+        this.#windowRef = inject(WINDOW);
+        this.#platformService = inject(PlatformService);
+        this.link = input.required({ ...(ngDevMode ? { debugName: "link" } : {}), alias: 'rtNavigationDirective' });
+    }
+    #router;
+    #windowRef;
+    #platformService;
+    onClick(event) {
+        if (this.link()) {
+            if (this.#platformService.isPlatformBrowser && (event.ctrlKey || event.metaKey)) {
+                this.#windowRef.open(this.link());
+            }
+            else {
+                void this.#router.navigate([this.link()]);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtNavigationDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.1", type: RtNavigationDirective, isStandalone: true, selector: "[rtNavigationDirective]", inputs: { link: { classPropertyName: "link", publicName: "rtNavigationDirective", isSignal: true, isRequired: true, transformFunction: null } }, host: { listeners: { "click": "onClick($event)" } }, providers: [PlatformService], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtNavigationDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rtNavigationDirective]',
+                    providers: [PlatformService],
+                }]
+        }], propDecorators: { link: [{ type: i0.Input, args: [{ isSignal: true, alias: "rtNavigationDirective", required: true }] }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+
+class RtTabQueryParamDirective {
+    constructor() {
+        this.#router = inject(Router);
+        this.#route = inject(ActivatedRoute);
+        this.#destroyRef = inject(DestroyRef);
+        this.#currentTabIndex = signal(0, { ...(ngDevMode ? { debugName: "#currentTabIndex" } : {}) });
+        this.currentTabIndex = this.#currentTabIndex.asReadonly();
+    }
+    #router;
+    #route;
+    #destroyRef;
+    #currentTabIndex;
+    ngOnInit() {
+        this.#route.queryParamMap
+            .pipe(filter((params) => params.has('tab')), take(1), map((params) => Number(params.get('tab'))), takeUntilDestroyed(this.#destroyRef))
+            .subscribe((tabIndex) => {
+            this.#setTabIndex(tabIndex);
+        });
+    }
+    setQueryTab(index) {
+        void this.#router.navigate([], {
+            relativeTo: this.#route,
+            queryParams: {
+                tab: index,
+            },
+            queryParamsHandling: 'merge',
+        });
+        this.#setTabIndex(index);
+    }
+    #setTabIndex(index) {
+        this.#currentTabIndex.set(index);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtTabQueryParamDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.0.1", type: RtTabQueryParamDirective, isStandalone: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtTabQueryParamDirective, decorators: [{
+            type: Directive
+        }] });
+
+class RtScrollDirective {
+    constructor() {
+        this.#windowRef = inject(WINDOW);
+        this.#platformService = inject(PlatformService);
+        this.active = input(true, { ...(ngDevMode ? { debugName: "active" } : {}) });
+        this.multiplier = input(0.5, { ...(ngDevMode ? { debugName: "multiplier" } : {}) });
+        this.scrollAction = output();
+        this.scroll = (event) => {
+            const target = event.target;
+            if (this.active() && target.offsetHeight + target.scrollTop >= target.scrollHeight * this.multiplier()) {
+                this.scrollAction.emit();
+            }
+        };
+    }
+    #windowRef;
+    #platformService;
+    ngOnInit() {
+        if (this.#platformService.isPlatformBrowser) {
+            this.#windowRef.addEventListener('scroll', this.scroll, true);
+        }
+    }
+    ngOnDestroy() {
+        this.#windowRef.removeEventListener('scroll', this.scroll, true);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.1", type: RtScrollDirective, isStandalone: true, selector: "[rtScrollDirective]", inputs: { active: { classPropertyName: "active", publicName: "active", isSignal: true, isRequired: false, transformFunction: null }, multiplier: { classPropertyName: "multiplier", publicName: "multiplier", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { scrollAction: "scrollAction" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rtScrollDirective]',
+                }]
+        }], propDecorators: { active: [{ type: i0.Input, args: [{ isSignal: true, alias: "active", required: false }] }], multiplier: [{ type: i0.Input, args: [{ isSignal: true, alias: "multiplier", required: false }] }], scrollAction: [{ type: i0.Output, args: ["scrollAction"] }] } });
+
+class RtEscapeKeyDirective {
+    constructor() {
+        this.escapeKeyAction = output();
+    }
+    handleKeyboardEvent(event) {
+        if (event.key === 'Escape') {
+            this.escapeKeyAction.emit();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtEscapeKeyDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.0.1", type: RtEscapeKeyDirective, isStandalone: true, selector: "[rtEscapeKey]", outputs: { escapeKeyAction: "escapeKeyAction" }, host: { listeners: { "document:keydown": "handleKeyboardEvent($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: RtEscapeKeyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rtEscapeKey]',
+                }]
+        }], propDecorators: { escapeKeyAction: [{ type: i0.Output, args: ["escapeKeyAction"] }], handleKeyboardEvent: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }] } });
+
+var MODAL_WINDOW_SIZE_ENUM;
+(function (MODAL_WINDOW_SIZE_ENUM) {
+    MODAL_WINDOW_SIZE_ENUM["SM"] = "25rem";
+    MODAL_WINDOW_SIZE_ENUM["MD"] = "45rem";
+    MODAL_WINDOW_SIZE_ENUM["LG"] = "65rem";
+    MODAL_WINDOW_SIZE_ENUM["FULL"] = "100%";
+})(MODAL_WINDOW_SIZE_ENUM || (MODAL_WINDOW_SIZE_ENUM = {}));
+
+var ASIDE_BUTTONS_ENUM;
+(function (ASIDE_BUTTONS_ENUM) {
+    ASIDE_BUTTONS_ENUM["USER_ACTIVE"] = "User active";
+    ASIDE_BUTTONS_ENUM["USER_INACTIVE"] = "User inactive";
+    ASIDE_BUTTONS_ENUM["DELETE"] = "Delete";
+    ASIDE_BUTTONS_ENUM["RESET"] = "Reset";
+})(ASIDE_BUTTONS_ENUM || (ASIDE_BUTTONS_ENUM = {}));
+
+var POSITION_ENUM;
+(function (POSITION_ENUM) {
+    POSITION_ENUM["LEFT"] = "left";
+    POSITION_ENUM["RIGHT"] = "right";
+    POSITION_ENUM["TOP"] = "top";
+    POSITION_ENUM["BOTTOM"] = "bottom";
+    POSITION_ENUM["START"] = "start";
+    POSITION_ENUM["END"] = "end";
+    POSITION_ENUM["CENTER"] = "center";
+})(POSITION_ENUM || (POSITION_ENUM = {}));
+
+class TypeCastHelper {
+    getAsString(data, defaultValue = '') {
+        return !isNil(data) && !Number.isNaN(data) ? String(data) : defaultValue;
+    }
+    getAsNumber(data, defaultValue) {
+        const result = Number(data);
+        return data === null || Number.isNaN(result) ? (defaultValue ?? NaN) : result;
+    }
+    getAsBoolean(data) {
+        const stringExceptions = ['false', '0', 'null'];
+        if (typeof data === 'string' && stringExceptions.includes(data)) {
+            return false;
+        }
+        return Boolean(data);
+    }
+    getAsNull(data, handler) {
+        if (!isNil(data) && !Number.isNaN(data)) {
+            return handler ? handler(data) : data;
+        }
+        return null;
+    }
+    // eslint-disable-next-line
+    getAsType(value, type) {
+        if (!!value && !Object.values(type).includes(value)) {
+            // eslint-disable-next-line no-console
+            console.error(`getAsTyped: the value "${value}" was not found in the specified type`);
+            return 'unknown';
+        }
+        return value;
+    }
+    getAsTypedArray(data, cb, showError = true) {
+        if (!Array.isArray(data)) {
+            if (showError) {
+                // eslint-disable-next-line no-console
+                console.error('getAsTypedArray: Given data must be an array (now it is ' +
+                    typeof data +
+                    '). Incorrect data will be defined as array of data (data => [data]).');
+            }
+            data = [data];
+        }
+        if (!data.length) {
+            return [];
+        }
+        return data.map(cb);
+    }
+    getAsDate(date, asString, parseFormatOptions, formatOptions) {
+        formatOptions = formatOptions ?? 'dd.MM.yyyy';
+        asString = asString ?? true;
+        const type = typeof date;
+        switch (type) {
+            case 'number':
+                date = new Date(date);
+                break;
+            case 'string':
+                date = !!parseFormatOptions ? parseDate(date, parseFormatOptions, new Date()) : parseISO(date);
+                break;
+        }
+        if (!isDate(date)) {
+            return '';
+        }
+        return asString ? formatDate(date, formatOptions) : date;
+    }
+}
+
+class BaseMapper {
+    constructor() {
+        this.typeCast = new TypeCastHelper();
+    }
+    // eslint-disable-next-line
+    mapFrom(data, ...args) {
+        return { ...data };
+    }
+    mapFromArray(data, ...args) {
+        if (!Array.isArray(data)) {
+            // eslint-disable-next-line no-console
+            console.error('mapFromArray: Given data must be an array (now it is ' + typeof data + '). Incorrect data will be defined as empty array.');
+            data = [];
+        }
+        return data.map((entry) => this.mapFrom(entry, ...args));
+    }
+    // eslint-disable-next-line
+    mapTo(model, ...args) {
+        return { ...model };
+    }
+    mapToArray(models, ...args) {
+        if (!Array.isArray(models)) {
+            // eslint-disable-next-line no-console
+            console.error('mapToArray: Given data must be an array (now it is ' + typeof models + '). Incorrect data will be defined as empty array.');
+            models = [];
+        }
+        return models.map((model) => this.mapTo(model, ...args));
+    }
+}
+
+class BreakStringPipe {
+    transform(value) {
+        if (isNil(value)) {
+            return DASH;
+        }
+        if (value && isString(value)) {
+            if (/\s/.test(value) || /^[A-Z0-9\s]+$/.test(value) || /\d/.test(value) || /[^\w\s]/.test(value)) {
+                return value;
+            }
+            return value.split(/(?=[A-Z])/).join(' ');
+        }
+        return value.toString();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: BreakStringPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.0.1", ngImport: i0, type: BreakStringPipe, isStandalone: true, name: "breakString" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: BreakStringPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'breakString',
+                }]
+        }] });
+
+class SanitizePipe {
+    #sanitizer = inject(DomSanitizer);
+    transform(value) {
+        return this.#sanitizer.bypassSecurityTrustHtml(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: SanitizePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.0.1", ngImport: i0, type: SanitizePipe, isStandalone: true, name: "sanitize" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: SanitizePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'sanitize',
+                    pure: true,
+                }]
+        }] });
+
+class EntityToStringPipe {
+    transform(value) {
+        if (isString(value)) {
+            return value;
+        }
+        if (isNumber(value)) {
+            return value.toString();
+        }
+        return DASH;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: EntityToStringPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.0.1", ngImport: i0, type: EntityToStringPipe, isStandalone: true, name: "entityToString" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: EntityToStringPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'entityToString',
+                    pure: true,
+                }]
+        }] });
+
+class EmptyToDashPipe {
+    transform(value) {
+        return emptyToDash(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: EmptyToDashPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.0.1", ngImport: i0, type: EmptyToDashPipe, isStandalone: true, name: "emptyToDash" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: EmptyToDashPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'emptyToDash',
+                    pure: true,
+                }]
+        }] });
+
+/**
+ * @description Use to compare equality to any of items with provided value
+ * @example
+ *
+ * Direct usage
+ * ```ts
+ *   equalPipe.transform(100, 1, 10, 100) // => true
+ * ```
+ *
+ * Template usage
+ *
+ * ```html
+ *   <div *ngIf="100 | equal:1:10:100">Visible</div>
+ * ```
+ */
+class EqualPipe {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transform(value, ...compares) {
+        return compares.reduce((equal, compare) => equal || value === compare, false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: EqualPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.0.1", ngImport: i0, type: EqualPipe, isStandalone: true, name: "equal" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: EqualPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'equal',
+                }]
+        }] });
+
+/**
+ * @description Use to access to the deep object state for comparison
+ * @example
+ *  {a: {b: true}} | equalChain:'a':'b':true => true
+ */
+class EqualChainPipe {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transform(obj, ...args) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const compared = args.pop();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return Boolean(obj) && args.reduce((inner, arg) => inner[arg], obj) === compared;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: EqualChainPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.0.1", ngImport: i0, type: EqualChainPipe, isStandalone: true, name: "equalChain" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: EqualChainPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'equalChain',
+                }]
+        }] });
+
+/**
+ * @description Use to compare not equality to all items with provided value
+ * @example
+ *
+ * Direct usage
+ * ```ts
+ *   notEqualPipe.transform(100, 1, 10, 100) // => false
+ * ```
+ *
+ * Template usage
+ *
+ * ```html
+ *   <div *ngIf="100 | notEqual:1:10:100">Invisible</div>
+ * ```
+ */
+class NotEqualPipe {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transform(value, ...compares) {
+        return compares.reduce((notEqual, compare) => notEqual && value !== compare, true);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: NotEqualPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.0.1", ngImport: i0, type: NotEqualPipe, isStandalone: true, name: "notEqual" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: NotEqualPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'notEqual',
+                }]
+        }] });
+
+/**
+ * @description Use to access to the deep object state for comparison
+ * @example
+ *  {a: {b: true}} | equalChain:'a':'b':false => true
+ */
+class NotEqualChainPipe {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transform(obj, ...args) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const compared = args.pop();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return Boolean(obj) && args.reduce((inner, arg) => inner[arg], obj) !== compared;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: NotEqualChainPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.0.1", ngImport: i0, type: NotEqualChainPipe, isStandalone: true, name: "notEqualChain" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: NotEqualChainPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'notEqualChain',
+                }]
+        }] });
+
+class TernaryPipe {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transform(value, option1, option2) {
+        return Boolean(value) ? option1 : option2;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: TernaryPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.0.1", ngImport: i0, type: TernaryPipe, isStandalone: true, name: "ternary" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.1", ngImport: i0, type: TernaryPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'ternary',
+                }]
+        }] });
+
+function checkIsMatchingValues(sample) {
+    return (control) => {
+        return sample && control.value && control.value.localeCompare(sample) === 0 ? null : { notEquivalent: true };
+    };
+}
+
+function arraysNotEmptyValidator(control) {
+    if (control.value instanceof Object) {
+        const arrays = Object.values(control.value);
+        const allArraysEmpty = arrays.every((array) => !array.length);
+        return allArraysEmpty ? { allArraysEmpty: true } : null;
+    }
+    else if (Array.isArray(control.value)) {
+        const array = control.value;
+        return !array.length ? { arrayEmpty: true } : null;
+    }
+    else {
+        return { invalidType: true };
+    }
+}
+
+/**
+ * Returns a set of dependency injection providers for utility services.
+ *
+ * @usageNotes
+ *
+ * This function provides utility services that are commonly used across
+ * an Angular application. Specifically, it provides the `BreakpointService`
+ * for managing responsive design breakpoints and the `PlatformService` for
+ * detecting the platform on which the application is running (e.g., browser or server).
+ *
+ * ```typescript
+ * bootstrapApplication(RootComponent, {
+ *   providers: [
+ *     provideRtUtils()
+ *   ]
+ * });
+ * ```
+ *
+ * @publicApi
+ */
+function provideRtUtils() {
+    return [BreakpointService, PlatformService];
+}
+
+// constants
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ASIDE_BUTTONS_ENUM, ASIDE_REF, AsideRef, BaseMapper, BreakStringPipe, BreakpointService, Breakpoints, DASH, DeviceDetectorService, EmptyToDashPipe, EntityToStringPipe, EqualChainPipe, EqualPipe, HAS_OWN_SCOPE_ENUM, MODAL_WINDOW_SIZE_ENUM, NAVIGATOR, NotEqualChainPipe, NotEqualPipe, OSTypes, OVERLAY_POSITIONS, POSITION_ENUM, RtEscapeKeyDirective, RtHideTooltipDirective, RtIconOutlinedDirective, RtNavigationDirective, RtScrollDirective, RtScrollToElementDirective, RtTabQueryParamDirective, SanitizePipe, TernaryPipe, TypeCastHelper, areArraysEqual, areArraysEqualUnordered, areObjectsEqual, arraysNotEmptyValidator, checkIsEntityInArrayByKey, checkIsMatchingValues, dateStringToDate, ddServices, debounce, emptyToDash, formatDate, hasPropertyInChain, initToday, isDate, isDateValid, isEmail, isEmpty, isEmptyArray, isEmptyObject, isEmptyString, isEqual, isNumber, isRecord, isString, isToday, parseDate, parseISO, provideRtUtils, removeFieldFromObject, safeComparatorPipe, safeCompare, safeNumCompare, safeStrCompare, sortByAlphabet, sortByDate, stringifyHttpLikeParams, transformArrayInput, transformStringInput };
+//# sourceMappingURL=rt-tools-utils.mjs.map