ctt-babylon 0.8.6 → 0.8.7

package/esm2022/lib/directives/sliders/slick-init.directive.mjs

@@ -0,0 +1,211 @@
+import { isPlatformBrowser } from '@angular/common';
+import { Directive, Inject, PLATFORM_ID, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SlickInitDirective {
+    constructor(host, platformId) {
+        this.host = host;
+        this.platformId = platformId;
+    }
+    async ngAfterViewInit() {
+        if (!isPlatformBrowser(this.platformId))
+            return;
+        await this.waitForSlick(); // espera a $ y $.fn.slick
+        const parent = this.host.nativeElement;
+        const get = (name) => parent.getAttribute(name);
+        const getBool = (name) => {
+            const v = get(name);
+            return v === 'true' || v === '1' || v === '' || v === true;
+        };
+        const getNum = (name, def = 0) => {
+            const v = Number(get(name));
+            return Number.isFinite(v) ? v : def;
+        };
+        const sliderName = get('data-slider_name') || '';
+        const sliderSpeed = getNum('data-slider_speed', 750);
+        const showBtns = getBool('data-slider_showbtns');
+        const showDots = getBool('data-slider_showdots');
+        const fade = getBool('data-slider_fade');
+        const centerMode = getBool('data-slider_centermode');
+        const autoplay = getBool('data-slider_autoplay');
+        const slidesPc = getNum('data-slides_pc', 1);
+        const slidesLaptop = getNum('data-slides_laptop') || slidesPc;
+        const slidesTablet = getNum('data-slides_tablet') || slidesLaptop;
+        const slidesMobile = getNum('data-slides_mobile') || slidesTablet;
+        const slidesMobileSmall = getNum('data-slides_mobile_small') || slidesMobile;
+        const slidesMobileXSmall = getNum('data-slides_mobile_xsmall') || slidesMobileSmall;
+        const infinite = getBool('data-slides_infinite');
+        let rowsPc = getNum('data-slidesrows_pc', 1);
+        let rowsLaptop = getNum('data-slidesrows_laptop', 1);
+        let rowsTablet = getNum('data-slidesrows_tablet', 1);
+        let rowsMobile = getNum('data-slidesrows_mobile', 1);
+        let rowsMobileSmall = getNum('data-slidesrows_mobile_small', 1);
+        let rowsMobileXSmall = getNum('data-slidesrows_mobile_xsmall', 1);
+        const asNavFor = get('data-slider_asNavFor') || undefined;
+        const vertical = getBool('data-slider_vertical');
+        const adaptiveHeight = getBool('data-slider_adaptive_height');
+        const pause = getBool('data-slider_pause');
+        const draggable = getBool('data-slider_draggable');
+        const rtl = getBool('data-slider_rtl');
+        const variableWidth = getBool('data-slider_variable_width');
+        const btnsMode = get('data-slider_btns') || '';
+        if (window.innerWidth < 540 && parent.classList.contains('rows-2')) {
+            rowsPc = 1;
+        }
+        const sliderArrows = parent.querySelector('.js-slider-arrows');
+        const sliderDots = parent.querySelector('.js-slider-dots');
+        const sliderSelector = parent.querySelector('.' + sliderName);
+        if (!sliderSelector)
+            return;
+        this.sliderEl = sliderSelector;
+        if ($(sliderSelector).hasClass('slick-initialized'))
+            return;
+        let prevArrow = '';
+        let nextArrow = '';
+        if (btnsMode.includes('icon-small')) {
+            prevArrow +=
+                "<button type='button' class='slick-prev icon-small'><svg aria-hidden='true' focusable='false' class='line'><use href='/assets/babylon/svg/arrow-line.svg#arrow-line'></use></svg><svg aria-hidden='true' focusable='false'><use href='/assets/babylon/svg/icon-arrow.svg#icon-arrow'></use></svg></button>";
+            nextArrow +=
+                "<button type='button' class='slick-next icon-small'><svg aria-hidden='true' focusable='false' class='line'><use href='/assets/babylon/svg/arrow-line.svg#arrow-line'></use></svg><svg aria-hidden='true' focusable='false'><use href='/assets/babylon/svg/icon-arrow.svg#icon-arrow'></use></svg></button>";
+        }
+        if (btnsMode.includes('icon-large')) {
+            prevArrow +=
+                "<button type='button' class='slick-prev icon-large'><svg aria-hidden='true' focusable='false'><use href='/assets/babylon/svg/icon-arrow-large.svg#icon-arrow-large'></use></svg></button>";
+            nextArrow +=
+                "<button type='button' class='slick-next icon-large'><svg aria-hidden='true' focusable='false'><use href='/assets/babylon/svg/icon-arrow-large.svg#icon-arrow-large'></use></svg></button>";
+        }
+        // --- normalizar altura en vertical (sin 'this' implícito) ---
+        const updateVerticalHeight = () => {
+            const $el = $(sliderSelector);
+            if (window.innerWidth >= 541) {
+                let maxH = 0;
+                $el.find('.slick-slide:not(.slick-cloned)').each((_, el) => {
+                    const h = $(el).outerHeight();
+                    if (h > maxH)
+                        maxH = h;
+                });
+                $el.find('.slick-slide').each((_, el) => {
+                    $(el).css('height', `${maxH}px`);
+                });
+            }
+            else {
+                $(sliderSelector).find('.slick-slide').css('height', '');
+            }
+        };
+        if (vertical) {
+            $(sliderSelector).on('setPosition', updateVerticalHeight);
+            $(sliderSelector).on('init', () => setTimeout(updateVerticalHeight, 0));
+            this.resizeHandler = () => updateVerticalHeight();
+            window.addEventListener('resize', this.resizeHandler, {
+                passive: true,
+            });
+        }
+        // --- INIT SLICK ---
+        $(sliderSelector).slick({
+            dots: showDots,
+            arrows: showBtns,
+            appendArrows: sliderArrows || parent,
+            prevArrow,
+            nextArrow,
+            appendDots: sliderDots || parent,
+            infinite,
+            useTransform: true,
+            fade,
+            centerMode,
+            centerPadding: '0',
+            cssEase: 'cubic-bezier(0.785, 0.135, 0.15, 0.86)',
+            speed: sliderSpeed,
+            slidesToShow: slidesPc,
+            slidesToScroll: 1,
+            rows: rowsPc,
+            autoplay,
+            autoplaySpeed: 5000,
+            swipeToSlide: true,
+            vertical,
+            verticalSwiping: vertical,
+            adaptiveHeight,
+            asNavFor,
+            pauseOnFocus: pause,
+            pauseOnHover: pause,
+            draggable,
+            swipe: draggable,
+            rtl,
+            variableWidth,
+            responsive: [
+                {
+                    breakpoint: 1680,
+                    settings: { slidesToShow: slidesLaptop, rows: rowsLaptop },
+                },
+                {
+                    breakpoint: 1366,
+                    settings: { slidesToShow: slidesTablet, rows: rowsTablet },
+                },
+                {
+                    breakpoint: 1280,
+                    settings: { slidesToShow: slidesMobile, rows: rowsMobile },
+                },
+                {
+                    breakpoint: 1023,
+                    settings: {
+                        slidesToShow: slidesMobileSmall,
+                        rows: rowsMobileSmall,
+                    },
+                },
+                {
+                    breakpoint: 767,
+                    settings: {
+                        slidesToShow: slidesMobileXSmall,
+                        rows: rowsMobileXSmall,
+                        vertical: false,
+                        verticalSwiping: false,
+                    },
+                },
+            ],
+        });
+    }
+    ngOnDestroy() {
+        if (!isPlatformBrowser(this.platformId))
+            return;
+        if (this.sliderEl && $(this.sliderEl).hasClass('slick-initialized')) {
+            try {
+                $(this.sliderEl).slick('unslick');
+            }
+            catch {
+                /* nada */
+            }
+        }
+        if (this.resizeHandler) {
+            window.removeEventListener('resize', this.resizeHandler);
+        }
+    }
+    // Espera a $ y slick: resuelve (no rechaza) y loguea si no llegan
+    waitForSlick(timeoutMs = 4000, stepMs = 100) {
+        if (!isPlatformBrowser(this.platformId))
+            return Promise.resolve();
+        const start = performance.now();
+        return new Promise((resolve) => {
+            const check = () => {
+                if (typeof $ !== 'undefined' && $.fn && $.fn.slick)
+                    return resolve();
+                if (performance.now() - start > timeoutMs) {
+                    console.warn('[SlickInitDirective] Slick no disponible. ¿Cargaste jQuery y slick?');
+                    return resolve(); // evita error si no llega
+                }
+                setTimeout(check, stepMs);
+            };
+            check();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SlickInitDirective, deps: [{ token: i0.ElementRef }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: SlickInitDirective, isStandalone: true, selector: ".js-active-slider,[appSlickInit]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SlickInitDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '.js-active-slider,[appSlickInit]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slick-init.directive.js","sourceRoot":"","sources":["../../../../../../projects/babylon/src/lib/directives/sliders/slick-init.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAEH,SAAS,EAET,MAAM,EAEN,WAAW,GACd,MAAM,eAAe,CAAC;;AASvB,MAAM,OAAO,kBAAkB;IAI3B,YACY,IAA6B,EACR,UAAkB;QADvC,SAAI,GAAJ,IAAI,CAAyB;QACR,eAAU,GAAV,UAAU,CAAQ;IAChD,CAAC;IAEJ,KAAK,CAAC,eAAe;QACjB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC;YAAE,OAAO;QAChD,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,0BAA0B;QAErD,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;QACvC,MAAM,GAAG,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACxD,MAAM,OAAO,GAAG,CAAC,IAAY,EAAE,EAAE;YAC7B,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;YACpB,OAAO,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,IAAK,CAAS,KAAK,IAAI,CAAC;QACxE,CAAC,CAAC;QACF,MAAM,MAAM,GAAG,CAAC,IAAY,EAAE,GAAG,GAAG,CAAC,EAAE,EAAE;YACrC,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;YAC5B,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;QACxC,CAAC,CAAC;QAEF,MAAM,UAAU,GAAG,GAAG,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC;QACjD,MAAM,WAAW,GAAG,MAAM,CAAC,mBAAmB,EAAE,GAAG,CAAC,CAAC;QACrD,MAAM,QAAQ,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;QACjD,MAAM,QAAQ,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;QACjD,MAAM,IAAI,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;QACzC,MAAM,UAAU,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;QACrD,MAAM,QAAQ,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;QACjD,MAAM,QAAQ,GAAG,MAAM,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC;QAC7C,MAAM,YAAY,GAAG,MAAM,CAAC,oBAAoB,CAAC,IAAI,QAAQ,CAAC;QAC9D,MAAM,YAAY,GAAG,MAAM,CAAC,oBAAoB,CAAC,IAAI,YAAY,CAAC;QAClE,MAAM,YAAY,GAAG,MAAM,CAAC,oBAAoB,CAAC,IAAI,YAAY,CAAC;QAClE,MAAM,iBAAiB,GACnB,MAAM,CAAC,0BAA0B,CAAC,IAAI,YAAY,CAAC;QACvD,MAAM,kBAAkB,GACpB,MAAM,CAAC,2BAA2B,CAAC,IAAI,iBAAiB,CAAC;QAC7D,MAAM,QAAQ,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;QAEjD,IAAI,MAAM,GAAG,MAAM,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC;QAC7C,IAAI,UAAU,GAAG,MAAM,CAAC,wBAAwB,EAAE,CAAC,CAAC,CAAC;QACrD,IAAI,UAAU,GAAG,MAAM,CAAC,wBAAwB,EAAE,CAAC,CAAC,CAAC;QACrD,IAAI,UAAU,GAAG,MAAM,CAAC,wBAAwB,EAAE,CAAC,CAAC,CAAC;QACrD,IAAI,eAAe,GAAG,MAAM,CAAC,8BAA8B,EAAE,CAAC,CAAC,CAAC;QAChE,IAAI,gBAAgB,GAAG,MAAM,CAAC,+BAA+B,EAAE,CAAC,CAAC,CAAC;QAElE,MAAM,QAAQ,GAAG,GAAG,CAAC,sBAAsB,CAAC,IAAI,SAAS,CAAC;QAC1D,MAAM,QAAQ,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;QACjD,MAAM,cAAc,GAAG,OAAO,CAAC,6BAA6B,CAAC,CAAC;QAC9D,MAAM,KAAK,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;QAC3C,MAAM,SAAS,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;QACnD,MAAM,GAAG,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;QACvC,MAAM,aAAa,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;QAC5D,MAAM,QAAQ,GAAG,GAAG,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC;QAE/C,IAAI,MAAM,CAAC,UAAU,GAAG,GAAG,IAAI,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;YAChE,MAAM,GAAG,CAAC,CAAC;SACd;QAED,MAAM,YAAY,GAAG,MAAM,CAAC,aAAa,CACrC,mBAAmB,CACA,CAAC;QACxB,MAAM,UAAU,GAAG,MAAM,CAAC,aAAa,CACnC,iBAAiB,CACE,CAAC;QACxB,MAAM,cAAc,GAAG,MAAM,CAAC,aAAa,CACvC,GAAG,GAAG,UAAU,CACG,CAAC;QACxB,IAAI,CAAC,cAAc;YAAE,OAAO;QAC5B,IAAI,CAAC,QAAQ,GAAG,cAAc,CAAC;QAE/B,IAAI,CAAC,CAAC,cAAc,CAAC,CAAC,QAAQ,CAAC,mBAAmB,CAAC;YAAE,OAAO;QAE5D,IAAI,SAAS,GAAG,EAAE,CAAC;QACnB,IAAI,SAAS,GAAG,EAAE,CAAC;QACnB,IAAI,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE;YACjC,SAAS;gBACL,4SAA4S,CAAC;YACjT,SAAS;gBACL,4SAA4S,CAAC;SACpT;QACD,IAAI,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE;YACjC,SAAS;gBACL,2LAA2L,CAAC;YAChM,SAAS;gBACL,2LAA2L,CAAC;SACnM;QAED,+DAA+D;QAC/D,MAAM,oBAAoB,GAAG,GAAG,EAAE;YAC9B,MAAM,GAAG,GAAG,CAAC,CAAC,cAAc,CAAC,CAAC;YAC9B,IAAI,MAAM,CAAC,UAAU,IAAI,GAAG,EAAE;gBAC1B,IAAI,IAAI,GAAG,CAAC,CAAC;gBACb,GAAG,CAAC,IAAI,CAAC,iCAAiC,CAAC,CAAC,IAAI,CAC5C,CAAC,CAAS,EAAE,EAAe,EAAE,EAAE;oBAC3B,MAAM,CAAC,GAAI,CAAC,CAAC,EAAE,CAAS,CAAC,WAAW,EAAE,CAAC;oBACvC,IAAI,CAAC,GAAG,IAAI;wBAAE,IAAI,GAAG,CAAC,CAAC;gBAC3B,CAAC,CACJ,CAAC;gBACF,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC,CAAS,EAAE,EAAe,EAAE,EAAE;oBACxD,CAAC,CAAC,EAAE,CAAS,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,IAAI,IAAI,CAAC,CAAC;gBAC9C,CAAC,CAAC,CAAC;aACN;iBAAM;gBACH,CAAC,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;aAC5D;QACL,CAAC,CAAC;QAEF,IAAI,QAAQ,EAAE;YACV,CAAC,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,aAAa,EAAE,oBAAoB,CAAC,CAAC;YAC1D,CAAC,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,CAC9B,UAAU,CAAC,oBAAoB,EAAE,CAAC,CAAC,CACtC,CAAC;YACF,IAAI,CAAC,aAAa,GAAG,GAAG,EAAE,CAAC,oBAAoB,EAAE,CAAC;YAClD,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,EAAE;gBAClD,OAAO,EAAE,IAAI;aAChB,CAAC,CAAC;SACN;QAED,qBAAqB;QACrB,CAAC,CAAC,cAAc,CAAC,CAAC,KAAK,CAAC;YACpB,IAAI,EAAE,QAAQ;YACd,MAAM,EAAE,QAAQ;YAChB,YAAY,EAAE,YAAY,IAAI,MAAM;YACpC,SAAS;YACT,SAAS;YACT,UAAU,EAAE,UAAU,IAAI,MAAM;YAChC,QAAQ;YACR,YAAY,EAAE,IAAI;YAClB,IAAI;YACJ,UAAU;YACV,aAAa,EAAE,GAAG;YAClB,OAAO,EAAE,wCAAwC;YACjD,KAAK,EAAE,WAAW;YAClB,YAAY,EAAE,QAAQ;YACtB,cAAc,EAAE,CAAC;YACjB,IAAI,EAAE,MAAM;YACZ,QAAQ;YACR,aAAa,EAAE,IAAI;YACnB,YAAY,EAAE,IAAI;YAClB,QAAQ;YACR,eAAe,EAAE,QAAQ;YACzB,cAAc;YACd,QAAQ;YACR,YAAY,EAAE,KAAK;YACnB,YAAY,EAAE,KAAK;YACnB,SAAS;YACT,KAAK,EAAE,SAAS;YAChB,GAAG;YACH,aAAa;YACb,UAAU,EAAE;gBACR;oBACI,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,EAAE;iBAC7D;gBACD;oBACI,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,EAAE;iBAC7D;gBACD;oBACI,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,EAAE;iBAC7D;gBACD;oBACI,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;wBACN,YAAY,EAAE,iBAAiB;wBAC/B,IAAI,EAAE,eAAe;qBACxB;iBACJ;gBACD;oBACI,UAAU,EAAE,GAAG;oBACf,QAAQ,EAAE;wBACN,YAAY,EAAE,kBAAkB;wBAChC,IAAI,EAAE,gBAAgB;wBACtB,QAAQ,EAAE,KAAK;wBACf,eAAe,EAAE,KAAK;qBACzB;iBACJ;aACJ;SACJ,CAAC,CAAC;IACP,CAAC;IAED,WAAW;QACP,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC;YAAE,OAAO;QAChD,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,mBAAmB,CAAC,EAAE;YACjE,IAAI;gBACA,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;aACrC;YAAC,MAAM;gBACJ,UAAU;aACb;SACJ;QACD,IAAI,IAAI,CAAC,aAAa,EAAE;YACpB,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;SAC5D;IACL,CAAC;IAED,kEAAkE;IAC1D,YAAY,CAAC,SAAS,GAAG,IAAI,EAAE,MAAM,GAAG,GAAG;QAC/C,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC;YAAE,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;QAClE,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAChC,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YACjC,MAAM,KAAK,GAAG,GAAG,EAAE;gBACf,IAAI,OAAO,CAAC,KAAK,WAAW,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK;oBAC9C,OAAO,OAAO,EAAE,CAAC;gBACrB,IAAI,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,SAAS,EAAE;oBACvC,OAAO,CAAC,IAAI,CACR,qEAAqE,CACxE,CAAC;oBACF,OAAO,OAAO,EAAE,CAAC,CAAC,0BAA0B;iBAC/C;gBACD,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YAC9B,CAAC,CAAC;YACF,KAAK,EAAE,CAAC;QACZ,CAAC,CAAC,CAAC;IACP,CAAC;+GAxNQ,kBAAkB,4CAMf,WAAW;mGANd,kBAAkB;;4FAAlB,kBAAkB;kBAJ9B,SAAS;mBAAC;oBACP,QAAQ,EAAE,kCAAkC;oBAC5C,UAAU,EAAE,IAAI;iBACnB;;0BAOQ,MAAM;2BAAC,WAAW","sourcesContent":["import { isPlatformBrowser } from '@angular/common';\nimport {\n    AfterViewInit,\n    Directive,\n    ElementRef,\n    Inject,\n    OnDestroy,\n    PLATFORM_ID,\n} from '@angular/core';\n\n// Si no tienes @types/jquery, déjalo como any\ndeclare const $: any;\n\n@Directive({\n    selector: '.js-active-slider,[appSlickInit]',\n    standalone: true,\n})\nexport class SlickInitDirective implements AfterViewInit, OnDestroy {\n    private resizeHandler?: () => void;\n    private sliderEl?: HTMLElement;\n\n    constructor(\n        private host: ElementRef<HTMLElement>,\n        @Inject(PLATFORM_ID) private platformId: object\n    ) {}\n\n    async ngAfterViewInit(): Promise<void> {\n        if (!isPlatformBrowser(this.platformId)) return;\n        await this.waitForSlick(); // espera a $ y $.fn.slick\n\n        const parent = this.host.nativeElement;\n        const get = (name: string) => parent.getAttribute(name);\n        const getBool = (name: string) => {\n            const v = get(name);\n            return v === 'true' || v === '1' || v === '' || (v as any) === true;\n        };\n        const getNum = (name: string, def = 0) => {\n            const v = Number(get(name));\n            return Number.isFinite(v) ? v : def;\n        };\n\n        const sliderName = get('data-slider_name') || '';\n        const sliderSpeed = getNum('data-slider_speed', 750);\n        const showBtns = getBool('data-slider_showbtns');\n        const showDots = getBool('data-slider_showdots');\n        const fade = getBool('data-slider_fade');\n        const centerMode = getBool('data-slider_centermode');\n        const autoplay = getBool('data-slider_autoplay');\n        const slidesPc = getNum('data-slides_pc', 1);\n        const slidesLaptop = getNum('data-slides_laptop') || slidesPc;\n        const slidesTablet = getNum('data-slides_tablet') || slidesLaptop;\n        const slidesMobile = getNum('data-slides_mobile') || slidesTablet;\n        const slidesMobileSmall =\n            getNum('data-slides_mobile_small') || slidesMobile;\n        const slidesMobileXSmall =\n            getNum('data-slides_mobile_xsmall') || slidesMobileSmall;\n        const infinite = getBool('data-slides_infinite');\n\n        let rowsPc = getNum('data-slidesrows_pc', 1);\n        let rowsLaptop = getNum('data-slidesrows_laptop', 1);\n        let rowsTablet = getNum('data-slidesrows_tablet', 1);\n        let rowsMobile = getNum('data-slidesrows_mobile', 1);\n        let rowsMobileSmall = getNum('data-slidesrows_mobile_small', 1);\n        let rowsMobileXSmall = getNum('data-slidesrows_mobile_xsmall', 1);\n\n        const asNavFor = get('data-slider_asNavFor') || undefined;\n        const vertical = getBool('data-slider_vertical');\n        const adaptiveHeight = getBool('data-slider_adaptive_height');\n        const pause = getBool('data-slider_pause');\n        const draggable = getBool('data-slider_draggable');\n        const rtl = getBool('data-slider_rtl');\n        const variableWidth = getBool('data-slider_variable_width');\n        const btnsMode = get('data-slider_btns') || '';\n\n        if (window.innerWidth < 540 && parent.classList.contains('rows-2')) {\n            rowsPc = 1;\n        }\n\n        const sliderArrows = parent.querySelector(\n            '.js-slider-arrows'\n        ) as HTMLElement | null;\n        const sliderDots = parent.querySelector(\n            '.js-slider-dots'\n        ) as HTMLElement | null;\n        const sliderSelector = parent.querySelector(\n            '.' + sliderName\n        ) as HTMLElement | null;\n        if (!sliderSelector) return;\n        this.sliderEl = sliderSelector;\n\n        if ($(sliderSelector).hasClass('slick-initialized')) return;\n\n        let prevArrow = '';\n        let nextArrow = '';\n        if (btnsMode.includes('icon-small')) {\n            prevArrow +=\n                \"<button type='button' class='slick-prev icon-small'><svg aria-hidden='true' focusable='false' class='line'><use href='/assets/babylon/svg/arrow-line.svg#arrow-line'></use></svg><svg aria-hidden='true' focusable='false'><use href='/assets/babylon/svg/icon-arrow.svg#icon-arrow'></use></svg></button>\";\n            nextArrow +=\n                \"<button type='button' class='slick-next icon-small'><svg aria-hidden='true' focusable='false' class='line'><use href='/assets/babylon/svg/arrow-line.svg#arrow-line'></use></svg><svg aria-hidden='true' focusable='false'><use href='/assets/babylon/svg/icon-arrow.svg#icon-arrow'></use></svg></button>\";\n        }\n        if (btnsMode.includes('icon-large')) {\n            prevArrow +=\n                \"<button type='button' class='slick-prev icon-large'><svg aria-hidden='true' focusable='false'><use href='/assets/babylon/svg/icon-arrow-large.svg#icon-arrow-large'></use></svg></button>\";\n            nextArrow +=\n                \"<button type='button' class='slick-next icon-large'><svg aria-hidden='true' focusable='false'><use href='/assets/babylon/svg/icon-arrow-large.svg#icon-arrow-large'></use></svg></button>\";\n        }\n\n        // --- normalizar altura en vertical (sin 'this' implícito) ---\n        const updateVerticalHeight = () => {\n            const $el = $(sliderSelector);\n            if (window.innerWidth >= 541) {\n                let maxH = 0;\n                $el.find('.slick-slide:not(.slick-cloned)').each(\n                    (_: number, el: HTMLElement) => {\n                        const h = ($(el) as any).outerHeight();\n                        if (h > maxH) maxH = h;\n                    }\n                );\n                $el.find('.slick-slide').each((_: number, el: HTMLElement) => {\n                    ($(el) as any).css('height', `${maxH}px`);\n                });\n            } else {\n                $(sliderSelector).find('.slick-slide').css('height', '');\n            }\n        };\n\n        if (vertical) {\n            $(sliderSelector).on('setPosition', updateVerticalHeight);\n            $(sliderSelector).on('init', () =>\n                setTimeout(updateVerticalHeight, 0)\n            );\n            this.resizeHandler = () => updateVerticalHeight();\n            window.addEventListener('resize', this.resizeHandler, {\n                passive: true,\n            });\n        }\n\n        // --- INIT SLICK ---\n        $(sliderSelector).slick({\n            dots: showDots,\n            arrows: showBtns,\n            appendArrows: sliderArrows || parent,\n            prevArrow,\n            nextArrow,\n            appendDots: sliderDots || parent,\n            infinite,\n            useTransform: true,\n            fade,\n            centerMode,\n            centerPadding: '0',\n            cssEase: 'cubic-bezier(0.785, 0.135, 0.15, 0.86)',\n            speed: sliderSpeed,\n            slidesToShow: slidesPc,\n            slidesToScroll: 1,\n            rows: rowsPc,\n            autoplay,\n            autoplaySpeed: 5000,\n            swipeToSlide: true,\n            vertical,\n            verticalSwiping: vertical,\n            adaptiveHeight,\n            asNavFor,\n            pauseOnFocus: pause,\n            pauseOnHover: pause,\n            draggable,\n            swipe: draggable,\n            rtl,\n            variableWidth,\n            responsive: [\n                {\n                    breakpoint: 1680,\n                    settings: { slidesToShow: slidesLaptop, rows: rowsLaptop },\n                },\n                {\n                    breakpoint: 1366,\n                    settings: { slidesToShow: slidesTablet, rows: rowsTablet },\n                },\n                {\n                    breakpoint: 1280,\n                    settings: { slidesToShow: slidesMobile, rows: rowsMobile },\n                },\n                {\n                    breakpoint: 1023,\n                    settings: {\n                        slidesToShow: slidesMobileSmall,\n                        rows: rowsMobileSmall,\n                    },\n                },\n                {\n                    breakpoint: 767,\n                    settings: {\n                        slidesToShow: slidesMobileXSmall,\n                        rows: rowsMobileXSmall,\n                        vertical: false,\n                        verticalSwiping: false,\n                    },\n                },\n            ],\n        });\n    }\n\n    ngOnDestroy(): void {\n        if (!isPlatformBrowser(this.platformId)) return;\n        if (this.sliderEl && $(this.sliderEl).hasClass('slick-initialized')) {\n            try {\n                $(this.sliderEl).slick('unslick');\n            } catch {\n                /* nada */\n            }\n        }\n        if (this.resizeHandler) {\n            window.removeEventListener('resize', this.resizeHandler);\n        }\n    }\n\n    // Espera a $ y slick: resuelve (no rechaza) y loguea si no llegan\n    private waitForSlick(timeoutMs = 4000, stepMs = 100): Promise<void> {\n        if (!isPlatformBrowser(this.platformId)) return Promise.resolve();\n        const start = performance.now();\n        return new Promise<void>((resolve) => {\n            const check = () => {\n                if (typeof $ !== 'undefined' && $.fn && $.fn.slick)\n                    return resolve();\n                if (performance.now() - start > timeoutMs) {\n                    console.warn(\n                        '[SlickInitDirective] Slick no disponible. ¿Cargaste jQuery y slick?'\n                    );\n                    return resolve(); // evita error si no llega\n                }\n                setTimeout(check, stepMs);\n            };\n            check();\n        });\n    }\n}\n"]}

package/esm2022/lib/directives/sliders/slider-fix-arrows.directive.mjs

@@ -0,0 +1,105 @@
+import { Directive, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SliderFixArrowsDirective {
+    constructor(el, r2, zone) {
+        this.el = el;
+        this.r2 = r2;
+        this.zone = zone;
+        this.rafPending = false;
+        this.cleanups = [];
+    }
+    ngAfterViewInit() {
+        // Primer cálculo
+        this.calcPosition();
+        // Recalcular a los 500ms (similar a tu setTimeout)
+        setTimeout(() => this.calcPosition(), 500);
+        // Escuchar scroll/resize sin disparar change detection a lo loco
+        this.zone.runOutsideAngular(() => {
+            const onScroll = () => this.scheduleCalc();
+            const onResize = () => this.scheduleCalc();
+            window.addEventListener('scroll', onScroll, { passive: true });
+            window.addEventListener('resize', onResize, { passive: true });
+            this.cleanups.push(() => window.removeEventListener('scroll', onScroll));
+            this.cleanups.push(() => window.removeEventListener('resize', onResize));
+        });
+    }
+    ngOnDestroy() {
+        this.cleanups.forEach((fn) => fn());
+    }
+    scheduleCalc() {
+        if (this.rafPending)
+            return;
+        this.rafPending = true;
+        requestAnimationFrame(() => {
+            this.rafPending = false;
+            this.calcPosition();
+        });
+    }
+    calcPosition() {
+        const slider = this.el.nativeElement; // .js-slider_fix-arrows
+        if (!slider)
+            return;
+        // Buscamos el contenedor donde aplicar la variable
+        const arrowsContainer = this.closest(slider, '.js-active-slider');
+        if (!arrowsContainer)
+            return;
+        // Resolver "zona" según mobile/desktop
+        const zone = this.pickZone(slider);
+        if (!zone)
+            return;
+        // Necesitamos el ancestro .relative para medir relativo a él
+        const relative = this.closest(zone, '.relative');
+        if (!relative)
+            return;
+        const zoneRect = zone.getBoundingClientRect();
+        const relRect = relative.getBoundingClientRect();
+        // Distancia relativa top + mitad de la altura de la zona
+        const height = zoneRect.top - relRect.top + zoneRect.height / 2;
+        // Seteamos la CSS var
+        this.r2.setStyle(arrowsContainer, '--sliderNav__position', `${height}px`);
+    }
+    /** Lógica mobile/desktop como en tu código original */
+    pickZone(root) {
+        const all = root.querySelectorAll('.js-slider_fix-arrows-zone');
+        if (!all.length)
+            return null;
+        const w = window.innerWidth || 0;
+        // ¿existe .mobile y estamos <= 1279?
+        const mobile = root.querySelector('.js-slider_fix-arrows-zone.mobile');
+        if (mobile && w <= 1279)
+            return mobile;
+        // ¿existe .desktop y estamos >= 1280?
+        const desktop = root.querySelector('.js-slider_fix-arrows-zone.desktop');
+        if (desktop && w >= 1280)
+            return desktop;
+        // fallback: el primero que exista
+        return all[0];
+    }
+    /** closest sin jQuery, con fallback para navegadores raros */
+    closest(el, selector) {
+        if (el.closest)
+            return el.closest(selector);
+        let current = el;
+        while (current) {
+            if (this.matches(current, selector))
+                return current;
+            current = current.parentElement;
+        }
+        return null;
+    }
+    matches(el, selector) {
+        const p = Element.prototype;
+        const f = p.matches || p.msMatchesSelector || p.webkitMatchesSelector;
+        return f.call(el, selector);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SliderFixArrowsDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: SliderFixArrowsDirective, isStandalone: true, selector: "[sliderFixArrows]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SliderFixArrowsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[sliderFixArrows]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider-fix-arrows.directive.js","sourceRoot":"","sources":["../../../../../../projects/babylon/src/lib/directives/sliders/slider-fix-arrows.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewInit,\n    Directive,\n    ElementRef,\n    NgZone,\n    OnDestroy,\n    Renderer2,\n} from '@angular/core';\n\n@Directive({\n    selector: '[sliderFixArrows]', // úsala en el nodo con .js-slider_fix-arrows\n    standalone: true,\n})\nexport class SliderFixArrowsDirective implements AfterViewInit, OnDestroy {\n    private rafPending = false;\n    private cleanups: Array<() => void> = [];\n\n    constructor(\n        private el: ElementRef<HTMLElement>,\n        private r2: Renderer2,\n        private zone: NgZone\n    ) {}\n\n    ngAfterViewInit(): void {\n        // Primer cálculo\n        this.calcPosition();\n\n        // Recalcular a los 500ms (similar a tu setTimeout)\n        setTimeout(() => this.calcPosition(), 500);\n\n        // Escuchar scroll/resize sin disparar change detection a lo loco\n        this.zone.runOutsideAngular(() => {\n            const onScroll = () => this.scheduleCalc();\n            const onResize = () => this.scheduleCalc();\n\n            window.addEventListener('scroll', onScroll, { passive: true });\n            window.addEventListener('resize', onResize, { passive: true });\n\n            this.cleanups.push(() =>\n                window.removeEventListener('scroll', onScroll)\n            );\n            this.cleanups.push(() =>\n                window.removeEventListener('resize', onResize)\n            );\n        });\n    }\n\n    ngOnDestroy(): void {\n        this.cleanups.forEach((fn) => fn());\n    }\n\n    private scheduleCalc() {\n        if (this.rafPending) return;\n        this.rafPending = true;\n        requestAnimationFrame(() => {\n            this.rafPending = false;\n            this.calcPosition();\n        });\n    }\n\n    private calcPosition(): void {\n        const slider = this.el.nativeElement; // .js-slider_fix-arrows\n        if (!slider) return;\n\n        // Buscamos el contenedor donde aplicar la variable\n        const arrowsContainer = this.closest(\n            slider,\n            '.js-active-slider'\n        ) as HTMLElement | null;\n        if (!arrowsContainer) return;\n\n        // Resolver \"zona\" según mobile/desktop\n        const zone = this.pickZone(slider);\n        if (!zone) return;\n\n        // Necesitamos el ancestro .relative para medir relativo a él\n        const relative = this.closest(zone, '.relative') as HTMLElement | null;\n        if (!relative) return;\n\n        const zoneRect = zone.getBoundingClientRect();\n        const relRect = relative.getBoundingClientRect();\n\n        // Distancia relativa top + mitad de la altura de la zona\n        const height = zoneRect.top - relRect.top + zoneRect.height / 2;\n\n        // Seteamos la CSS var\n        this.r2.setStyle(\n            arrowsContainer,\n            '--sliderNav__position',\n            `${height}px`\n        );\n    }\n\n    /** Lógica mobile/desktop como en tu código original */\n    private pickZone(root: HTMLElement): HTMLElement | null {\n        const all = root.querySelectorAll<HTMLElement>(\n            '.js-slider_fix-arrows-zone'\n        );\n        if (!all.length) return null;\n\n        const w = window.innerWidth || 0;\n\n        // ¿existe .mobile y estamos <= 1279?\n        const mobile = root.querySelector<HTMLElement>(\n            '.js-slider_fix-arrows-zone.mobile'\n        );\n        if (mobile && w <= 1279) return mobile;\n\n        // ¿existe .desktop y estamos >= 1280?\n        const desktop = root.querySelector<HTMLElement>(\n            '.js-slider_fix-arrows-zone.desktop'\n        );\n        if (desktop && w >= 1280) return desktop;\n\n        // fallback: el primero que exista\n        return all[0];\n    }\n\n    /** closest sin jQuery, con fallback para navegadores raros */\n    private closest(el: Element, selector: string): Element | null {\n        if (el.closest) return el.closest(selector);\n        let current: Element | null = el;\n        while (current) {\n            if (this.matches(current, selector)) return current;\n            current = current.parentElement;\n        }\n        return null;\n    }\n\n    private matches(el: Element, selector: string): boolean {\n        const p = Element.prototype as any;\n        const f = p.matches || p.msMatchesSelector || p.webkitMatchesSelector;\n        return f.call(el, selector);\n    }\n}\n"]}

package/esm2022/lib/directives/utils/sticky-avoid-footer.directive.mjs

@@ -0,0 +1,91 @@
+import { Directive, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class StickyAvoidFooterDirective {
+    constructor(el, zone, r2) {
+        this.el = el;
+        this.zone = zone;
+        this.r2 = r2;
+        /** Selector del footer (por defecto como en tu HTML) */
+        this.footerSelector = '.footer__links';
+        /** Margen de seguridad inferior del viewport al evaluar visibilidad del footer */
+        this.viewportPadding = 30; // px
+        /** Bottom cuando el footer NO es visible */
+        this.defaultBottom = '3rem';
+        /** Ajuste fino cuando el footer SÍ es visible */
+        this.overlapAdjustPx = 10; // px
+        this.cleanupFns = [];
+        this.rafPending = false;
+    }
+    ngAfterViewInit() {
+        // Cálculo inicial
+        this.adjust();
+        // Listeners performantes fuera de Angular
+        this.zone.runOutsideAngular(() => {
+            const onScroll = () => this.scheduleAdjust();
+            const onResize = () => this.scheduleAdjust();
+            window.addEventListener('scroll', onScroll, { passive: true });
+            window.addEventListener('resize', onResize, { passive: true });
+            this.cleanupFns.push(() => window.removeEventListener('scroll', onScroll));
+            this.cleanupFns.push(() => window.removeEventListener('resize', onResize));
+        });
+    }
+    ngOnDestroy() {
+        this.cleanupFns.forEach((fn) => fn());
+    }
+    scheduleAdjust() {
+        if (this.rafPending)
+            return;
+        this.rafPending = true;
+        requestAnimationFrame(() => {
+            this.rafPending = false;
+            this.adjust();
+        });
+    }
+    adjust() {
+        const button = this.el.nativeElement;
+        const footer = document.querySelector(this.footerSelector);
+        if (!button)
+            return;
+        // Asegura posición controlable (por si acaso)
+        const pos = getComputedStyle(button).position;
+        if (pos === 'static') {
+            this.r2.setStyle(button, 'position', 'fixed'); // o 'absolute' según tu layout
+            this.r2.setStyle(button, 'right', getComputedStyle(button).right || '1rem');
+        }
+        if (!footer) {
+            this.r2.setStyle(button, 'bottom', this.defaultBottom);
+            return;
+        }
+        const footerRect = footer.getBoundingClientRect();
+        const windowHeight = window.innerHeight;
+        const footerHeight = footer.offsetHeight;
+        const isFooterFullyVisible = footerRect.top >= 0 &&
+            footerRect.bottom <= windowHeight - this.viewportPadding;
+        if (isFooterFullyVisible) {
+            const overlap = windowHeight - footerRect.top;
+            const bottomPx = overlap - footerHeight + this.overlapAdjustPx;
+            this.r2.setStyle(button, 'bottom', `${bottomPx}px`);
+        }
+        else {
+            this.r2.setStyle(button, 'bottom', this.defaultBottom);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StickyAvoidFooterDirective, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: StickyAvoidFooterDirective, isStandalone: true, selector: "[stickyAvoidFooter]", inputs: { footerSelector: "footerSelector", viewportPadding: "viewportPadding", defaultBottom: "defaultBottom", overlapAdjustPx: "overlapAdjustPx" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StickyAvoidFooterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[stickyAvoidFooter]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Renderer2 }], propDecorators: { footerSelector: [{
+                type: Input
+            }], viewportPadding: [{
+                type: Input
+            }], defaultBottom: [{
+                type: Input
+            }], overlapAdjustPx: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sticky-avoid-footer.directive.js","sourceRoot":"","sources":["../../../../../../projects/babylon/src/lib/directives/utils/sticky-avoid-footer.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewInit,\n    Directive,\n    ElementRef,\n    Input,\n    NgZone,\n    OnDestroy,\n    Renderer2,\n} from '@angular/core';\n\n@Directive({\n    selector: '[stickyAvoidFooter]', // úsala en .hero-banner__actions\n    standalone: true,\n})\nexport class StickyAvoidFooterDirective implements AfterViewInit, OnDestroy {\n    /** Selector del footer (por defecto como en tu HTML) */\n    @Input() footerSelector = '.footer__links';\n    /** Margen de seguridad inferior del viewport al evaluar visibilidad del footer */\n    @Input() viewportPadding = 30; // px\n    /** Bottom cuando el footer NO es visible */\n    @Input() defaultBottom = '3rem';\n    /** Ajuste fino cuando el footer SÍ es visible */\n    @Input() overlapAdjustPx = 10; // px\n\n    private cleanupFns: Array<() => void> = [];\n    private rafPending = false;\n\n    constructor(\n        private el: ElementRef<HTMLElement>,\n        private zone: NgZone,\n        private r2: Renderer2\n    ) {}\n\n    ngAfterViewInit(): void {\n        // Cálculo inicial\n        this.adjust();\n\n        // Listeners performantes fuera de Angular\n        this.zone.runOutsideAngular(() => {\n            const onScroll = () => this.scheduleAdjust();\n            const onResize = () => this.scheduleAdjust();\n            window.addEventListener('scroll', onScroll, { passive: true });\n            window.addEventListener('resize', onResize, { passive: true });\n            this.cleanupFns.push(() =>\n                window.removeEventListener('scroll', onScroll)\n            );\n            this.cleanupFns.push(() =>\n                window.removeEventListener('resize', onResize)\n            );\n        });\n    }\n\n    ngOnDestroy(): void {\n        this.cleanupFns.forEach((fn) => fn());\n    }\n\n    private scheduleAdjust(): void {\n        if (this.rafPending) return;\n        this.rafPending = true;\n        requestAnimationFrame(() => {\n            this.rafPending = false;\n            this.adjust();\n        });\n    }\n\n    private adjust(): void {\n        const button = this.el.nativeElement;\n        const footer = document.querySelector<HTMLElement>(this.footerSelector);\n\n        if (!button) return;\n\n        // Asegura posición controlable (por si acaso)\n        const pos = getComputedStyle(button).position;\n        if (pos === 'static') {\n            this.r2.setStyle(button, 'position', 'fixed'); // o 'absolute' según tu layout\n            this.r2.setStyle(\n                button,\n                'right',\n                getComputedStyle(button).right || '1rem'\n            );\n        }\n\n        if (!footer) {\n            this.r2.setStyle(button, 'bottom', this.defaultBottom);\n            return;\n        }\n\n        const footerRect = footer.getBoundingClientRect();\n        const windowHeight = window.innerHeight;\n        const footerHeight = footer.offsetHeight;\n\n        const isFooterFullyVisible =\n            footerRect.top >= 0 &&\n            footerRect.bottom <= windowHeight - this.viewportPadding;\n\n        if (isFooterFullyVisible) {\n            const overlap = windowHeight - footerRect.top;\n            const bottomPx = overlap - footerHeight + this.overlapAdjustPx;\n            this.r2.setStyle(button, 'bottom', `${bottomPx}px`);\n        } else {\n            this.r2.setStyle(button, 'bottom', this.defaultBottom);\n        }\n    }\n}\n"]}

package/esm2022/lib/services/index.mjs

@@ -1,4 +1,2 @@
 export * from './screen-sizer';
-export * from './mapper';
-export * from './modals-service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9iYWJ5bG9uL3NyYy9saWIvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zY3JlZW4tc2l6ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9tYXBwZXInO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RhbHMtc2VydmljZSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9iYWJ5bG9uL3NyYy9saWIvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2NyZWVuLXNpemVyJzsiXX0=