tool-dom-ang15 0.0.8 → 0.0.10

package/README.md

@@ -52,9 +52,11 @@ tool-dom-ang15/
 ├── tool-dom-ang15.component.html   # шаблон (панели + лог)
 ├── tool-dom-ang15.component.scss   # стили
 └── dom/
-    ├── dom-element.ts              # сервис DomElement
-    ├── dom-class.ts                # сервис DomClass
-    └── dom-style.ts                # сервис DomStyle
+    ├── dom-tools.ts               # сервис DomToolsService
+    ├── root
+        ├── dom-element.ts              # сервис DomElement
+        ├── dom-class.ts                # сервис DomClass
+        └── dom-style.ts                # сервис DomStyle
 ```
 
 ---
@@ -95,7 +97,7 @@ tool-dom-ang15/
 **Инициализация (`ngOnInit`):**
 
 ```ts
-this.dom   = new DomElement(this.document);
+this.elt   = new DomElement(this.document);
 this.cls   = new DomClass(this.document);
 this.style = new DomStyle();
 ```

package/esm2020/lib/dom/dom-tools.mjs

@@ -0,0 +1,31 @@
+import { Inject, Injectable } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { DomClass } from './source/dom-class';
+import { DomElement } from './source/dom-element';
+import { DomStyle } from './source/dom-style';
+import * as i0 from "@angular/core";
+export function createDomTools(document) {
+    return {
+        elt: new DomElement(document),
+        cls: new DomClass(document),
+        style: new DomStyle(),
+    };
+}
+export class DomToolsService {
+    constructor(document) {
+        const t = createDomTools(document);
+        this.elt = t.elt;
+        this.cls = t.cls;
+        this.style = t.style;
+    }
+}
+DomToolsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DomToolsService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+DomToolsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DomToolsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DomToolsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/dom/source/dom-class.mjs

@@ -0,0 +1,198 @@
+import { __decorate, __param } from "tslib";
+import { Inject } from '@angular/core';
+import { DOCUMENT } from "@angular/common";
+import { DomElement } from "./dom-element";
+/**
+ * Класс для работы с классами DOM
+ */
+let DomClass = class DomClass {
+    constructor(document) {
+        this.document = document;
+        this.elt = new DomElement(this.document);
+    }
+    //region Управление классами
+    /**
+     * Проверяет наличие класса у элемента
+     *
+     * @param {HTMLElement} element - Элемент
+     * @param {string} className - Класс
+     *
+     * @returns {boolean} true, если класс присутствует
+     */
+    hasClass(element, className) {
+        return !!(className && element?.classList.contains(className));
+    }
+    /**
+     * Добавляет класс элементу
+     *
+     * @param {HTMLElement} element - Элемент
+     * @param {string} className - Класс
+     *
+     * @returns {boolean} true, если класс добавили
+     */
+    addClass(element, className) {
+        if (className && element && 'classList' in element) {
+            element.classList.add(className);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Массовое добавление CSS-классов
+     *
+     * @param {HTMLElement} element - Элемент
+     * @param classNames - Массив названий CSS-классов для добавления
+     */
+    addClasses(element, classNames) {
+        if (!element || !classNames || classNames.length === 0) {
+            return;
+        }
+        classNames.forEach(className => {
+            if (className && className.trim() !== '') {
+                this.addClass(element, className.trim());
+            }
+        });
+    }
+    /**
+     * Создает CSS-классы для margin и padding на основе переменных --evo{n}.
+     * Классы генерируются для всех направлений (top, right, bottom, left).
+     *
+     * @param elementRef - Элемент для которого будут создаваться классы.
+     * @param {number[]} arrVars - Значения для генерации классов.
+     *
+     */
+    addClassMarginPadding(elementRef, arrVars = []) {
+        const root = this.elt.elementGetParent(elementRef.nativeElement);
+        if (!root) {
+            console.error('Root element not found');
+            return;
+        }
+        const properties = ['m', 'p']; // margin, padding
+        const directions = ['t', 'r', 'b', 'l']; // top, right, bottom, left
+        let style = this.document.querySelector('style[data-dynamic-style]');
+        if (!style) {
+            style = this.document.createElement('style');
+            style.setAttribute('data-dynamic-style', '');
+            root.appendChild(style);
+        }
+        let cssContent = '';
+        // Добавляем классы для arrVars (если массив не пустой)
+        if (arrVars && arrVars.length > 0) {
+            arrVars.forEach(value => {
+                properties.forEach(prop => {
+                    directions.forEach(dir => {
+                        const className = `.evo-${prop}${dir}-${value}`;
+                        const cssProperty = prop === 'm' ? 'margin' : 'padding';
+                        const cssDirection = this._getCssDirection(dir);
+                        cssContent += `${className} { ${cssProperty}-${cssDirection}: var(--evo${value}); }\n`;
+                    });
+                });
+            });
+        }
+        style.textContent = cssContent;
+    }
+    /**
+     * Удаление всех классов созданных в addClassMarginPadding (<style data-dynamic-style="">)
+     *  @see {@link addClassMarginPadding} - Создает CSS-классы для margin и padding на основе переменных --evo{n}.
+     */
+    deleteClassMarginPadding() {
+        this.document.querySelector('style[data-dynamic-style]')?.remove();
+    }
+    /**
+     * Удаляет класс у элемента
+     *
+     * @param {HTMLElement} element - Элемент
+     * @param {string} className - Класс
+     *
+     * @returns {boolean} true, если класс был удален
+     */
+    removeClass(element, className) {
+        if (className && element && 'classList' in element) {
+            element.classList.remove(className);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Переключает CSS-класс у корневого элемента
+     *
+     * @param {HTMLElement} element - Элемент
+     * @param className - Название CSS-класса для переключения
+     * @param force - Принудительно установить или удалить класс (true - добавить, false - удалить)
+     */
+    toggleClass(element, className, force) {
+        if (!element || !className) {
+            return;
+        }
+        const trimmedClassName = className.trim();
+        if (force !== undefined) {
+            if (force) {
+                this.addClass(element, trimmedClassName);
+            }
+            else {
+                this.removeClass(element, trimmedClassName);
+            }
+        }
+        else {
+            // Переключаем на основе текущего состояния
+            if (this.hasClass(element, trimmedClassName)) {
+                this.removeClass(element, trimmedClassName);
+            }
+            else {
+                this.addClass(element, trimmedClassName);
+            }
+        }
+    }
+    /**
+     * Возвращает массив всех CSS-классов корневого элемента
+     *
+     * @param {HTMLElement} element - Элемент
+     *
+     * @returns Массив названий CSS-классов
+     */
+    getClasses(element) {
+        if (element) {
+            // Получаем актуальные классы с элемента
+            return Array.from(element.classList);
+        }
+        return [];
+    }
+    /**
+     * Удаляет все CSS-классы у корневого элемента и очищает кэш
+     *
+     * @param {HTMLElement} element - Элемент
+     */
+    clearClasses(element) {
+        // Удаляем все классы с элемента
+        if (element) {
+            element.className = '';
+        }
+    }
+    //endregion
+    //region Приватные методы
+    /**
+     * Преобразует сокращенное направление (t, r, b, l) в полное название CSS-свойства.
+     *
+     * @param {string} dir - Сокращенное направление (t, r, b, l).
+     * @returns {string} Полное название направления (top, right, bottom, left).
+     */
+    _getCssDirection(dir) {
+        switch (dir) {
+            case 't':
+                return 'top';
+            case 'r':
+                return 'right';
+            case 'b':
+                return 'bottom';
+            case 'l':
+                return 'left';
+            default:
+                return '';
+        }
+    }
+};
+DomClass = __decorate([
+    __param(0, Inject(DOCUMENT))
+], DomClass);
+export { DomClass };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dom-class.js","sourceRoot":"","sources":["../../../../../../projects/tool-dom-ang15/src/lib/dom/source/dom-class.ts"],"names":[],"mappings":"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","sourcesContent":["import {ElementRef, Inject} from '@angular/core';\r\nimport {DOCUMENT} from \"@angular/common\";\r\nimport {DomElement} from \"./dom-element\";\r\n\r\n/**\r\n * Класс для работы с классами DOM\r\n */\r\nexport class DomClass {\r\n    public elt: DomElement;\r\n\r\n    constructor(\r\n        @Inject(DOCUMENT) public document: Document,\r\n    ) {\r\n        this.elt = new DomElement(this.document)\r\n    }\r\n\r\n    //region Управление классами\r\n    /**\r\n     * Проверяет наличие класса у элемента\r\n     *\r\n     * @param {HTMLElement} element - Элемент\r\n     * @param {string} className - Класс\r\n     *\r\n     * @returns {boolean} true, если класс присутствует\r\n     */\r\n    hasClass(element: HTMLElement, className: string): boolean {\r\n        return !!(className && element?.classList.contains(className));\r\n    }\r\n\r\n    /**\r\n     * Добавляет класс элементу\r\n     *\r\n     * @param {HTMLElement} element - Элемент\r\n     * @param {string} className - Класс\r\n     *\r\n     * @returns {boolean} true, если класс добавили\r\n     */\r\n    addClass(element: HTMLElement | null, className: string): boolean {\r\n        if (className && element && 'classList' in element) {\r\n            element.classList.add(className);\r\n\r\n            return true;\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Массовое добавление CSS-классов\r\n     *\r\n     * @param {HTMLElement} element - Элемент\r\n     * @param classNames - Массив названий CSS-классов для добавления\r\n     */\r\n    addClasses(element: HTMLElement | null, classNames: string[]): void {\r\n        if (!element || !classNames || classNames.length === 0) {\r\n            return;\r\n        }\r\n\r\n        classNames.forEach(className => {\r\n            if (className && className.trim() !== '') {\r\n                this.addClass(element, className.trim());\r\n            }\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Создает CSS-классы для margin и padding на основе переменных --evo{n}.\r\n     * Классы генерируются для всех направлений (top, right, bottom, left).\r\n     *\r\n     * @param elementRef - Элемент для которого будут создаваться классы.\r\n     * @param {number[]} arrVars - Значения для генерации классов.\r\n     *\r\n     */\r\n    addClassMarginPadding(elementRef: ElementRef<HTMLElement>, arrVars: number[] = []): void {\r\n        const root = this.elt.elementGetParent(elementRef.nativeElement);\r\n\r\n        if (!root) {\r\n            console.error('Root element not found');\r\n            return;\r\n        }\r\n\r\n        const properties = ['m', 'p']; // margin, padding\r\n        const directions = ['t', 'r', 'b', 'l']; // top, right, bottom, left\r\n        let style = this.document.querySelector('style[data-dynamic-style]');\r\n\r\n        if (!style) {\r\n            style = this.document.createElement('style');\r\n            style.setAttribute('data-dynamic-style', '');\r\n            root.appendChild(style);\r\n        }\r\n\r\n        let cssContent = '';\r\n\r\n        // Добавляем классы для arrVars (если массив не пустой)\r\n        if (arrVars && arrVars.length > 0) {\r\n            arrVars.forEach(value => {\r\n                properties.forEach(prop => {\r\n                    directions.forEach(dir => {\r\n                        const className = `.evo-${prop}${dir}-${value}`;\r\n                        const cssProperty = prop === 'm' ? 'margin' : 'padding';\r\n                        const cssDirection = this._getCssDirection(dir);\r\n\r\n                        cssContent += `${className} { ${cssProperty}-${cssDirection}: var(--evo${value}); }\\n`;\r\n                    });\r\n                });\r\n            });\r\n        }\r\n\r\n        style.textContent = cssContent;\r\n    }\r\n\r\n    /**\r\n     * Удаление всех классов созданных в addClassMarginPadding (<style data-dynamic-style=\"\">)\r\n     *  @see {@link addClassMarginPadding} - Создает CSS-классы для margin и padding на основе переменных --evo{n}.\r\n     */\r\n    deleteClassMarginPadding(): void {\r\n        this.document.querySelector('style[data-dynamic-style]')?.remove();\r\n    }\r\n\r\n    /**\r\n     * Удаляет класс у элемента\r\n     *\r\n     * @param {HTMLElement} element - Элемент\r\n     * @param {string} className - Класс\r\n     *\r\n     * @returns {boolean} true, если класс был удален\r\n     */\r\n    removeClass(element: HTMLElement | null, className: string): boolean {\r\n        if (className && element && 'classList' in element) {\r\n            element.classList.remove(className);\r\n\r\n            return true;\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Переключает CSS-класс у корневого элемента\r\n     *\r\n     * @param {HTMLElement} element - Элемент\r\n     * @param className - Название CSS-класса для переключения\r\n     * @param force - Принудительно установить или удалить класс (true - добавить, false - удалить)\r\n     */\r\n    toggleClass(element: HTMLElement | null, className: string, force?: boolean): void {\r\n        if (!element || !className) {\r\n            return;\r\n        }\r\n\r\n        const trimmedClassName = className.trim();\r\n\r\n        if (force !== undefined) {\r\n            if (force) {\r\n                this.addClass(element, trimmedClassName);\r\n            } else {\r\n                this.removeClass(element, trimmedClassName);\r\n            }\r\n        } else {\r\n            // Переключаем на основе текущего состояния\r\n            if (this.hasClass(element, trimmedClassName)) {\r\n                this.removeClass(element, trimmedClassName);\r\n            } else {\r\n                this.addClass(element, trimmedClassName);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Возвращает массив всех CSS-классов корневого элемента\r\n     *\r\n     * @param {HTMLElement} element - Элемент\r\n     *\r\n     * @returns Массив названий CSS-классов\r\n     */\r\n    getClasses(element: HTMLElement | null): string[] {\r\n        if (element) {\r\n            // Получаем актуальные классы с элемента\r\n            return Array.from(element.classList);\r\n        }\r\n\r\n        return [];\r\n    }\r\n\r\n    /**\r\n     * Удаляет все CSS-классы у корневого элемента и очищает кэш\r\n     *\r\n     * @param {HTMLElement} element - Элемент\r\n     */\r\n    clearClasses(element: HTMLElement | null): void {\r\n        // Удаляем все классы с элемента\r\n        if (element) {\r\n            element.className = '';\r\n        }\r\n    }\r\n\r\n    //endregion\r\n\r\n    //region Приватные методы\r\n\r\n    /**\r\n     * Преобразует сокращенное направление (t, r, b, l) в полное название CSS-свойства.\r\n     *\r\n     * @param {string} dir - Сокращенное направление (t, r, b, l).\r\n     * @returns {string} Полное название направления (top, right, bottom, left).\r\n     */\r\n    private _getCssDirection(dir: string): string {\r\n        switch (dir) {\r\n            case 't':\r\n                return 'top';\r\n            case 'r':\r\n                return 'right';\r\n            case 'b':\r\n                return 'bottom';\r\n            case 'l':\r\n                return 'left';\r\n            default:\r\n                return '';\r\n        }\r\n    }\r\n\r\n    //endregion\r\n}\r\n"]}

package/esm2020/lib/dom/source/dom-element.mjs

@@ -0,0 +1,299 @@
+import { __decorate, __param } from "tslib";
+import { DOCUMENT } from '@angular/common';
+import { Inject } from '@angular/core';
+/**
+ * Предоставляет методы для манипуляции DOM элементами
+ *
+ * Класс включает функционал для:
+ * - Создания элементов
+ * - Добавления и удаления элементов из DOM
+ * - Поиска элементов с повторными попытками
+ * - Навигации по DOM дереву
+ * - Работы с data-атрибутами
+ */
+let DomElement = class DomElement {
+    constructor(document) {
+        this.document = document;
+        this._countGetElement = 0;
+    }
+    /**
+     * Создает новый DOM элемент с указанным тегом и CSS классом
+     *
+     * @param tagName - HTML тег создаваемого элемента (div, span, button и т.д.)
+     * @param className - CSS класс для элемента (опционально)
+     * @returns Новый DOM элемент
+     *
+     * @example
+     * const div = worker.createElement('div', 'container');
+     * const span = worker.createElement('span');
+     */
+    createElement(tagName, className) {
+        const element = this.document.createElement(tagName);
+        if (className) {
+            element.className = className;
+        }
+        return element;
+    }
+    /**
+     * Создает и добавляет новый HTML элемент в DOM
+     *
+     * @param parentElement - Родительский элемент, к которому будет добавлен новый
+     * @param newElement - HTML тег создаваемого элемента
+     * @param typeAppend - Способ добавления ('appendChild' или 'insertBefore')
+     * @param strInnerHTML - Внутреннее HTML содержимое (опционально)
+     * @param dataId - Значение для атрибута data-id (опционально)
+     * @param eventName - Тип события для добавления слушателя
+     * @param fn - Функция-обработчик события (опционально)
+     *
+     * @example
+     * worker.elementCreate(
+     *   this.document.body,
+     *   'button',
+     *   'appendChild',
+     *   'Click me',
+     *   123,
+     *   'click',
+     *   () => console.log('Clicked')
+     * );
+     */
+    elementCreate(parentElement, newElement, typeAppend, strInnerHTML = '', dataId = '', eventName, fn = null) {
+        if (!parentElement || !newElement) {
+            return;
+        }
+        const el$ = this.document.createElement(newElement);
+        if (dataId !== null) {
+            el$.setAttribute('data-id', String(dataId));
+        }
+        if (strInnerHTML) {
+            el$.innerHTML = strInnerHTML;
+        }
+        this.elementAdd(parentElement, typeAppend, dataId, eventName, fn, el$);
+    }
+    /**
+     * Добавляет существующий HTML элемент в DOM
+     *
+     * @param parentElement - Родительский элемент
+     * @param typeAppend - Способ добавления ('appendChild' или 'insertBefore')
+     * @param dataId - Идентификатор для атрибута data-id
+     * @param eventName - Тип события для слушателя
+     * @param fn - Функция-обработчик события
+     * @param el$ - Добавляемый DOM элемент
+     *
+     * @remarks
+     * Если typeAppend равен 'insertBefore', элемент добавляется в начало родителя.
+     * В противном случае элемент добавляется в конец.
+     */
+    elementAdd(parentElement, typeAppend, dataId, eventName, fn, el$) {
+        if ('firstChild' in parentElement) {
+            if (typeAppend === 'insertBefore') {
+                parentElement.insertBefore(el$, parentElement.firstChild);
+            }
+            else {
+                parentElement.appendChild(el$);
+            }
+        }
+        else {
+            parentElement.appendChild(el$);
+        }
+        if (fn) {
+            el$.addEventListener(eventName, event => {
+                fn.call(null, event, null, el$, dataId);
+            });
+        }
+    }
+    /**
+     * Удаляет HTML элемент из DOM
+     *
+     * @param parentElement - Родительский элемент, содержащий удаляемый элемент
+     * @param el$ - Удаляемый DOM элемент
+     *
+     * @remarks
+     * Метод безопасно завершается, если parentElement или el$ отсутствуют
+     */
+    elementRemove(parentElement, el$) {
+        if (parentElement && el$) {
+            parentElement.removeChild(el$);
+        }
+    }
+    /**
+     * Асинхронно получает HTML элемент с повторными попытками
+     *
+     * @param identifier - Селектор для поиска элемента
+     * @param selector - Метод поиска ('querySelector' или 'querySelectorAll')
+     * @param node - DOM узел для поиска (по умолчанию this.document)
+     * @param time - Задержка между попытками в мс (по умолчанию 300)
+     * @param max - Максимальное количество попыток (по умолчанию 10)
+     * @returns Промис с найденным DOM элементом
+     *
+     * @remarks
+     * Метод полезен для ожидания появления динамически создаваемых элементов
+     */
+    async elementGet(identifier, selector = 'querySelector', node = this.document, time = 300, max = 10) {
+        let result = await this._getElementResult(identifier, selector, node, time);
+        if ((!result || (result instanceof NodeList && result.length < 1)) && this._countGetElement < max) {
+            this._countGetElement++;
+            result = await this.elementGet(identifier, selector, node, time, max);
+        }
+        return result;
+    }
+    /**
+     * Находит элементы по data-атрибуту или его значению
+     *
+     * @param elementToSelect - Название data-атрибута (например, 'data-id')
+     * @param dataValue - Значение атрибута для фильтрации (опционально)
+     * @returns Массив найденных элементов
+     * @throws {Error} Если elementToSelect не указан
+     *
+     * @example
+     * // Найти все элементы с data-id
+     * const items = worker.getElementByDataAttribute('data-id');
+     *
+     * // Найти элемент с конкретным значением
+     * const item = worker.getElementByDataAttribute('data-id', '123');
+     */
+    getElementByDataAttribute(elementToSelect, dataValue = null) {
+        if (!elementToSelect) {
+            throw new Error('elementToSelect is required for getElementByDataAttribute');
+        }
+        const selector = dataValue ? `[${elementToSelect}='${dataValue}']` : `[${elementToSelect}]`;
+        const elements = this.document.querySelectorAll(selector);
+        return Array.from(elements);
+    }
+    /**
+     * Внутренний метод для получения элемента с задержкой
+     *
+     * @param identifier - Селектор элемента
+     * @param selector - Метод поиска
+     * @param node - Корневой узел
+     * @param time - Время задержки в мс
+     * @returns Промис с результатом поиска
+     * @private
+     */
+    async _getElementResult(identifier, selector, node, time) {
+        return this._setDelay(time)
+            .then(_ => {
+            if (!node) {
+                return null;
+            }
+            // Используем type assertion для вызова метода
+            const result = node[selector](identifier);
+            return result || null;
+        })
+            .catch(error => console.log('Ошибка в _getElementResult', error));
+    }
+    /**
+     * Создает Promise с задержкой
+     *
+     * @param ms - Время задержки в миллисекундах
+     * @returns Promise, который разрешается через указанное время
+     * @private
+     */
+    _setDelay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Возвращает размеры элемента и его положение относительно viewport
+     *
+     * @param element - Целевой DOM элемент
+     * @returns DOMRect объект с координатами (top, left, right, bottom) и размерами (width, height)
+     * @throws {Error} Если element не указан
+     *
+     * @example
+     * const rect = worker.getCoordinates(buttonElement);
+     * console.log(rect.top, rect.left, rect.width);
+     */
+    getCoordinates(element) {
+        if (!element) {
+            throw new Error('Element is required for getCoordinates');
+        }
+        return element.getBoundingClientRect();
+    }
+    /**
+     * Возвращает родительский элемент указанного DOM узла
+     *
+     * @param el - DOM элемент или NodeList
+     * @returns Родительский элемент или null, если родителя нет
+     */
+    elementGetParent(el) {
+        if (el && 'parentNode' in el) {
+            return el.parentNode;
+        }
+        return null;
+    }
+    /**
+     * Возвращает все соседние элементы (включая сам элемент)
+     *
+     * @param el - Исходный DOM элемент
+     * @returns Массив всех элементов в текущей ветке DOM дерева
+     *
+     * @remarks
+     * Метод собирает все элементы на одном уровне вложенности
+     */
+    elementsGetSiblingAll(el) {
+        if (el && 'parentNode' in el) {
+            const parent = el.parentNode;
+            const firstElement = parent.firstChild;
+            return this.elementGetSiblingNext(firstElement);
+        }
+        return [];
+    }
+    /**
+     * Возвращает все следующие соседние элементы (nextElementSibling)
+     *
+     * @param el - Исходный DOM элемент
+     * @returns Массив элементов, начиная с указанного и включая все следующие
+     *
+     * @example
+     * const nextElements = worker.elementGetSiblingNext(currentElement);
+     * // Возвращает [currentElement, nextElement, nextNextElement, ...]
+     */
+    elementGetSiblingNext(el) {
+        const result = [];
+        while (el) {
+            if ('nextElementSibling' in el) {
+                result.push(el);
+                el = el.nextElementSibling;
+            }
+            else {
+                break;
+            }
+        }
+        return result;
+    }
+    /**
+     * Возвращает все предыдущие соседние элементы (previousSibling)
+     *
+     * @param el - Исходный DOM элемент
+     * @returns Массив предыдущих элементов
+     *
+     * @remarks
+     * Возвращает все элементы, включая указанный, в обратном порядке
+     */
+    elementGetSiblingPrevious(el) {
+        const result = [];
+        let current = el;
+        while (current) {
+            result.push(current);
+            current = current.previousSibling;
+        }
+        return result;
+    }
+    /**
+     * Возвращает все прямые дочерние элементы указанного родителя
+     *
+     * @param el - Родительский DOM элемент
+     * @returns Массив дочерних элементов
+     *
+     * @example
+     * const children = worker.elementGetChildren(parentElement);
+     * children.forEach(child => console.log(child.tagName));
+     */
+    elementGetChildren(el) {
+        return Array.from(el.children);
+    }
+};
+DomElement = __decorate([
+    __param(0, Inject(DOCUMENT))
+], DomElement);
+export { DomElement };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dom-element.js","sourceRoot":"","sources":["../../../../../../projects/tool-dom-ang15/src/lib/dom/source/dom-element.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAKrC;;;;;;;;;GASG;AACI,IAAM,UAAU,GAAhB,MAAM,UAAU;IAInB,YAAqC,QAAkB;QAAlB,aAAQ,GAAR,QAAQ,CAAU;QAF/C,qBAAgB,GAAG,CAAC,CAAC;IAG7B,CAAC;IAED;;;;;;;;;;OAUG;IACH,aAAa,CAAC,OAAe,EAAE,SAAkB;QAC7C,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QACrD,IAAI,SAAS,EAAE;YACX,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;SACjC;QACD,OAAO,OAAO,CAAC;IACnB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,aAAa,CACT,aAA0B,EAC1B,UAAkB,EAClB,UAAuB,EACvB,eAAuB,EAAE,EACzB,SAA0B,EAAE,EAC5B,SAAqB,EACrB,KAAsD,IAAI;QAE1D,IAAI,CAAC,aAAa,IAAI,CAAC,UAAU,EAAE;YAC/B,OAAO;SACV;QAED,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;QAEpD,IAAI,MAAM,KAAK,IAAI,EAAE;YACjB,GAAG,CAAC,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;SAC/C;QAED,IAAI,YAAY,EAAE;YACd,GAAG,CAAC,SAAS,GAAG,YAAY,CAAC;SAChC;QAED,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC;IAC3E,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,UAAU,CACN,aAA0B,EAC1B,UAAuB,EACvB,MAAuB,EACvB,SAAqB,EACrB,EAAmD,EACnD,GAAgB;QAEhB,IAAI,YAAY,IAAI,aAAa,EAAE;YAC/B,IAAI,UAAU,KAAK,cAAc,EAAE;gBAC9B,aAAsB,CAAC,YAAY,CAAC,GAAG,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;aACvE;iBAAM;gBACF,aAAsB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;aAC5C;SACJ;aAAM;YACF,aAAsB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;SAC5C;QAED,IAAI,EAAE,EAAE;YACJ,GAAG,CAAC,gBAAgB,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE;gBACpC,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;YAC5C,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAED;;;;;;;;OAQG;IACH,aAAa,CAAC,aAA0B,EAAE,GAAgB;QACtD,IAAI,aAAa,IAAI,GAAG,EAAE;YACrB,aAAsB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;SAC5C;IACL,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,UAAU,CACZ,UAAkB,EAClB,WAAsB,eAAe,EACrC,OAAsC,IAAI,CAAC,QAAQ,EACnD,OAAe,GAAG,EAClB,MAAc,EAAE;QAEhB,IAAI,MAAM,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QAE5E,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,MAAM,YAAY,QAAQ,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,gBAAgB,GAAG,GAAG,EAAE;YAC/F,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;SACzE;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,yBAAyB,CAAC,eAAuB,EAAE,YAA2B,IAAI;QAC9E,IAAI,CAAC,eAAe,EAAE;YAClB,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;SAChF;QACD,MAAM,QAAQ,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,eAAe,KAAK,SAAS,IAAI,CAAC,CAAC,CAAC,IAAI,eAAe,GAAG,CAAC;QAC5F,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QAC1D,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAkB,CAAC;IACjD,CAAC;IAED;;;;;;;;;OASG;IACK,KAAK,CAAC,iBAAiB,CAC3B,UAAkB,EAClB,QAAmB,EACnB,IAAmC,EACnC,IAAY;QAEZ,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;aACtB,IAAI,CAAC,CAAC,CAAC,EAAE;YACN,IAAI,CAAC,IAAI,EAAE;gBACP,OAAO,IAAI,CAAC;aACf;YACD,8CAA8C;YAC9C,MAAM,MAAM,GAAI,IAAY,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,CAAC;YACnD,OAAO,MAAM,IAAI,IAAI,CAAC;QAC1B,CAAC,CAAC;aACD,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,4BAA4B,EAAE,KAAK,CAAC,CAAC,CAAC;IAC1E,CAAC;IAED;;;;;;OAMG;IACK,SAAS,CAAC,EAAU;QACxB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;;;;;OAUG;IACH,cAAc,CAAC,OAAoB;QAC/B,IAAI,CAAC,OAAO,EAAE;YACV,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;SAC7D;QACD,OAAO,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAC3C,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,EAAsB;QACnC,IAAI,EAAE,IAAI,YAAY,IAAI,EAAE,EAAE;YAC1B,OAAO,EAAE,CAAC,UAA+B,CAAC;SAC7C;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;OAQG;IACH,qBAAqB,CAAC,EAAsB;QACxC,IAAI,EAAE,IAAI,YAAY,IAAI,EAAE,EAAE;YAC1B,MAAM,MAAM,GAAG,EAAE,CAAC,UAA+B,CAAC;YAClD,MAAM,YAAY,GAAG,MAAM,CAAC,UAAqB,CAAC;YAClD,OAAO,IAAI,CAAC,qBAAqB,CAAC,YAAY,CAAC,CAAC;SACnD;QACD,OAAO,EAAE,CAAC;IACd,CAAC;IAED;;;;;;;;;OASG;IACH,qBAAqB,CAAC,EAAsB;QACxC,MAAM,MAAM,GAAc,EAAE,CAAC;QAE7B,OAAO,EAAE,EAAE;YACP,IAAI,oBAAoB,IAAI,EAAE,EAAE;gBAC5B,MAAM,CAAC,IAAI,CAAC,EAAa,CAAC,CAAC;gBAC3B,EAAE,GAAI,EAAc,CAAC,kBAA6B,CAAC;aACtD;iBAAM;gBACH,MAAM;aACT;SACJ;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAED;;;;;;;;OAQG;IACH,yBAAyB,CAAC,EAA6B;QACnD,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,IAAI,OAAO,GAAgB,EAAU,CAAC;QAEtC,OAAO,OAAO,EAAE;YACZ,MAAM,CAAC,IAAI,CAAC,OAAkB,CAAC,CAAC;YAChC,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC;SACrC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAED;;;;;;;;;OASG;IACH,kBAAkB,CAAC,EAAW;QAC1B,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAc,CAAC;IAChD,CAAC;CACJ,CAAA;AA1UY,UAAU;IAIN,WAAA,MAAM,CAAC,QAAQ,CAAC,CAAA;GAJpB,UAAU,CA0UtB;SA1UY,UAAU","sourcesContent":["import {DOCUMENT} from '@angular/common';\r\nimport {Inject} from '@angular/core';\r\n\r\nimport {TAllEvents, TSelector, TTypeAppend} from './dom.interface';\r\n\r\n\r\n/**\r\n * Предоставляет методы для манипуляции DOM элементами\r\n *\r\n * Класс включает функционал для:\r\n * - Создания элементов\r\n * - Добавления и удаления элементов из DOM\r\n * - Поиска элементов с повторными попытками\r\n * - Навигации по DOM дереву\r\n * - Работы с data-атрибутами\r\n */\r\nexport class DomElement {\r\n\r\n    private _countGetElement = 0;\r\n\r\n    constructor(@Inject(DOCUMENT) public document: Document) {\r\n    }\r\n\r\n    /**\r\n     * Создает новый DOM элемент с указанным тегом и CSS классом\r\n     *\r\n     * @param tagName - HTML тег создаваемого элемента (div, span, button и т.д.)\r\n     * @param className - CSS класс для элемента (опционально)\r\n     * @returns Новый DOM элемент\r\n     *\r\n     * @example\r\n     * const div = worker.createElement('div', 'container');\r\n     * const span = worker.createElement('span');\r\n     */\r\n    createElement(tagName: string, className?: string): HTMLElement {\r\n        const element = this.document.createElement(tagName);\r\n        if (className) {\r\n            element.className = className;\r\n        }\r\n        return element;\r\n    }\r\n\r\n    /**\r\n     * Создает и добавляет новый HTML элемент в DOM\r\n     *\r\n     * @param parentElement - Родительский элемент, к которому будет добавлен новый\r\n     * @param newElement - HTML тег создаваемого элемента\r\n     * @param typeAppend - Способ добавления ('appendChild' или 'insertBefore')\r\n     * @param strInnerHTML - Внутреннее HTML содержимое (опционально)\r\n     * @param dataId - Значение для атрибута data-id (опционально)\r\n     * @param eventName - Тип события для добавления слушателя\r\n     * @param fn - Функция-обработчик события (опционально)\r\n     *\r\n     * @example\r\n     * worker.elementCreate(\r\n     *   this.document.body,\r\n     *   'button',\r\n     *   'appendChild',\r\n     *   'Click me',\r\n     *   123,\r\n     *   'click',\r\n     *   () => console.log('Clicked')\r\n     * );\r\n     */\r\n    elementCreate(\r\n        parentElement: HTMLElement,\r\n        newElement: string,\r\n        typeAppend: TTypeAppend,\r\n        strInnerHTML: string = '',\r\n        dataId: number | string = '',\r\n        eventName: TAllEvents,\r\n        fn: ((event: Event, ...args: any[]) => void) | null = null\r\n    ): void {\r\n        if (!parentElement || !newElement) {\r\n            return;\r\n        }\r\n\r\n        const el$ = this.document.createElement(newElement);\r\n\r\n        if (dataId !== null) {\r\n            el$.setAttribute('data-id', String(dataId));\r\n        }\r\n\r\n        if (strInnerHTML) {\r\n            el$.innerHTML = strInnerHTML;\r\n        }\r\n\r\n        this.elementAdd(parentElement, typeAppend, dataId, eventName, fn, el$);\r\n    }\r\n\r\n    /**\r\n     * Добавляет существующий HTML элемент в DOM\r\n     *\r\n     * @param parentElement - Родительский элемент\r\n     * @param typeAppend - Способ добавления ('appendChild' или 'insertBefore')\r\n     * @param dataId - Идентификатор для атрибута data-id\r\n     * @param eventName - Тип события для слушателя\r\n     * @param fn - Функция-обработчик события\r\n     * @param el$ - Добавляемый DOM элемент\r\n     *\r\n     * @remarks\r\n     * Если typeAppend равен 'insertBefore', элемент добавляется в начало родителя.\r\n     * В противном случае элемент добавляется в конец.\r\n     */\r\n    elementAdd(\r\n        parentElement: HTMLElement,\r\n        typeAppend: TTypeAppend,\r\n        dataId: number | string,\r\n        eventName: TAllEvents,\r\n        fn: ((event: Event, ...args: any[]) => void) | null,\r\n        el$: HTMLElement\r\n    ): void {\r\n        if ('firstChild' in parentElement) {\r\n            if (typeAppend === 'insertBefore') {\r\n                (parentElement as Node).insertBefore(el$, parentElement.firstChild);\r\n            } else {\r\n                (parentElement as Node).appendChild(el$);\r\n            }\r\n        } else {\r\n            (parentElement as Node).appendChild(el$);\r\n        }\r\n\r\n        if (fn) {\r\n            el$.addEventListener(eventName, event => {\r\n                fn.call(null, event, null, el$, dataId);\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Удаляет HTML элемент из DOM\r\n     *\r\n     * @param parentElement - Родительский элемент, содержащий удаляемый элемент\r\n     * @param el$ - Удаляемый DOM элемент\r\n     *\r\n     * @remarks\r\n     * Метод безопасно завершается, если parentElement или el$ отсутствуют\r\n     */\r\n    elementRemove(parentElement: HTMLElement, el$: HTMLElement): void {\r\n        if (parentElement && el$) {\r\n            (parentElement as Node).removeChild(el$);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Асинхронно получает HTML элемент с повторными попытками\r\n     *\r\n     * @param identifier - Селектор для поиска элемента\r\n     * @param selector - Метод поиска ('querySelector' или 'querySelectorAll')\r\n     * @param node - DOM узел для поиска (по умолчанию this.document)\r\n     * @param time - Задержка между попытками в мс (по умолчанию 300)\r\n     * @param max - Максимальное количество попыток (по умолчанию 10)\r\n     * @returns Промис с найденным DOM элементом\r\n     *\r\n     * @remarks\r\n     * Метод полезен для ожидания появления динамически создаваемых элементов\r\n     */\r\n    async elementGet(\r\n        identifier: string,\r\n        selector: TSelector = 'querySelector',\r\n        node: Document | HTMLElement | null = this.document,\r\n        time: number = 300,\r\n        max: number = 10\r\n    ): Promise<HTMLElement> {\r\n        let result = await this._getElementResult(identifier, selector, node, time);\r\n\r\n        if ((!result || (result instanceof NodeList && result.length < 1)) && this._countGetElement < max) {\r\n            this._countGetElement++;\r\n            result = await this.elementGet(identifier, selector, node, time, max);\r\n        }\r\n\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Находит элементы по data-атрибуту или его значению\r\n     *\r\n     * @param elementToSelect - Название data-атрибута (например, 'data-id')\r\n     * @param dataValue - Значение атрибута для фильтрации (опционально)\r\n     * @returns Массив найденных элементов\r\n     * @throws {Error} Если elementToSelect не указан\r\n     *\r\n     * @example\r\n     * // Найти все элементы с data-id\r\n     * const items = worker.getElementByDataAttribute('data-id');\r\n     *\r\n     * // Найти элемент с конкретным значением\r\n     * const item = worker.getElementByDataAttribute('data-id', '123');\r\n     */\r\n    getElementByDataAttribute(elementToSelect: string, dataValue: string | null = null): HTMLElement[] {\r\n        if (!elementToSelect) {\r\n            throw new Error('elementToSelect is required for getElementByDataAttribute');\r\n        }\r\n        const selector = dataValue ? `[${elementToSelect}='${dataValue}']` : `[${elementToSelect}]`;\r\n        const elements = this.document.querySelectorAll(selector);\r\n        return Array.from(elements) as HTMLElement[];\r\n    }\r\n\r\n    /**\r\n     * Внутренний метод для получения элемента с задержкой\r\n     *\r\n     * @param identifier - Селектор элемента\r\n     * @param selector - Метод поиска\r\n     * @param node - Корневой узел\r\n     * @param time - Время задержки в мс\r\n     * @returns Промис с результатом поиска\r\n     * @private\r\n     */\r\n    private async _getElementResult(\r\n        identifier: string,\r\n        selector: TSelector,\r\n        node: Document | HTMLElement | null,\r\n        time: number\r\n    ): Promise<HTMLElement> {\r\n        return this._setDelay(time)\r\n            .then(_ => {\r\n                if (!node) {\r\n                    return null;\r\n                }\r\n                // Используем type assertion для вызова метода\r\n                const result = (node as any)[selector](identifier);\r\n                return result || null;\r\n            })\r\n            .catch(error => console.log('Ошибка в _getElementResult', error));\r\n    }\r\n\r\n    /**\r\n     * Создает Promise с задержкой\r\n     *\r\n     * @param ms - Время задержки в миллисекундах\r\n     * @returns Promise, который разрешается через указанное время\r\n     * @private\r\n     */\r\n    private _setDelay(ms: number): Promise<unknown> {\r\n        return new Promise(resolve => setTimeout(resolve, ms));\r\n    }\r\n\r\n    /**\r\n     * Возвращает размеры элемента и его положение относительно viewport\r\n     *\r\n     * @param element - Целевой DOM элемент\r\n     * @returns DOMRect объект с координатами (top, left, right, bottom) и размерами (width, height)\r\n     * @throws {Error} Если element не указан\r\n     *\r\n     * @example\r\n     * const rect = worker.getCoordinates(buttonElement);\r\n     * console.log(rect.top, rect.left, rect.width);\r\n     */\r\n    getCoordinates(element: HTMLElement): DOMRect {\r\n        if (!element) {\r\n            throw new Error('Element is required for getCoordinates');\r\n        }\r\n        return element.getBoundingClientRect();\r\n    }\r\n\r\n    /**\r\n     * Возвращает родительский элемент указанного DOM узла\r\n     *\r\n     * @param el - DOM элемент или NodeList\r\n     * @returns Родительский элемент или null, если родителя нет\r\n     */\r\n    elementGetParent(el: Element | NodeList): Node & ParentNode | null {\r\n        if (el && 'parentNode' in el) {\r\n            return el.parentNode as Node & ParentNode;\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    /**\r\n     * Возвращает все соседние элементы (включая сам элемент)\r\n     *\r\n     * @param el - Исходный DOM элемент\r\n     * @returns Массив всех элементов в текущей ветке DOM дерева\r\n     *\r\n     * @remarks\r\n     * Метод собирает все элементы на одном уровне вложенности\r\n     */\r\n    elementsGetSiblingAll(el: Element | NodeList): Element[] {\r\n        if (el && 'parentNode' in el) {\r\n            const parent = el.parentNode as Node & ParentNode;\r\n            const firstElement = parent.firstChild as Element;\r\n            return this.elementGetSiblingNext(firstElement);\r\n        }\r\n        return [];\r\n    }\r\n\r\n    /**\r\n     * Возвращает все следующие соседние элементы (nextElementSibling)\r\n     *\r\n     * @param el - Исходный DOM элемент\r\n     * @returns Массив элементов, начиная с указанного и включая все следующие\r\n     *\r\n     * @example\r\n     * const nextElements = worker.elementGetSiblingNext(currentElement);\r\n     * // Возвращает [currentElement, nextElement, nextNextElement, ...]\r\n     */\r\n    elementGetSiblingNext(el: Element | NodeList): Element[] {\r\n        const result: Element[] = [];\r\n\r\n        while (el) {\r\n            if ('nextElementSibling' in el) {\r\n                result.push(el as Element);\r\n                el = (el as Element).nextElementSibling as Element;\r\n            } else {\r\n                break;\r\n            }\r\n        }\r\n\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Возвращает все предыдущие соседние элементы (previousSibling)\r\n     *\r\n     * @param el - Исходный DOM элемент\r\n     * @returns Массив предыдущих элементов\r\n     *\r\n     * @remarks\r\n     * Возвращает все элементы, включая указанный, в обратном порядке\r\n     */\r\n    elementGetSiblingPrevious(el: Element | NodeList | Node): Element[] {\r\n        const result: Element[] = [];\r\n        let current: Node | null = el as Node;\r\n\r\n        while (current) {\r\n            result.push(current as Element);\r\n            current = current.previousSibling;\r\n        }\r\n\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Возвращает все прямые дочерние элементы указанного родителя\r\n     *\r\n     * @param el - Родительский DOM элемент\r\n     * @returns Массив дочерних элементов\r\n     *\r\n     * @example\r\n     * const children = worker.elementGetChildren(parentElement);\r\n     * children.forEach(child => console.log(child.tagName));\r\n     */\r\n    elementGetChildren(el: Element): Element[] {\r\n        return Array.from(el.children) as Element[];\r\n    }\r\n}\r\n"]}