ctt-babylon 0.8.13 → 0.8.15

package/esm2022/lib/directives/scroll/scroll-to.directive.mjs

@@ -0,0 +1,183 @@
+import { isPlatformBrowser } from '@angular/common';
+import { Directive, HostBinding, HostListener, Inject, PLATFORM_ID, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/scroll/scroll-spy.service";
+export class ScrollToDirective {
+    constructor(el, spy, platformId) {
+        this.el = el;
+        this.spy = spy;
+        this.platformId = platformId;
+        this.role = 'button';
+        this.tabindex = '0';
+        this.isActive = false;
+    }
+    ngOnInit() {
+        if (!isPlatformBrowser(this.platformId))
+            return;
+        this.spy.register(this);
+        this.onScrollY(this.rootScrollTop());
+    }
+    ngOnDestroy() {
+        this.spy.unregister(this);
+    }
+    // ==== Eventos ====
+    onClick(ev) {
+        ev.preventDefault();
+        this.scrollToTarget(false);
+    }
+    onKey(ev) {
+        ev.preventDefault();
+        this.scrollToTarget(false);
+    }
+    // ==== Helpers ====
+    attr(name) {
+        return this.el.nativeElement.getAttribute(name);
+    }
+    spacerBase() {
+        const raw = this.attr('data-scroll_spacer');
+        const n = raw ? parseInt(raw, 10) : 0;
+        return Number.isFinite(n) ? n : 0;
+    }
+    widthAdj(onScroll) {
+        const w = window.innerWidth || document.documentElement.clientWidth || 0;
+        if (onScroll) {
+            if (w >= 768)
+                return 30;
+            if (w >= 540)
+                return 20;
+        }
+        else {
+            if (w >= 768)
+                return 20;
+            if (w >= 540)
+                return 10;
+        }
+        return 0;
+    }
+    targetEl() {
+        const sel = this.attr('data-scroll_to');
+        return sel ? document.querySelector(sel) : null;
+    }
+    /** selector opcional para scroller custom */
+    scrollContainer() {
+        const sel = this.attr('data-scroll_container');
+        if (!sel)
+            return null;
+        return document.querySelector(sel);
+    }
+    rootScrollTop() {
+        const se = document.scrollingElement;
+        return se
+            ? se.scrollTop
+            : window.pageYOffset || document.documentElement.scrollTop || 0;
+    }
+    pageTop(el) {
+        const rect = el.getBoundingClientRect();
+        const pageY = window.pageYOffset || document.documentElement.scrollTop || 0;
+        return rect.top + pageY;
+    }
+    computeScrollTop(onScroll) {
+        const target = this.targetEl();
+        if (!target)
+            return null;
+        const spacer = this.spacerBase() + this.widthAdj(onScroll);
+        // 1) Si hay contenedor custom, calculamos relativo a él
+        const container = this.scrollContainer();
+        if (container) {
+            const targetPage = this.pageTop(target);
+            const containerPage = this.pageTop(container);
+            // posición del target dentro del contenedor + scroll actual del contenedor
+            const relative = targetPage - containerPage;
+            const top = relative - spacer;
+            return { scroller: container, top: top < 0 ? 0 : top };
+        }
+        // 2) Por defecto: documento (como $('html, body'))
+        const top = this.pageTop(target) - spacer;
+        return { scroller: window, top: top < 0 ? 0 : top };
+    }
+    scrollToTarget(fromScrollHandler) {
+        const data = this.computeScrollTop(false);
+        if (!data)
+            return;
+        const behavior = window.matchMedia?.('(prefers-reduced-motion: reduce)').matches
+            ? 'auto'
+            : 'smooth';
+        if (data.scroller instanceof HTMLElement) {
+            data.scroller.scrollTo({ top: data.top, behavior });
+        }
+        else {
+            window.scrollTo({ top: data.top, behavior });
+        }
+        if (this.groupIsActive() && !fromScrollHandler)
+            this.activateSelfAndDeactivateSiblings();
+    }
+    groupIsActive() {
+        const ul = this.el.nativeElement.closest('ul');
+        return ul?.getAttribute('data-scroll_active') === 'true';
+    }
+    activateSelfAndDeactivateSiblings() {
+        this.isActive = true;
+        if (!this.groupIsActive())
+            return;
+        const parent = this.el.nativeElement.parentElement;
+        if (!parent)
+            return;
+        Array.from(parent.children).forEach((ch) => {
+            if (ch !== this.el.nativeElement)
+                ch.classList.remove('active');
+        });
+    }
+    // ==== ScrollSpyTarget ====
+    onScrollY(scrollY) {
+        const target = this.targetEl();
+        if (!target)
+            return;
+        const style = window.getComputedStyle(target);
+        if (style.display === 'none') {
+            this.isActive = false;
+            return;
+        }
+        // Para marcar activo baste con usar la ventana
+        const data = this.computeScrollTop(true);
+        if (!data)
+            return;
+        const top = data.scroller instanceof HTMLElement
+            ? this.rootScrollTop()
+            : data.top;
+        const height = Math.max(target.offsetHeight, 1);
+        const inRange = scrollY >= data.top && scrollY < data.top + height;
+        if (this.groupIsActive())
+            this.isActive = inRange;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ScrollToDirective, deps: [{ token: i0.ElementRef }, { token: i1.ScrollSpyService }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: ScrollToDirective, isStandalone: true, selector: ".js-scrollto,[appScrollTo]", host: { listeners: { "click": "onClick($event)", "keydown.enter": "onKey($event)", "keydown.space": "onKey($event)" }, properties: { "attr.role": "this.role", "attr.tabindex": "this.tabindex", "class.active": "this.isActive" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ScrollToDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '.js-scrollto,[appScrollTo]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.ScrollSpyService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }], propDecorators: { role: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], tabindex: [{
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }], isActive: [{
+                type: HostBinding,
+                args: ['class.active']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], onKey: [{
+                type: HostListener,
+                args: ['keydown.enter', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keydown.space', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll-to.directive.js","sourceRoot":"","sources":["../../../../../../projects/babylon/src/lib/directives/scroll/scroll-to.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { isPlatformBrowser } from '@angular/common';\nimport {\n    Directive,\n    ElementRef,\n    HostBinding,\n    HostListener,\n    Inject,\n    OnDestroy,\n    OnInit,\n    PLATFORM_ID,\n} from '@angular/core';\nimport {\n    ScrollSpyService,\n    ScrollSpyTarget,\n} from '../../services/scroll/scroll-spy.service';\n\n@Directive({\n    selector: '.js-scrollto,[appScrollTo]',\n    standalone: true,\n})\nexport class ScrollToDirective implements OnInit, OnDestroy, ScrollSpyTarget {\n    @HostBinding('attr.role') role = 'button';\n    @HostBinding('attr.tabindex') tabindex = '0';\n    @HostBinding('class.active') isActive = false;\n\n    constructor(\n        private el: ElementRef<HTMLElement>,\n        private spy: ScrollSpyService,\n        @Inject(PLATFORM_ID) private platformId: object\n    ) {}\n\n    ngOnInit(): void {\n        if (!isPlatformBrowser(this.platformId)) return;\n        this.spy.register(this);\n        this.onScrollY(this.rootScrollTop());\n    }\n\n    ngOnDestroy(): void {\n        this.spy.unregister(this);\n    }\n\n    // ==== Eventos ====\n    @HostListener('click', ['$event'])\n    onClick(ev: Event) {\n        ev.preventDefault();\n        this.scrollToTarget(false);\n    }\n\n    @HostListener('keydown.enter', ['$event'])\n    @HostListener('keydown.space', ['$event'])\n    onKey(ev: KeyboardEvent) {\n        ev.preventDefault();\n        this.scrollToTarget(false);\n    }\n\n    // ==== Helpers ====\n    private attr(name: string): string | null {\n        return this.el.nativeElement.getAttribute(name);\n    }\n\n    private spacerBase(): number {\n        const raw = this.attr('data-scroll_spacer');\n        const n = raw ? parseInt(raw, 10) : 0;\n        return Number.isFinite(n) ? n : 0;\n    }\n\n    private widthAdj(onScroll: boolean): number {\n        const w =\n            window.innerWidth || document.documentElement.clientWidth || 0;\n        if (onScroll) {\n            if (w >= 768) return 30;\n            if (w >= 540) return 20;\n        } else {\n            if (w >= 768) return 20;\n            if (w >= 540) return 10;\n        }\n        return 0;\n    }\n\n    private targetEl(): HTMLElement | null {\n        const sel = this.attr('data-scroll_to');\n        return sel ? (document.querySelector(sel) as HTMLElement | null) : null;\n    }\n\n    /** selector opcional para scroller custom */\n    private scrollContainer(): HTMLElement | null {\n        const sel = this.attr('data-scroll_container');\n        if (!sel) return null;\n        return document.querySelector(sel) as HTMLElement | null;\n    }\n\n    private rootScrollTop(): number {\n        const se = document.scrollingElement as HTMLElement | null;\n        return se\n            ? se.scrollTop\n            : window.pageYOffset || document.documentElement.scrollTop || 0;\n    }\n\n    private pageTop(el: HTMLElement): number {\n        const rect = el.getBoundingClientRect();\n        const pageY =\n            window.pageYOffset || document.documentElement.scrollTop || 0;\n        return rect.top + pageY;\n    }\n\n    private computeScrollTop(\n        onScroll: boolean\n    ): { scroller: HTMLElement | Window; top: number } | null {\n        const target = this.targetEl();\n        if (!target) return null;\n\n        const spacer = this.spacerBase() + this.widthAdj(onScroll);\n\n        // 1) Si hay contenedor custom, calculamos relativo a él\n        const container = this.scrollContainer();\n        if (container) {\n            const targetPage = this.pageTop(target);\n            const containerPage = this.pageTop(container);\n            // posición del target dentro del contenedor + scroll actual del contenedor\n            const relative = targetPage - containerPage;\n            const top = relative - spacer;\n            return { scroller: container, top: top < 0 ? 0 : top };\n        }\n\n        // 2) Por defecto: documento (como $('html, body'))\n        const top = this.pageTop(target) - spacer;\n        return { scroller: window, top: top < 0 ? 0 : top };\n    }\n\n    private scrollToTarget(fromScrollHandler: boolean) {\n        const data = this.computeScrollTop(false);\n        if (!data) return;\n\n        const behavior: ScrollBehavior = window.matchMedia?.(\n            '(prefers-reduced-motion: reduce)'\n        ).matches\n            ? 'auto'\n            : 'smooth';\n\n        if (data.scroller instanceof HTMLElement) {\n            data.scroller.scrollTo({ top: data.top, behavior });\n        } else {\n            window.scrollTo({ top: data.top, behavior });\n        }\n\n        if (this.groupIsActive() && !fromScrollHandler)\n            this.activateSelfAndDeactivateSiblings();\n    }\n\n    private groupIsActive(): boolean {\n        const ul = this.el.nativeElement.closest('ul');\n        return ul?.getAttribute('data-scroll_active') === 'true';\n    }\n\n    private activateSelfAndDeactivateSiblings() {\n        this.isActive = true;\n        if (!this.groupIsActive()) return;\n        const parent = this.el.nativeElement.parentElement;\n        if (!parent) return;\n        Array.from(parent.children).forEach((ch) => {\n            if (ch !== this.el.nativeElement) ch.classList.remove('active');\n        });\n    }\n\n    // ==== ScrollSpyTarget ====\n    onScrollY(scrollY: number): void {\n        const target = this.targetEl();\n        if (!target) return;\n        const style = window.getComputedStyle(target);\n        if (style.display === 'none') {\n            this.isActive = false;\n            return;\n        }\n\n        // Para marcar activo baste con usar la ventana\n        const data = this.computeScrollTop(true);\n        if (!data) return;\n        const top =\n            data.scroller instanceof HTMLElement\n                ? this.rootScrollTop()\n                : data.top;\n        const height = Math.max(target.offsetHeight, 1);\n        const inRange = scrollY >= data.top && scrollY < data.top + height;\n\n        if (this.groupIsActive()) this.isActive = inRange;\n    }\n}\n"]}

package/esm2022/lib/directives/scroll/show-only-top.directive.mjs

@@ -0,0 +1,103 @@
+// directives/show-only-at-top.directive.ts
+import { Directive, HostBinding, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ShowOnlyAtTopDirective {
+    get cls() {
+        return this.hidden;
+    }
+    get op() {
+        return this.hidden ? '0' : '1';
+    }
+    get pe() {
+        return this.hidden ? 'none' : 'auto';
+    }
+    constructor(zone) {
+        this.zone = zone;
+        /** Rango en px desde el top en el que el botón permanece visible */
+        this.topShowPx = 10; // ajusta a 4–16 si quieres más/menos sensible
+        this.minWidth = 540;
+        this.hidden = false;
+        this.active = false;
+        this.ticking = false;
+        this.t = 'opacity .25s ease, transform .25s ease';
+    }
+    ngAfterViewInit() {
+        const evaluateScroll = () => {
+            const y = Math.max(window.scrollY, document.documentElement.scrollTop || 0);
+            const shouldHide = this.active && y > this.topShowPx;
+            if (shouldHide !== this.hidden)
+                this.hidden = shouldHide;
+        };
+        const applyActiveState = () => {
+            const nowActive = window.innerWidth >= this.minWidth;
+            if (nowActive === this.active)
+                return;
+            this.active = nowActive;
+            if (!this.active) {
+                // Desactivado en < minWidth: muestra siempre y no escucha scroll
+                this.hidden = false;
+                window.removeEventListener('scroll', onScroll);
+            }
+            else {
+                // Re-activar
+                window.addEventListener('scroll', onScroll, { passive: true });
+                evaluateScroll();
+            }
+        };
+        const onScroll = () => {
+            if (this.ticking)
+                return;
+            this.ticking = true;
+            requestAnimationFrame(() => {
+                evaluateScroll();
+                this.ticking = false;
+            });
+        };
+        const onResize = () => {
+            applyActiveState();
+            if (this.active)
+                onScroll();
+        };
+        this.zone.runOutsideAngular(() => {
+            // Setup inicial
+            applyActiveState();
+            if (this.active) {
+                window.addEventListener('scroll', onScroll, { passive: true });
+                evaluateScroll();
+            }
+            window.addEventListener('resize', onResize, { passive: true });
+            this.offScroll = () => window.removeEventListener('scroll', onScroll);
+            this.offResize = () => window.removeEventListener('resize', onResize);
+        });
+    }
+    ngOnDestroy() {
+        this.offScroll?.();
+        this.offResize?.();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ShowOnlyAtTopDirective, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: ShowOnlyAtTopDirective, isStandalone: true, selector: "[showOnlyAtTop]", inputs: { topShowPx: "topShowPx", minWidth: "minWidth" }, host: { properties: { "style.transition": "this.t", "class.is-hidden": "this.cls", "style.opacity": "this.op", "style.pointerEvents": "this.pe" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ShowOnlyAtTopDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[showOnlyAtTop]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.NgZone }], propDecorators: { topShowPx: [{
+                type: Input
+            }], minWidth: [{
+                type: Input
+            }], t: [{
+                type: HostBinding,
+                args: ['style.transition']
+            }], cls: [{
+                type: HostBinding,
+                args: ['class.is-hidden']
+            }], op: [{
+                type: HostBinding,
+                args: ['style.opacity']
+            }], pe: [{
+                type: HostBinding,
+                args: ['style.pointerEvents']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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":"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","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"]}