ctt-babylon 0.9.17 → 0.9.19

package/esm2022/lib/directives/link-type/link-type.directive.mjs

@@ -0,0 +1,288 @@
+import { isPlatformBrowser } from '@angular/common';
+import { Directive, EventEmitter, HostListener, inject, Input, Output, PLATFORM_ID, NgZone, } from '@angular/core';
+import { complex_links } from '../../utils/complex-links.token';
+import { SITE_CONFIG_SERVICE_TOKEN } from '../../services/mapper/mapper.service.token';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class BabylonLinkTypeDirective {
+    constructor(router, elRef) {
+        this.router = router;
+        this.elRef = elRef;
+        this.anchorClicked = new EventEmitter();
+        this.platformId = inject(PLATFORM_ID);
+        this.hasComplexLinks = inject(complex_links);
+        this.siteSvc = inject(SITE_CONFIG_SERVICE_TOKEN);
+        this.ngZone = inject(NgZone);
+        this.PHONE_RE = /^T\s*[:\-]?\s*(.+)$/i;
+        this.MAILTO_RE = /^mailto:/i;
+        this.ADDRESS_RE = /^c\/\.?(.*)$/i;
+    }
+    ngOnChanges() {
+        if (!this.linkType || !this.href) {
+            this.handleNoLink();
+            return;
+        }
+        if (this.isExternalType(this.linkType)) {
+            const detected = this.detectExternalKind(this.href);
+            this.applyNormalizedHref(detected);
+        }
+        else {
+            this.elRef.nativeElement.setAttribute('href', this.href);
+        }
+        if (this.linkType === 'external' || this.linkType === 'external_link') {
+            this.elRef.nativeElement.setAttribute('rel', 'nofollow');
+        }
+    }
+    btnClick(event) {
+        if (!this.linkType || !this.href) {
+            this.handleNoLink();
+            return;
+        }
+        if (!this.linkType) {
+            console.warn('linkType is missing.');
+            return;
+        }
+        event.preventDefault();
+        switch (this.linkType) {
+            case 'internal':
+                this.handleInternalLink(this.href);
+                break;
+            case 'internal_link':
+                this.handleInternalLink(this.href);
+                break;
+            case 'external':
+                this.handleExternalLink(this.href);
+                break;
+            case 'external_link':
+                this.handleExternalLink(this.href);
+                break;
+            case 'anchor':
+                this.handleAnchorLink(this.href);
+                break;
+            case 'pdf_link':
+                this.handlePdfLink(this.href);
+                break;
+            case 'nolink':
+                this.handleNoLink();
+                break;
+            case 'component':
+                this.handleComponentLink(this.href);
+                break;
+            case 'component_link':
+                this.handleComponentLink(this.href);
+                break;
+            default:
+                console.warn(`Unsupported linkType: ${this.linkType}`);
+                break;
+        }
+    }
+    handleInternalLink(url) {
+        const cleanedUrl = url.trim().replace(/\/+$/, '');
+        this.anchorClicked.emit();
+        this.router.navigateByUrl('/' + cleanedUrl);
+    }
+    handleExternalLink(url) {
+        if (!isPlatformBrowser(this.platformId))
+            return;
+        const detected = this.detectExternalKind(url);
+        switch (detected.kind) {
+            case 'phone':
+                this.openPhone(detected.value);
+                break;
+            case 'email':
+                this.openEmail(detected.value);
+                break;
+            case 'address':
+                this.openAddress(detected.value);
+                break;
+            default:
+                const isAbsoluteUrl = (url) => /^(https?:)/i.test(url);
+                const finalUrl = isAbsoluteUrl(detected.value)
+                    ? detected.value
+                    : 'https://' + detected.value;
+                window.open(finalUrl, '_blank');
+                break;
+        }
+    }
+    handlePdfLink(url) {
+        if (isPlatformBrowser(this.platformId)) {
+            window.open(url, '_blank');
+        }
+    }
+    handleAnchorLink(sectionId) {
+        if (isPlatformBrowser(this.platformId)) {
+            const lang = this.siteSvc.selectedLanguageInstant?.locate.toLowerCase();
+            if (this.hasComplexLinks && this.router.url !== `/${lang}`) {
+                this.redirectToHomeAnchor(sectionId);
+            }
+            else {
+                const element = document.getElementById(sectionId);
+                if (element) {
+                    const yOffset = -160;
+                    const y = element.getBoundingClientRect().top +
+                        window.scrollY +
+                        yOffset;
+                    window.scrollTo({ top: y, behavior: 'smooth' });
+                    this.anchorClicked.emit();
+                }
+                else {
+                    console.warn(`Section with ID ${sectionId} not found.`);
+                }
+            }
+        }
+    }
+    handleComponentLink(url) {
+        const cleanedComponentName = url.trim().toLowerCase();
+        if (this.modalClick) {
+            this.modalClick.emit(cleanedComponentName);
+        }
+        if (this.clickPopup) {
+            this.clickPopup.emit(cleanedComponentName);
+        }
+    }
+    handleNoLink() {
+        const parentLi = this.elRef.nativeElement.closest('li');
+        const isInsideMenuItemWithChildren = parentLi?.classList.contains('menu-item-has-children');
+        if (!isInsideMenuItemWithChildren) {
+            this.elRef.nativeElement.removeAttribute('href');
+            this.elRef.nativeElement.removeAttribute('[href]');
+            this.elRef.nativeElement.setAttribute('aria-disabled', 'true');
+            this.elRef.nativeElement.setAttribute('tabindex', '-1');
+            this.elRef.nativeElement.style.cursor = 'default';
+            this.elRef.nativeElement.style.pointerEvents = 'none';
+        }
+    }
+    openPhone(num) {
+        window.location.href = `tel:${num}`;
+    }
+    openEmail(email) {
+        window.location.href = `mailto:${email}`;
+    }
+    openAddress(address) {
+        const mapsUrl = this.buildMapsUrl(address);
+        window.open(mapsUrl, '_blank');
+    }
+    buildMapsUrl(address) {
+        return `https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(address)}`;
+    }
+    isExternalType(t) {
+        return t === 'external' || t === 'external_link';
+    }
+    detectExternalKind(raw) {
+        const trimmed = (raw || '').trim();
+        if (this.MAILTO_RE.test(trimmed)) {
+            const email = trimmed.replace(/^mailto:/i, '');
+            return { kind: 'email', value: email };
+        }
+        if (this.PHONE_RE.test(trimmed)) {
+            const match = this.PHONE_RE.exec(trimmed);
+            const numRaw = (match?.[1] ?? '').trim();
+            const digits = numRaw.replace(/[^\d+]/g, '');
+            return { kind: 'phone', value: digits };
+        }
+        if (/^tel:/i.test(trimmed)) {
+            const num = trimmed.replace(/^tel:/i, '').replace(/[^\d+]/g, '');
+            return { kind: 'phone', value: num };
+        }
+        const addrMatch = this.ADDRESS_RE.exec(trimmed);
+        if (addrMatch) {
+            const addr = (addrMatch[1] ?? '').trim();
+            return { kind: 'address', value: addr };
+        }
+        return { kind: 'url', value: trimmed };
+    }
+    checkExternalLanguages(val) {
+        const lang = this.siteSvc.selectedLanguageInstant?.locate.toLowerCase();
+        let langurl = val + '/' + lang;
+        return langurl;
+    }
+    redirectToHomeAnchor(sectionId) {
+        const intervalMs = 50;
+        let intervalId;
+        this.router.navigateByUrl('/').then(() => {
+            setTimeout(() => {
+                const attemptScroll = () => {
+                    const element = document.getElementById(sectionId);
+                    if (element) {
+                        clearInterval(intervalId);
+                        clearTimeout(timeoutId);
+                        this.scrollToSection(sectionId);
+                    }
+                };
+                intervalId = setInterval(attemptScroll, intervalMs);
+                const timeoutId = setTimeout(() => {
+                    clearInterval(intervalId);
+                    console.warn(`Section with ID ${sectionId} not found.`);
+                }, 3000);
+                attemptScroll();
+            }, 300);
+        });
+    }
+    scrollToSection(sectionId) {
+        const element = document.getElementById(sectionId);
+        if (element) {
+            setTimeout(() => {
+                const yOffset = -160;
+                const y = element.getBoundingClientRect().top +
+                    window.scrollY +
+                    yOffset;
+                window.scrollTo({ top: y, behavior: 'smooth' });
+                this.anchorClicked.emit();
+                document.querySelector('body')?.classList.remove('no_scroll');
+            }, 500);
+        }
+        else {
+            console.warn(`Section with ID ${sectionId} not found.`);
+        }
+    }
+    applyNormalizedHref(detected) {
+        const el = this.elRef.nativeElement;
+        switch (detected.kind) {
+            case 'phone':
+                el.setAttribute('href', `tel:${detected.value}`);
+                el.removeAttribute('target');
+                break;
+            case 'email':
+                el.setAttribute('href', `mailto:${detected.value}`);
+                el.removeAttribute('target');
+                break;
+            case 'address':
+                el.setAttribute('href', this.buildMapsUrl(detected.value));
+                el.setAttribute('target', '_blank');
+                break;
+            default:
+                if (el.closest('.cs_nav_list') && this.hasComplexLinks) {
+                    let newvalue = this.checkExternalLanguages(detected.value);
+                    el.setAttribute('href', newvalue);
+                }
+                else {
+                    el.setAttribute('href', detected.value);
+                }
+                el.setAttribute('target', '_blank');
+                break;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonLinkTypeDirective, deps: [{ token: i1.Router }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: BabylonLinkTypeDirective, isStandalone: true, selector: "[linkType]", inputs: { linkType: "linkType", href: "href", modalClick: "modalClick", clickPopup: "clickPopup" }, outputs: { anchorClicked: "anchorClicked" }, host: { listeners: { "click": "btnClick($event)" } }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonLinkTypeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[linkType]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i0.ElementRef }], propDecorators: { linkType: [{
+                type: Input
+            }], href: [{
+                type: Input
+            }], modalClick: [{
+                type: Input
+            }], clickPopup: [{
+                type: Input
+            }], anchorClicked: [{
+                type: Output
+            }], btnClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"link-type.directive.js","sourceRoot":"","sources":["../../../../../../projects/babylon/src/lib/directives/link-type/link-type.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { isPlatformBrowser } from '@angular/common';\nimport {\n    Directive,\n    ElementRef,\n    EventEmitter,\n    HostListener,\n    inject,\n    Input,\n    OnChanges,\n    Output,\n    PLATFORM_ID,\n    NgZone,\n} from '@angular/core';\nimport { Router, NavigationEnd } from '@angular/router';\nimport { complex_links } from '../../utils/complex-links.token';\nimport { SITE_CONFIG_SERVICE_TOKEN } from '../../services/mapper/mapper.service.token';\n\n@Directive({\n    selector: '[linkType]',\n    standalone: true,\n})\nexport class BabylonLinkTypeDirective implements OnChanges {\n    @Input() linkType?: string;\n    @Input() href?: string;\n    @Input() modalClick?: EventEmitter<string>;\n    @Input() clickPopup?: EventEmitter<string>;\n    @Output() anchorClicked = new EventEmitter<void>();\n    private platformId = inject(PLATFORM_ID);\n    private hasComplexLinks = inject(complex_links);\n    private readonly siteSvc = inject(SITE_CONFIG_SERVICE_TOKEN);\n    private readonly ngZone = inject(NgZone);\n\n    private readonly PHONE_RE = /^T\\s*[:\\-]?\\s*(.+)$/i;\n    private readonly MAILTO_RE = /^mailto:/i;\n    private readonly ADDRESS_RE = /^c\\/\\.?(.*)$/i;\n\n    constructor(\n        private readonly router: Router,\n        private readonly elRef: ElementRef\n    ) {}\n    ngOnChanges(): void {\n        if (!this.linkType || !this.href) {\n            this.handleNoLink();\n            return;\n        }\n        if (this.isExternalType(this.linkType)) {\n            const detected = this.detectExternalKind(this.href);\n            this.applyNormalizedHref(detected);\n        } else {\n            this.elRef.nativeElement.setAttribute('href', this.href);\n        }\n\n        if (this.linkType === 'external' || this.linkType === 'external_link') {\n            this.elRef.nativeElement.setAttribute('rel', 'nofollow');\n        }\n    }\n\n    @HostListener('click', ['$event'])\n    btnClick(event: Event): void {\n        if (!this.linkType || !this.href) {\n            this.handleNoLink();\n            return;\n        }\n\n        if (!this.linkType) {\n            console.warn('linkType is missing.');\n            return;\n        }\n\n        event.preventDefault();\n\n        switch (this.linkType) {\n            case 'internal':\n                this.handleInternalLink(this.href);\n                break;\n\n            case 'internal_link':\n                this.handleInternalLink(this.href);\n                break;\n\n            case 'external':\n                this.handleExternalLink(this.href);\n                break;\n\n            case 'external_link':\n                this.handleExternalLink(this.href);\n                break;\n\n            case 'anchor':\n                this.handleAnchorLink(this.href);\n                break;\n\n            case 'pdf_link':\n                this.handlePdfLink(this.href);\n                break;\n\n            case 'nolink':\n                this.handleNoLink();\n                break;\n\n            case 'component':\n                this.handleComponentLink(this.href);\n                break;\n\n            case 'component_link':\n                this.handleComponentLink(this.href);\n                break;\n\n            default:\n                console.warn(`Unsupported linkType: ${this.linkType}`);\n                break;\n        }\n    }\n\n    private handleInternalLink(url: string): void {\n        const cleanedUrl = url.trim().replace(/\\/+$/, '');\n        this.anchorClicked.emit();\n        this.router.navigateByUrl('/' + cleanedUrl);\n    }\n\n    private handleExternalLink(url: string): void {\n        if (!isPlatformBrowser(this.platformId)) return;\n\n        const detected = this.detectExternalKind(url);\n        switch (detected.kind) {\n            case 'phone':\n                this.openPhone(detected.value);\n                break;\n            case 'email':\n                this.openEmail(detected.value);\n                break;\n            case 'address':\n                this.openAddress(detected.value);\n                break;\n            default:\n                const isAbsoluteUrl = (url: string) => /^(https?:)/i.test(url);\n                const finalUrl = isAbsoluteUrl(detected.value)\n                    ? detected.value\n                    : 'https://' + detected.value;\n\n                window.open(finalUrl, '_blank');\n                break;\n        }\n    }\n\n    private handlePdfLink(url: string): void {\n        if (isPlatformBrowser(this.platformId)) {\n            window.open(url, '_blank');\n        }\n    }\n\n    private handleAnchorLink(sectionId: string): void {\n        if (isPlatformBrowser(this.platformId)) {\n            const lang =\n                this.siteSvc.selectedLanguageInstant?.locate.toLowerCase();\n            if (this.hasComplexLinks && this.router.url !== `/${lang}`) {\n                this.redirectToHomeAnchor(sectionId);\n            } else {\n                const element = document.getElementById(sectionId);\n                if (element) {\n                    const yOffset = -160;\n                    const y =\n                        element.getBoundingClientRect().top +\n                        window.scrollY +\n                        yOffset;\n\n                    window.scrollTo({ top: y, behavior: 'smooth' });\n                    this.anchorClicked.emit();\n                } else {\n                    console.warn(`Section with ID ${sectionId} not found.`);\n                }\n            }\n        }\n    }\n\n    private handleComponentLink(url: string): void {\n        const cleanedComponentName = url.trim().toLowerCase();\n        if (this.modalClick) {\n            this.modalClick.emit(cleanedComponentName);\n        }\n        if (this.clickPopup) {\n            this.clickPopup.emit(cleanedComponentName);\n        }\n    }\n\n    private handleNoLink(): void {\n        const parentLi = this.elRef.nativeElement.closest('li');\n\n        const isInsideMenuItemWithChildren = parentLi?.classList.contains(\n            'menu-item-has-children'\n        );\n\n        if (!isInsideMenuItemWithChildren) {\n            this.elRef.nativeElement.removeAttribute('href');\n            this.elRef.nativeElement.removeAttribute('[href]');\n            this.elRef.nativeElement.setAttribute('aria-disabled', 'true');\n            this.elRef.nativeElement.setAttribute('tabindex', '-1');\n            this.elRef.nativeElement.style.cursor = 'default';\n            this.elRef.nativeElement.style.pointerEvents = 'none';\n        }\n    }\n\n    private openPhone(num: string): void {\n        window.location.href = `tel:${num}`;\n    }\n\n    private openEmail(email: string): void {\n        window.location.href = `mailto:${email}`;\n    }\n\n    private openAddress(address: string): void {\n        const mapsUrl = this.buildMapsUrl(address);\n        window.open(mapsUrl, '_blank');\n    }\n\n    private buildMapsUrl(address: string): string {\n        return `https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(address)}`;\n    }\n\n    private isExternalType(t?: string): boolean {\n        return t === 'external' || t === 'external_link';\n    }\n\n    private detectExternalKind(raw: string): {\n        kind: 'phone' | 'email' | 'address' | 'url';\n        value: string;\n    } {\n        const trimmed = (raw || '').trim();\n\n        if (this.MAILTO_RE.test(trimmed)) {\n            const email = trimmed.replace(/^mailto:/i, '');\n            return { kind: 'email', value: email };\n        }\n\n        if (this.PHONE_RE.test(trimmed)) {\n            const match = this.PHONE_RE.exec(trimmed);\n            const numRaw = (match?.[1] ?? '').trim();\n            const digits = numRaw.replace(/[^\\d+]/g, '');\n            return { kind: 'phone', value: digits };\n        }\n        if (/^tel:/i.test(trimmed)) {\n            const num = trimmed.replace(/^tel:/i, '').replace(/[^\\d+]/g, '');\n            return { kind: 'phone', value: num };\n        }\n\n        const addrMatch = this.ADDRESS_RE.exec(trimmed);\n        if (addrMatch) {\n            const addr = (addrMatch[1] ?? '').trim();\n            return { kind: 'address', value: addr };\n        }\n\n        return { kind: 'url', value: trimmed };\n    }\n\n    private checkExternalLanguages(val: string): string {\n        const lang = this.siteSvc.selectedLanguageInstant?.locate.toLowerCase();\n        let langurl = val + '/' + lang;\n\n        return langurl;\n    }\n\n    private redirectToHomeAnchor(sectionId: string): void {\n        const intervalMs = 50;\n        let intervalId: any;\n        this.router.navigateByUrl('/').then(() => {\n            setTimeout(() => {\n                const attemptScroll = () => {\n                    const element = document.getElementById(sectionId);\n\n                    if (element) {\n                        clearInterval(intervalId);\n                        clearTimeout(timeoutId);\n                        this.scrollToSection(sectionId);\n                    }\n                };\n\n                intervalId = setInterval(attemptScroll, intervalMs);\n\n                const timeoutId = setTimeout(() => {\n                    clearInterval(intervalId);\n                    console.warn(`Section with ID ${sectionId} not found.`);\n                }, 3000);\n\n                attemptScroll();\n            }, 300);\n        });\n    }\n\n    private scrollToSection(sectionId: string): void {\n        const element = document.getElementById(sectionId);\n        if (element) {\n            setTimeout(() => {\n                const yOffset = -160;\n                const y =\n                    element.getBoundingClientRect().top +\n                    window.scrollY +\n                    yOffset;\n\n                window.scrollTo({ top: y, behavior: 'smooth' });\n                this.anchorClicked.emit();\n                document.querySelector('body')?.classList.remove('no_scroll');\n            }, 500);\n        } else {\n            console.warn(`Section with ID ${sectionId} not found.`);\n        }\n    }\n\n    private applyNormalizedHref(detected: {\n        kind: 'phone' | 'email' | 'address' | 'url';\n        value: string;\n    }): void {\n        const el = this.elRef.nativeElement;\n        switch (detected.kind) {\n            case 'phone':\n                el.setAttribute('href', `tel:${detected.value}`);\n                el.removeAttribute('target');\n                break;\n            case 'email':\n                el.setAttribute('href', `mailto:${detected.value}`);\n                el.removeAttribute('target');\n                break;\n            case 'address':\n                el.setAttribute('href', this.buildMapsUrl(detected.value));\n                el.setAttribute('target', '_blank');\n                break;\n            default:\n                if (el.closest('.cs_nav_list') && this.hasComplexLinks) {\n                    let newvalue = this.checkExternalLanguages(detected.value);\n                    el.setAttribute('href', newvalue);\n                } else {\n                    el.setAttribute('href', detected.value);\n                }\n                el.setAttribute('target', '_blank');\n                break;\n        }\n    }\n}\n"]}

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

@@ -0,0 +1,195 @@
+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) {
+        if (!isPlatformBrowser(this.platformId))
+            return 0;
+        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() {
+        if (!isPlatformBrowser(this.platformId))
+            return 0;
+        const se = document.scrollingElement;
+        return se
+            ? se.scrollTop
+            : window.pageYOffset || document.documentElement.scrollTop || 0;
+    }
+    pageTop(el) {
+        if (!isPlatformBrowser(this.platformId))
+            return 0;
+        const rect = el.getBoundingClientRect();
+        const pageY = window.pageYOffset || document.documentElement.scrollTop || 0;
+        return rect.top + pageY;
+    }
+    computeScrollTop(onScroll) {
+        if (!isPlatformBrowser(this.platformId))
+            return null;
+        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) {
+        if (!isPlatformBrowser(this.platformId))
+            return;
+        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) {
+        if (!isPlatformBrowser(this.platformId))
+            return;
+        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/scrolls/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: Event) {\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      if (!isPlatformBrowser(this.platformId)) return 0;\n\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      if (!isPlatformBrowser(this.platformId)) return 0;\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        if (!isPlatformBrowser(this.platformId)) return 0;\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      if (!isPlatformBrowser(this.platformId)) return 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      if (!isPlatformBrowser(this.platformId)) return;\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      if (!isPlatformBrowser(this.platformId)) return;\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/scrolls/scroll-up.directive.mjs

@@ -0,0 +1,27 @@
+import { isPlatformBrowser } from '@angular/common';
+import { Directive, HostListener, inject, PLATFORM_ID } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BabylonScrollUpDirective {
+    constructor() {
+        this.platformId = inject(PLATFORM_ID);
+    }
+    onClick(event) {
+        if (isPlatformBrowser(this.platformId)) {
+            event.preventDefault();
+            window.scrollTo({ top: 0, behavior: 'smooth' });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonScrollUpDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: BabylonScrollUpDirective, isStandalone: true, selector: "[scrollUp]", host: { listeners: { "click": "onClick($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonScrollUpDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[scrollUp]',
+                    standalone: true,
+                }]
+        }], propDecorators: { onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Nyb2xsLXVwLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2JhYnlsb24vc3JjL2xpYi9kaXJlY3RpdmVzL3Njcm9sbHMvc2Nyb2xsLXVwLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxNQUFNLEVBQUUsV0FBVyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU03RSxNQUFNLE9BQU8sd0JBQXdCO0lBSnJDO1FBS1ksZUFBVSxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQztLQVM1QztJQU5HLE9BQU8sQ0FBQyxLQUFZO1FBQ2hCLElBQUksaUJBQWlCLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxFQUFFO1lBQ3BDLEtBQUssQ0FBQyxjQUFjLEVBQUUsQ0FBQztZQUN2QixNQUFNLENBQUMsUUFBUSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUMsRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQztTQUNuRDtJQUNMLENBQUM7K0dBVFEsd0JBQXdCO21HQUF4Qix3QkFBd0I7OzRGQUF4Qix3QkFBd0I7a0JBSnBDLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLFlBQVk7b0JBQ3RCLFVBQVUsRUFBRSxJQUFJO2lCQUNuQjs4QkFLRyxPQUFPO3NCQUROLFlBQVk7dUJBQUMsT0FBTyxFQUFFLENBQUMsUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaXNQbGF0Zm9ybUJyb3dzZXIgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgRGlyZWN0aXZlLCBIb3N0TGlzdGVuZXIsIGluamVjdCwgUExBVEZPUk1fSUQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gICAgc2VsZWN0b3I6ICdbc2Nyb2xsVXBdJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBCYWJ5bG9uU2Nyb2xsVXBEaXJlY3RpdmUge1xuICAgIHByaXZhdGUgcGxhdGZvcm1JZCA9IGluamVjdChQTEFURk9STV9JRCk7XG5cbiAgICBASG9zdExpc3RlbmVyKCdjbGljaycsIFsnJGV2ZW50J10pXG4gICAgb25DbGljayhldmVudDogRXZlbnQpOiB2b2lkIHtcbiAgICAgICAgaWYgKGlzUGxhdGZvcm1Ccm93c2VyKHRoaXMucGxhdGZvcm1JZCkpIHtcbiAgICAgICAgICAgIGV2ZW50LnByZXZlbnREZWZhdWx0KCk7XG4gICAgICAgICAgICB3aW5kb3cuc2Nyb2xsVG8oeyB0b3A6IDAsIGJlaGF2aW9yOiAnc21vb3RoJyB9KTtcbiAgICAgICAgfVxuICAgIH1cbn1cbiJdfQ==