@up_si_vale/sivale-componentes-angular 1.0.0 → 1.0.2

package/esm2022/lib/directives/asset-source.directive.mjs

@@ -0,0 +1,68 @@
+import { Directive, Input, Inject, Optional } from '@angular/core';
+import { ASSET_BASE_URL } from '../tokens/asset-base-url.token';
+import * as i0 from "@angular/core";
+export class AssetSourceDirective {
+    el;
+    assetBaseUrl;
+    assetSource = 'mf';
+    assetPath;
+    originalSrc = null;
+    constructor(el, assetBaseUrl) {
+        this.el = el;
+        this.assetBaseUrl = assetBaseUrl;
+    }
+    ngOnInit() {
+        this.captureOriginalSrc();
+    }
+    ngAfterViewInit() {
+        this.updateSrc();
+    }
+    ngOnChanges() {
+        this.updateSrc();
+    }
+    captureOriginalSrc() {
+        if (this.el.nativeElement.tagName === 'IMG') {
+            this.originalSrc = this.el.nativeElement.getAttribute('src');
+        }
+    }
+    updateSrc() {
+        const assetPath = this.assetPath || this.originalSrc;
+        if (!assetPath) {
+            return;
+        }
+        const baseUrl = this.getBaseUrl();
+        const fullPath = `${baseUrl}/${assetPath}`;
+        if (this.el.nativeElement.tagName === 'IMG') {
+            this.el.nativeElement.src = fullPath;
+        }
+    }
+    getBaseUrl() {
+        switch (this.assetSource) {
+            case 'mf':
+                return this.assetBaseUrl ?? '';
+            case 'main':
+                return '/assets';
+            default:
+                return this.assetBaseUrl ?? '';
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AssetSourceDirective, deps: [{ token: i0.ElementRef }, { token: ASSET_BASE_URL, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: AssetSourceDirective, isStandalone: true, selector: "[assetSource]", inputs: { assetSource: "assetSource", assetPath: "assetPath" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AssetSourceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[assetSource]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ASSET_BASE_URL]
+                }] }], propDecorators: { assetSource: [{
+                type: Input
+            }], assetPath: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/icon-source.directive.mjs

@@ -0,0 +1,65 @@
+import { Directive, Input, Inject, Optional } from '@angular/core';
+import { ASSET_BASE_URL } from '../tokens/asset-base-url.token';
+import * as i0 from "@angular/core";
+export class IconSourceDirective {
+    el;
+    assetBaseUrl;
+    iconName;
+    assetSource = 'mf';
+    constructor(el, assetBaseUrl) {
+        this.el = el;
+        this.assetBaseUrl = assetBaseUrl;
+    }
+    ngOnInit() {
+        this.addIconClass();
+    }
+    ngAfterViewInit() {
+        this.setIconUrl();
+    }
+    ngOnChanges() {
+        this.setIconUrl();
+    }
+    addIconClass() {
+        if (this.iconName) {
+            this.el.nativeElement.classList.add(`icon-${this.iconName}`);
+        }
+    }
+    setIconUrl() {
+        if (!this.iconName) {
+            return;
+        }
+        const baseUrl = this.getBaseUrl();
+        const iconUrl = `${baseUrl}/icons/${this.iconName}.svg`;
+        this.el.nativeElement.style.maskImage = `url('${iconUrl}')`;
+        this.el.nativeElement.style.webkitMaskImage = `url('${iconUrl}')`;
+    }
+    getBaseUrl() {
+        switch (this.assetSource) {
+            case 'mf':
+                return this.assetBaseUrl ?? '';
+            case 'main':
+                return '/assets';
+            default:
+                return this.assetBaseUrl ?? '';
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IconSourceDirective, deps: [{ token: i0.ElementRef }, { token: ASSET_BASE_URL, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: IconSourceDirective, isStandalone: true, selector: "i[iconName]", inputs: { iconName: "iconName", assetSource: "assetSource" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IconSourceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'i[iconName]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ASSET_BASE_URL]
+                }] }], propDecorators: { iconName: [{
+                type: Input
+            }], assetSource: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/no-leading-space.directive.mjs

@@ -0,0 +1,24 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NoLeadingSpaceDirective {
+    onInput(event) {
+        const value = event.target.value;
+        // Elimina espacios al inicio
+        if (value.startsWith(' ')) {
+            event.target.value = value.trimStart();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NoLeadingSpaceDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: NoLeadingSpaceDirective, isStandalone: true, selector: "[noLeadingSpace]", host: { listeners: { "input": "onInput($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NoLeadingSpaceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[noLeadingSpace]',
+                    standalone: true
+                }]
+        }], propDecorators: { onInput: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm8tbGVhZGluZy1zcGFjZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2RpcmVjdGl2ZXMvbm8tbGVhZGluZy1zcGFjZS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTXhELE1BQU0sT0FBTyx1QkFBdUI7SUFHbEMsT0FBTyxDQUFDLEtBQVU7UUFDaEIsTUFBTSxLQUFLLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUM7UUFFakMsNkJBQTZCO1FBQzdCLElBQUksS0FBSyxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO1lBQzFCLEtBQUssQ0FBQyxNQUFNLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQyxTQUFTLEVBQUUsQ0FBQztRQUN6QyxDQUFDO0lBQ0gsQ0FBQzt3R0FWVSx1QkFBdUI7NEZBQXZCLHVCQUF1Qjs7NEZBQXZCLHVCQUF1QjtrQkFKbkMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsa0JBQWtCO29CQUM1QixVQUFVLEVBQUUsSUFBSTtpQkFDakI7OEJBSUMsT0FBTztzQkFETixZQUFZO3VCQUFDLE9BQU8sRUFBRSxDQUFDLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSG9zdExpc3RlbmVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tub0xlYWRpbmdTcGFjZV0nLFxuICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIE5vTGVhZGluZ1NwYWNlRGlyZWN0aXZlIHtcblxuICBASG9zdExpc3RlbmVyKCdpbnB1dCcsIFsnJGV2ZW50J10pXG4gIG9uSW5wdXQoZXZlbnQ6IGFueSkge1xuICAgIGNvbnN0IHZhbHVlID0gZXZlbnQudGFyZ2V0LnZhbHVlO1xuXG4gICAgLy8gRWxpbWluYSBlc3BhY2lvcyBhbCBpbmljaW9cbiAgICBpZiAodmFsdWUuc3RhcnRzV2l0aCgnICcpKSB7XG4gICAgICBldmVudC50YXJnZXQudmFsdWUgPSB2YWx1ZS50cmltU3RhcnQoKTtcbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/directives/only-letters.directive.mjs

@@ -0,0 +1,25 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+export class OnlyLettersDirective {
+    regex = /^[A-Za-zÁÉÍÓÚÜÑáéíóúüñ' -]*$/;
+    onInput(event) {
+        const value = event.target.value;
+        event.target.value = value
+            .split('')
+            .filter(char => this.regex.test(char))
+            .join('');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OnlyLettersDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: OnlyLettersDirective, isStandalone: true, selector: "[onlyLetters]", host: { listeners: { "input": "onInput($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OnlyLettersDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[onlyLetters]',
+                    standalone: true
+                }]
+        }], propDecorators: { onInput: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25seS1sZXR0ZXJzLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvZGlyZWN0aXZlcy9vbmx5LWxldHRlcnMuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU94RCxNQUFNLE9BQU8sb0JBQW9CO0lBRXZCLEtBQUssR0FBRyw4QkFBOEIsQ0FBQztJQUcvQyxPQUFPLENBQUMsS0FBVTtRQUNoQixNQUFNLEtBQUssR0FBVyxLQUFLLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQztRQUV6QyxLQUFLLENBQUMsTUFBTSxDQUFDLEtBQUssR0FBRyxLQUFLO2FBQ3ZCLEtBQUssQ0FBQyxFQUFFLENBQUM7YUFDVCxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQzthQUNyQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDZCxDQUFDO3dHQVpVLG9CQUFvQjs0RkFBcEIsb0JBQW9COzs0RkFBcEIsb0JBQW9CO2tCQUxoQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxlQUFlO29CQUN6QixVQUFVLEVBQUUsSUFBSTtpQkFDakI7OEJBT0MsT0FBTztzQkFETixZQUFZO3VCQUFDLE9BQU8sRUFBRSxDQUFDLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSG9zdExpc3RlbmVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tvbmx5TGV0dGVyc10nLFxuICBzdGFuZGFsb25lOiB0cnVlXG59KVxuXG5leHBvcnQgY2xhc3MgT25seUxldHRlcnNEaXJlY3RpdmUge1xuXG4gIHByaXZhdGUgcmVnZXggPSAvXltBLVphLXrDgcOJw43Dk8Oaw5zDkcOhw6nDrcOzw7rDvMOxJyAtXSokLztcblxuICBASG9zdExpc3RlbmVyKCdpbnB1dCcsIFsnJGV2ZW50J10pXG4gIG9uSW5wdXQoZXZlbnQ6IGFueSkge1xuICAgIGNvbnN0IHZhbHVlOiBzdHJpbmcgPSBldmVudC50YXJnZXQudmFsdWU7XG5cbiAgICBldmVudC50YXJnZXQudmFsdWUgPSB2YWx1ZVxuICAgICAgLnNwbGl0KCcnKVxuICAgICAgLmZpbHRlcihjaGFyID0+IHRoaXMucmVnZXgudGVzdChjaGFyKSlcbiAgICAgIC5qb2luKCcnKTtcbiAgfVxufVxuIl19

package/esm2022/lib/directives/only-number.directive.mjs

@@ -0,0 +1,21 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+export class OnlyNumberDirective {
+    onInput(event) {
+        const value = event.target.value;
+        event.target.value = value.replace(/\D/g, '');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OnlyNumberDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: OnlyNumberDirective, isStandalone: true, selector: "[onlyNumber]", host: { listeners: { "input": "onInput($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OnlyNumberDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[onlyNumber]',
+                    standalone: true
+                }]
+        }], propDecorators: { onInput: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25seS1udW1iZXIuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9kaXJlY3RpdmVzL29ubHktbnVtYmVyLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFPeEQsTUFBTSxPQUFPLG1CQUFtQjtJQUU5QixPQUFPLENBQUMsS0FBVTtRQUNoQixNQUFNLEtBQUssR0FBRyxLQUFLLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQztRQUNqQyxLQUFLLENBQUMsTUFBTSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsQ0FBQztJQUNoRCxDQUFDO3dHQUxVLG1CQUFtQjs0RkFBbkIsbUJBQW1COzs0RkFBbkIsbUJBQW1CO2tCQUwvQixTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxjQUFjO29CQUN4QixVQUFVLEVBQUUsSUFBSTtpQkFDakI7OEJBSUMsT0FBTztzQkFETixZQUFZO3VCQUFDLE9BQU8sRUFBRSxDQUFDLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSG9zdExpc3RlbmVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tvbmx5TnVtYmVyXScsXG4gIHN0YW5kYWxvbmU6IHRydWVcbn0pXG5cbmV4cG9ydCBjbGFzcyBPbmx5TnVtYmVyRGlyZWN0aXZlIHtcbiAgQEhvc3RMaXN0ZW5lcignaW5wdXQnLCBbJyRldmVudCddKVxuICBvbklucHV0KGV2ZW50OiBhbnkpIHtcbiAgICBjb25zdCB2YWx1ZSA9IGV2ZW50LnRhcmdldC52YWx1ZTtcbiAgICBldmVudC50YXJnZXQudmFsdWUgPSB2YWx1ZS5yZXBsYWNlKC9cXEQvZywgJycpO1xuICB9XG5cbn1cbiJdfQ==

package/esm2022/lib/directives/rfc.directive.mjs

@@ -0,0 +1,67 @@
+import { Directive, HostListener, Input, Optional, Self } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class RfcDirective {
+    ngControl;
+    tipoContribuyente = null;
+    constructor(ngControl) {
+        this.ngControl = ngControl;
+    }
+    // Función para obtener el límite según el tipo de contribuyente
+    getMaxLength() {
+        if (this.tipoContribuyente === 'fisica')
+            return 13;
+        if (this.tipoContribuyente === 'moral')
+            return 12;
+        return 13; // Default por si no llega el valor
+    }
+    onInput(event) {
+        const input = event.target;
+        let value = input.value;
+        // Solo letras y números
+        value = value.replace(/[^a-zA-Z0-9]/g, '');
+        // Mayúsculas
+        value = value.toUpperCase();
+        // Aplicar límite dinámico
+        const max = this.getMaxLength();
+        if (value.length > max) {
+            value = value.substring(0, max);
+        }
+        this.ngControl?.control?.setValue(value, { emitEvent: false });
+    }
+    onPaste(event) {
+        const pasted = event.clipboardData?.getData('text') || '';
+        const max = this.getMaxLength();
+        // Bloquear pegado con caracteres inválidos
+        if (/[^a-zA-Z0-9]/.test(pasted)) {
+            event.preventDefault();
+            return;
+        }
+        // Bloquear pegado si excede el máximo
+        if (pasted.length > max) {
+            event.preventDefault();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RfcDirective, deps: [{ token: i1.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: RfcDirective, isStandalone: true, selector: "[rfcValidator]", inputs: { tipoContribuyente: "tipoContribuyente" }, host: { listeners: { "input": "onInput($event)", "paste": "onPaste($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RfcDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rfcValidator]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }], propDecorators: { tipoContribuyente: [{
+                type: Input
+            }], onInput: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }], onPaste: [{
+                type: HostListener,
+                args: ['paste', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/tooltip.directive.mjs

@@ -0,0 +1,199 @@
+import { Directive, Input, HostListener, HostBinding } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TooltipDirective {
+    el;
+    renderer;
+    tooltipText = '';
+    tooltipPosition = 'auto';
+    tooltipDelay = 300;
+    tooltipMaxWidth = 280;
+    tooltipClass = '';
+    cursor = 'help';
+    tooltipElement = null;
+    showTimeout;
+    hideTimeout;
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+    }
+    onMouseEnter() {
+        if (this.hideTimeout) {
+            clearTimeout(this.hideTimeout);
+            this.hideTimeout = undefined;
+        }
+        this.showTimeout = window.setTimeout(() => {
+            this.showTooltip();
+        }, this.tooltipDelay);
+    }
+    onMouseLeave() {
+        if (this.showTimeout) {
+            clearTimeout(this.showTimeout);
+            this.showTimeout = undefined;
+        }
+        this.hideTimeout = window.setTimeout(() => {
+            this.hideTooltip();
+        }, 100);
+    }
+    onClick() {
+        // Allow click events to propagate
+    }
+    showTooltip() {
+        if (!this.tooltipText || this.tooltipElement) {
+            return;
+        }
+        // Create tooltip element
+        this.tooltipElement = this.renderer.createElement('div');
+        this.renderer.addClass(this.tooltipElement, 'app-tooltip');
+        if (this.tooltipClass) {
+            this.renderer.addClass(this.tooltipElement, this.tooltipClass);
+        }
+        // Create tooltip content
+        const tooltipContent = this.renderer.createElement('div');
+        this.renderer.addClass(tooltipContent, 'app-tooltip-content');
+        this.renderer.setStyle(tooltipContent, 'max-width', `${this.tooltipMaxWidth}px`);
+        const textNode = this.renderer.createText(this.tooltipText);
+        this.renderer.appendChild(tooltipContent, textNode);
+        this.renderer.appendChild(this.tooltipElement, tooltipContent);
+        // Create arrow element
+        const arrow = this.renderer.createElement('div');
+        this.renderer.addClass(arrow, 'app-tooltip-arrow');
+        this.renderer.appendChild(this.tooltipElement, arrow);
+        // Add to body
+        this.renderer.appendChild(document.body, this.tooltipElement);
+        // Position tooltip
+        this.positionTooltip();
+        // Trigger animation
+        requestAnimationFrame(() => {
+            if (this.tooltipElement) {
+                this.renderer.addClass(this.tooltipElement, 'app-tooltip-show');
+            }
+        });
+    }
+    hideTooltip() {
+        if (!this.tooltipElement) {
+            return;
+        }
+        this.renderer.removeClass(this.tooltipElement, 'app-tooltip-show');
+        setTimeout(() => {
+            if (this.tooltipElement) {
+                this.renderer.removeChild(document.body, this.tooltipElement);
+                this.tooltipElement = null;
+            }
+        }, 200);
+    }
+    positionTooltip() {
+        if (!this.tooltipElement) {
+            return;
+        }
+        const hostRect = this.el.nativeElement.getBoundingClientRect();
+        const tooltipRect = this.tooltipElement.getBoundingClientRect();
+        const scrollX = window.scrollX || window.pageXOffset;
+        const scrollY = window.scrollY || window.pageYOffset;
+        const gap = 16; // Space between element and tooltip
+        // Calculate available space in each direction
+        const spaceTop = hostRect.top;
+        const spaceBottom = window.innerHeight - hostRect.bottom;
+        const spaceLeft = hostRect.left;
+        const spaceRight = window.innerWidth - hostRect.right;
+        let position = this.tooltipPosition;
+        let top = 0;
+        let left = 0;
+        // Auto-detect best position
+        if (position === 'auto') {
+            if (spaceTop >= tooltipRect.height + gap) {
+                position = 'top';
+            }
+            else if (spaceBottom >= tooltipRect.height + gap) {
+                position = 'bottom';
+            }
+            else if (spaceRight >= tooltipRect.width + gap) {
+                position = 'right';
+            }
+            else if (spaceLeft >= tooltipRect.width + gap) {
+                position = 'left';
+            }
+            else {
+                // Default to top if no space is sufficient
+                position = 'top';
+            }
+        }
+        // Calculate position based on detected/specified position
+        switch (position) {
+            case 'top':
+                top = hostRect.top + scrollY - tooltipRect.height - gap;
+                left = hostRect.left + scrollX + (hostRect.width / 2) - (tooltipRect.width / 2);
+                break;
+            case 'bottom':
+                top = hostRect.bottom + scrollY + gap;
+                left = hostRect.left + scrollX + (hostRect.width / 2) - (tooltipRect.width / 2);
+                break;
+            case 'left':
+                top = hostRect.top + scrollY + (hostRect.height / 2) - (tooltipRect.height / 2);
+                left = hostRect.left + scrollX - tooltipRect.width - gap;
+                break;
+            case 'right':
+                top = hostRect.top + scrollY + (hostRect.height / 2) - (tooltipRect.height / 2);
+                left = hostRect.right + scrollX + gap;
+                break;
+        }
+        // Adjust horizontal position to keep tooltip within viewport
+        if (position === 'top' || position === 'bottom') {
+            const minLeft = scrollX + 10;
+            const maxLeft = scrollX + window.innerWidth - tooltipRect.width - 10;
+            left = Math.max(minLeft, Math.min(left, maxLeft));
+        }
+        // Adjust vertical position to keep tooltip within viewport
+        if (position === 'left' || position === 'right') {
+            const minTop = scrollY + 10;
+            const maxTop = scrollY + window.innerHeight - tooltipRect.height - 10;
+            top = Math.max(minTop, Math.min(top, maxTop));
+        }
+        // Apply position
+        this.renderer.setStyle(this.tooltipElement, 'top', `${top}px`);
+        this.renderer.setStyle(this.tooltipElement, 'left', `${left}px`);
+        // Add position class for arrow styling
+        this.renderer.addClass(this.tooltipElement, `app-tooltip-${position}`);
+    }
+    ngOnDestroy() {
+        if (this.showTimeout) {
+            clearTimeout(this.showTimeout);
+        }
+        if (this.hideTimeout) {
+            clearTimeout(this.hideTimeout);
+        }
+        this.hideTooltip();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TooltipDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: TooltipDirective, isStandalone: true, selector: "[appTooltip]", inputs: { tooltipText: ["appTooltip", "tooltipText"], tooltipPosition: "tooltipPosition", tooltipDelay: "tooltipDelay", tooltipMaxWidth: "tooltipMaxWidth", tooltipClass: "tooltipClass" }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()", "click": "onClick()" }, properties: { "style.cursor": "this.cursor" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appTooltip]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { tooltipText: [{
+                type: Input,
+                args: ['appTooltip']
+            }], tooltipPosition: [{
+                type: Input
+            }], tooltipDelay: [{
+                type: Input
+            }], tooltipMaxWidth: [{
+                type: Input
+            }], tooltipClass: [{
+                type: Input
+            }], cursor: [{
+                type: HostBinding,
+                args: ['style.cursor']
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.directive.js","sourceRoot":"","sources":["../../../../src/lib/directives/tooltip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  Input,\n  ElementRef,\n  HostListener,\n  Renderer2,\n  OnDestroy,\n  HostBinding\n} from '@angular/core';\n\ntype TooltipPosition = 'top' | 'bottom' | 'left' | 'right' | 'auto';\n\n@Directive({\n  selector: '[appTooltip]',\n  standalone: true\n})\nexport class TooltipDirective implements OnDestroy {\n  @Input('appTooltip') tooltipText = '';\n  @Input() tooltipPosition: TooltipPosition = 'auto';\n  @Input() tooltipDelay = 300;\n  @Input() tooltipMaxWidth = 280;\n  @Input() tooltipClass = '';\n\n  @HostBinding('style.cursor') cursor = 'help';\n\n  private tooltipElement: HTMLElement | null = null;\n  private showTimeout?: number;\n  private hideTimeout?: number;\n\n  constructor(\n    private el: ElementRef,\n    private renderer: Renderer2\n  ) {}\n\n  @HostListener('mouseenter')\n  onMouseEnter(): void {\n    if (this.hideTimeout) {\n      clearTimeout(this.hideTimeout);\n      this.hideTimeout = undefined;\n    }\n\n    this.showTimeout = window.setTimeout(() => {\n      this.showTooltip();\n    }, this.tooltipDelay);\n  }\n\n  @HostListener('mouseleave')\n  onMouseLeave(): void {\n    if (this.showTimeout) {\n      clearTimeout(this.showTimeout);\n      this.showTimeout = undefined;\n    }\n\n    this.hideTimeout = window.setTimeout(() => {\n      this.hideTooltip();\n    }, 100);\n  }\n\n  @HostListener('click')\n  onClick(): void {\n    // Allow click events to propagate\n  }\n\n  private showTooltip(): void {\n    if (!this.tooltipText || this.tooltipElement) {\n      return;\n    }\n\n    // Create tooltip element\n    this.tooltipElement = this.renderer.createElement('div');\n    this.renderer.addClass(this.tooltipElement, 'app-tooltip');\n\n    if (this.tooltipClass) {\n      this.renderer.addClass(this.tooltipElement, this.tooltipClass);\n    }\n\n    // Create tooltip content\n    const tooltipContent = this.renderer.createElement('div');\n    this.renderer.addClass(tooltipContent, 'app-tooltip-content');\n    this.renderer.setStyle(tooltipContent, 'max-width', `${this.tooltipMaxWidth}px`);\n\n    const textNode = this.renderer.createText(this.tooltipText);\n    this.renderer.appendChild(tooltipContent, textNode);\n    this.renderer.appendChild(this.tooltipElement, tooltipContent);\n\n    // Create arrow element\n    const arrow = this.renderer.createElement('div');\n    this.renderer.addClass(arrow, 'app-tooltip-arrow');\n    this.renderer.appendChild(this.tooltipElement, arrow);\n\n    // Add to body\n    this.renderer.appendChild(document.body, this.tooltipElement);\n\n    // Position tooltip\n    this.positionTooltip();\n\n    // Trigger animation\n    requestAnimationFrame(() => {\n      if (this.tooltipElement) {\n        this.renderer.addClass(this.tooltipElement, 'app-tooltip-show');\n      }\n    });\n  }\n\n  private hideTooltip(): void {\n    if (!this.tooltipElement) {\n      return;\n    }\n\n    this.renderer.removeClass(this.tooltipElement, 'app-tooltip-show');\n\n    setTimeout(() => {\n      if (this.tooltipElement) {\n        this.renderer.removeChild(document.body, this.tooltipElement);\n        this.tooltipElement = null;\n      }\n    }, 200);\n  }\n\n  private positionTooltip(): void {\n    if (!this.tooltipElement) {\n      return;\n    }\n\n    const hostRect = this.el.nativeElement.getBoundingClientRect();\n    const tooltipRect = this.tooltipElement.getBoundingClientRect();\n    const scrollX = window.scrollX || window.pageXOffset;\n    const scrollY = window.scrollY || window.pageYOffset;\n    const gap = 16; // Space between element and tooltip\n\n    // Calculate available space in each direction\n    const spaceTop = hostRect.top;\n    const spaceBottom = window.innerHeight - hostRect.bottom;\n    const spaceLeft = hostRect.left;\n    const spaceRight = window.innerWidth - hostRect.right;\n\n    let position = this.tooltipPosition;\n    let top = 0;\n    let left = 0;\n\n    // Auto-detect best position\n    if (position === 'auto') {\n      if (spaceTop >= tooltipRect.height + gap) {\n        position = 'top';\n      } else if (spaceBottom >= tooltipRect.height + gap) {\n        position = 'bottom';\n      } else if (spaceRight >= tooltipRect.width + gap) {\n        position = 'right';\n      } else if (spaceLeft >= tooltipRect.width + gap) {\n        position = 'left';\n      } else {\n        // Default to top if no space is sufficient\n        position = 'top';\n      }\n    }\n\n    // Calculate position based on detected/specified position\n    switch (position) {\n      case 'top':\n        top = hostRect.top + scrollY - tooltipRect.height - gap;\n        left = hostRect.left + scrollX + (hostRect.width / 2) - (tooltipRect.width / 2);\n        break;\n\n      case 'bottom':\n        top = hostRect.bottom + scrollY + gap;\n        left = hostRect.left + scrollX + (hostRect.width / 2) - (tooltipRect.width / 2);\n        break;\n\n      case 'left':\n        top = hostRect.top + scrollY + (hostRect.height / 2) - (tooltipRect.height / 2);\n        left = hostRect.left + scrollX - tooltipRect.width - gap;\n        break;\n\n      case 'right':\n        top = hostRect.top + scrollY + (hostRect.height / 2) - (tooltipRect.height / 2);\n        left = hostRect.right + scrollX + gap;\n        break;\n    }\n\n    // Adjust horizontal position to keep tooltip within viewport\n    if (position === 'top' || position === 'bottom') {\n      const minLeft = scrollX + 10;\n      const maxLeft = scrollX + window.innerWidth - tooltipRect.width - 10;\n      left = Math.max(minLeft, Math.min(left, maxLeft));\n    }\n\n    // Adjust vertical position to keep tooltip within viewport\n    if (position === 'left' || position === 'right') {\n      const minTop = scrollY + 10;\n      const maxTop = scrollY + window.innerHeight - tooltipRect.height - 10;\n      top = Math.max(minTop, Math.min(top, maxTop));\n    }\n\n    // Apply position\n    this.renderer.setStyle(this.tooltipElement, 'top', `${top}px`);\n    this.renderer.setStyle(this.tooltipElement, 'left', `${left}px`);\n\n    // Add position class for arrow styling\n    this.renderer.addClass(this.tooltipElement, `app-tooltip-${position}`);\n  }\n\n  ngOnDestroy(): void {\n    if (this.showTimeout) {\n      clearTimeout(this.showTimeout);\n    }\n    if (this.hideTimeout) {\n      clearTimeout(this.hideTimeout);\n    }\n    this.hideTooltip();\n  }\n}\n"]}

package/esm2022/lib/models/snackbar.models.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic25hY2tiYXIubW9kZWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9tb2RlbHMvc25hY2tiYXIubW9kZWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBTbmFja2JhclR5cGUgPSAnc3VjY2VzcycgfCAnZXJyb3InIHwgJ3dhcm5pbmcnIHwgJ2luZm8nO1xuZXhwb3J0IHR5cGUgU25hY2tiYXJQb3NpdGlvbiA9ICd0b3AtcmlnaHQnIHwgJ3RvcC1sZWZ0JyB8ICd0b3AtY2VudGVyJyB8ICdib3R0b20tcmlnaHQnIHwgJ2JvdHRvbS1sZWZ0JyB8ICdib3R0b20tY2VudGVyJztcblxuZXhwb3J0IGludGVyZmFjZSBTbmFja2JhckNvbmZpZyB7XG4gIG1lc3NhZ2U6IHN0cmluZztcbiAgdHlwZTogU25hY2tiYXJUeXBlO1xuICBkdXJhdGlvbj86IG51bWJlcjtcbiAgcG9zaXRpb24/OiBTbmFja2JhclBvc2l0aW9uO1xuICBhY3Rpb24/OiBzdHJpbmc7XG4gIGFjdGlvbkNhbGxiYWNrPzogKCkgPT4gdm9pZDtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTbmFja2JhckRhdGEgZXh0ZW5kcyBTbmFja2JhckNvbmZpZyB7XG4gIGlkOiBzdHJpbmc7XG4gIHBvc2l0aW9uOiBTbmFja2JhclBvc2l0aW9uO1xufVxuIl19