ctt-babylon 0.9.17 → 0.9.19

package/esm2022/lib/directives/babylon-background-strip/babylon-background-strip.directive.mjs

@@ -0,0 +1,71 @@
+import { Directive, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BabylonBackgroundStrip {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+    }
+    ngOnChanges() {
+        this.updateBackgroundStyle();
+    }
+    updateBackgroundStyle() {
+        const nativeElement = this.el.nativeElement;
+        // Limpiar elementos previos
+        if (this.topSection) {
+            this.renderer.removeChild(nativeElement, this.topSection);
+            this.topSection = undefined;
+        }
+        if (this.bottomSection) {
+            this.renderer.removeChild(nativeElement, this.bottomSection);
+            this.bottomSection = undefined;
+        }
+        // Crear sección superior si hay contenido
+        if ((this.topBG && this.topBG.trim() !== '') ||
+            (this.topColor && this.topColor.trim() !== '')) {
+            this.topSection = this.renderer.createElement('div');
+            this.renderer.addClass(this.topSection, 'top-section');
+            this.renderer.appendChild(nativeElement, this.topSection);
+            if (this.topBG && this.topBG.trim() !== '') {
+                this.renderer.setStyle(this.topSection, 'background-image', `url('${this.topBG}')`);
+                this.renderer.setStyle(this.topSection, 'background-size', 'cover');
+                this.renderer.setStyle(this.topSection, 'background-position', 'center');
+            }
+            if (this.topColor && this.topColor.trim() !== '') {
+                this.renderer.setStyle(this.topSection, 'background-color', this.topColor);
+            }
+        }
+        // Crear sección inferior si hay contenido
+        if ((this.bottomBG && this.bottomBG.trim() !== '') ||
+            (this.bottomColor && this.bottomColor.trim() !== '')) {
+            this.bottomSection = this.renderer.createElement('div');
+            this.renderer.addClass(this.bottomSection, 'bottom-section');
+            this.renderer.appendChild(nativeElement, this.bottomSection);
+            if (this.bottomBG && this.bottomBG.trim() !== '') {
+                this.renderer.setStyle(this.bottomSection, 'background-image', `url('${this.bottomBG}')`);
+                this.renderer.setStyle(this.bottomSection, 'background-size', 'cover');
+                this.renderer.setStyle(this.bottomSection, 'background-position', 'center');
+            }
+            if (this.bottomColor && this.bottomColor.trim() !== '') {
+                this.renderer.setStyle(this.bottomSection, 'background-color', this.bottomColor);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonBackgroundStrip, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: BabylonBackgroundStrip, isStandalone: true, selector: "[backgroundStrip]", inputs: { topBG: "topBG", bottomBG: "bottomBG", topColor: "topColor", bottomColor: "bottomColor" }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonBackgroundStrip, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[backgroundStrip]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { topBG: [{
+                type: Input
+            }], bottomBG: [{
+                type: Input
+            }], topColor: [{
+                type: Input
+            }], bottomColor: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"babylon-background-strip.directive.js","sourceRoot":"","sources":["../../../../../../projects/babylon/src/lib/directives/babylon-background-strip/babylon-background-strip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Directive,\n    ElementRef,\n    Input,\n    OnChanges,\n    Renderer2,\n} from '@angular/core';\n\n@Directive({\n    selector: '[backgroundStrip]',\n    standalone: true,\n})\nexport class BabylonBackgroundStrip implements OnChanges {\n    @Input() topBG?: string;\n    @Input() bottomBG?: string;\n    @Input() topColor?: string;\n    @Input() bottomColor?: string;\n\n    private topSection?: HTMLElement;\n    private bottomSection?: HTMLElement;\n\n    constructor(\n        private el: ElementRef,\n        private renderer: Renderer2\n    ) {}\n\n    ngOnChanges(): void {\n        this.updateBackgroundStyle();\n    }\n\n    private updateBackgroundStyle(): void {\n        const nativeElement = this.el.nativeElement;\n\n        // Limpiar elementos previos\n        if (this.topSection) {\n            this.renderer.removeChild(nativeElement, this.topSection);\n            this.topSection = undefined;\n        }\n        if (this.bottomSection) {\n            this.renderer.removeChild(nativeElement, this.bottomSection);\n            this.bottomSection = undefined;\n        }\n\n        // Crear sección superior si hay contenido\n        if (\n            (this.topBG && this.topBG.trim() !== '') ||\n            (this.topColor && this.topColor.trim() !== '')\n        ) {\n            this.topSection = this.renderer.createElement('div');\n            this.renderer.addClass(this.topSection, 'top-section');\n            this.renderer.appendChild(nativeElement, this.topSection);\n\n            if (this.topBG && this.topBG.trim() !== '') {\n                this.renderer.setStyle(\n                    this.topSection,\n                    'background-image',\n                    `url('${this.topBG}')`\n                );\n                this.renderer.setStyle(\n                    this.topSection,\n                    'background-size',\n                    'cover'\n                );\n                this.renderer.setStyle(\n                    this.topSection,\n                    'background-position',\n                    'center'\n                );\n            }\n            if (this.topColor && this.topColor.trim() !== '') {\n                this.renderer.setStyle(\n                    this.topSection,\n                    'background-color',\n                    this.topColor\n                );\n            }\n        }\n\n        // Crear sección inferior si hay contenido\n        if (\n            (this.bottomBG && this.bottomBG.trim() !== '') ||\n            (this.bottomColor && this.bottomColor.trim() !== '')\n        ) {\n            this.bottomSection = this.renderer.createElement('div');\n            this.renderer.addClass(this.bottomSection, 'bottom-section');\n            this.renderer.appendChild(nativeElement, this.bottomSection);\n\n            if (this.bottomBG && this.bottomBG.trim() !== '') {\n                this.renderer.setStyle(\n                    this.bottomSection,\n                    'background-image',\n                    `url('${this.bottomBG}')`\n                );\n                this.renderer.setStyle(\n                    this.bottomSection,\n                    'background-size',\n                    'cover'\n                );\n                this.renderer.setStyle(\n                    this.bottomSection,\n                    'background-position',\n                    'center'\n                );\n            }\n            if (this.bottomColor && this.bottomColor.trim() !== '') {\n                this.renderer.setStyle(\n                    this.bottomSection,\n                    'background-color',\n                    this.bottomColor\n                );\n            }\n        }\n    }\n}\n"]}

package/esm2022/lib/directives/babylon-customs/babylon-custom-mouse-pointer.directive.mjs

@@ -0,0 +1,52 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BabylonCustomMousePointerDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+    }
+    onMouseMove(event) {
+        const mousePoint = this.el.nativeElement.querySelector('.cs_mouse_point');
+        if (mousePoint) {
+            const mouseX = event.pageX -
+                this.el.nativeElement.getBoundingClientRect().left;
+            const mouseY = event.clientY -
+                this.el.nativeElement.getBoundingClientRect().top;
+            if (mousePoint) {
+                this.renderer.setStyle(mousePoint, 'top', `${mouseY}px`);
+                this.renderer.setStyle(mousePoint, 'left', `${mouseX}px`);
+            }
+        }
+    }
+    onMouseEnter() {
+        const mousePoint = this.el.nativeElement.querySelector('.cs_mouse_point');
+        if (mousePoint) {
+            this.renderer.setStyle(mousePoint, 'visibility', 'visible');
+        }
+    }
+    onMouseLeave() {
+        const mousePoint = this.el.nativeElement.querySelector('.cs_mouse_point');
+        if (mousePoint) {
+            this.renderer.setStyle(mousePoint, 'visibility', 'hidden');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonCustomMousePointerDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: BabylonCustomMousePointerDirective, isStandalone: true, selector: "[BabylonCustomMousePointer]", host: { listeners: { "mousemove": "onMouseMove($event)", "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonCustomMousePointerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[BabylonCustomMousePointer]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { onMouseMove: [{
+                type: HostListener,
+                args: ['mousemove', ['$event']]
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/babylon-galleries/babylon-light-gallery.directive.mjs

@@ -0,0 +1,107 @@
+import { isPlatformBrowser } from '@angular/common';
+import { Directive, inject, PLATFORM_ID, } from '@angular/core';
+import { forkJoin, switchMap, tap } from 'rxjs';
+import { Utils } from '../../utils';
+import * as i0 from "@angular/core";
+export class BabylonLightGalleryDirective {
+    constructor(el) {
+        this.el = el;
+        this.platformId = inject(PLATFORM_ID);
+    }
+    ngAfterViewInit() {
+        if (isPlatformBrowser(this.platformId)) {
+            const isJQueryLoaded = typeof jQuery !== 'undefined' && typeof $ === 'function';
+            const isLightGalleryLoaded = isJQueryLoaded &&
+                typeof $.fn.lightGallery === 'function';
+            if (isLightGalleryLoaded) {
+                this.executeInitLightGallery();
+            }
+            else {
+                this.loadDependenciesAndInitialize();
+            }
+        }
+    }
+    ngOnDestroy() {
+        if (isPlatformBrowser(this.platformId)) {
+            this.destroyGallery();
+            this.observer?.disconnect();
+        }
+    }
+    loadDependenciesAndInitialize() {
+        if (isPlatformBrowser(this.platformId)) {
+            Utils.loadScript$('assets/babylon/js/jquery.min.js')
+                .pipe(switchMap(() => forkJoin([
+                Utils.loadScript$('assets/babylon/lightgallery/js/lightgallery.min.js'),
+                Utils.loadStyle$('assets/babylon/lightgallery/css/lightgallery.min.css'),
+            ]).pipe(tap(() => {
+                this.executeInitLightGallery();
+            }))))
+                .subscribe();
+        }
+    }
+    executeInitLightGallery() {
+        if (isPlatformBrowser(this.platformId)) {
+            setTimeout(() => {
+                try {
+                    this.initLightGallery();
+                    if (!this.observer) {
+                        // Cuando el DOM cambie (Angular repinta al filtrar) refrescamos el plugin
+                        this.observer = new MutationObserver(() => this.refresh());
+                        this.observer.observe(this.el.nativeElement, {
+                            childList: true,
+                            subtree: true,
+                        });
+                    }
+                }
+                catch (error) {
+                    this.executeInitLightGallery();
+                }
+            }, 70);
+        }
+    }
+    initLightGallery() {
+        if (isPlatformBrowser(this.platformId)) {
+            if (typeof $ === 'undefined')
+                return;
+            this.galleryInstance = $(this.el.nativeElement)
+                .lightGallery({
+                selector: '.cs_lightbox_item',
+                thumbnail: true,
+                mousewheel: true,
+                share: false,
+                fullScreen: false,
+                autoplay: false,
+                actualSize: false,
+                autoplayControls: false,
+                download: false,
+            })
+                .data('lightGallery');
+        }
+    }
+    refresh() {
+        if (isPlatformBrowser(this.platformId)) {
+            // evita bucles infinitos: solo si hay elementos y el plugin está vivo
+            if (this.galleryInstance &&
+                $(this.el.nativeElement).find('.cs_lightbox_item').length) {
+                this.destroyGallery();
+                this.initLightGallery();
+            }
+        }
+    }
+    destroyGallery() {
+        if (isPlatformBrowser(this.platformId)) {
+            this.galleryInstance?.destroy(true);
+            this.galleryInstance = null;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonLightGalleryDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: BabylonLightGalleryDirective, isStandalone: true, selector: "[BabylonLightGallery]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonLightGalleryDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[BabylonLightGallery]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"babylon-light-gallery.directive.js","sourceRoot":"","sources":["../../../../../../projects/babylon/src/lib/directives/babylon-galleries/babylon-light-gallery.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';\nimport { forkJoin, switchMap, tap } from 'rxjs';\nimport { Utils } from '../../utils';\n\n@Directive({\n    selector: '[BabylonLightGallery]',\n    standalone: true,\n})\nexport class BabylonLightGalleryDirective implements AfterViewInit, OnDestroy {\n    private galleryInstance: any;\n    private observer!: MutationObserver;\n    private readonly platformId = inject(PLATFORM_ID);\n\n    constructor(private el: ElementRef) {}\n\n    ngAfterViewInit() {\n        if (isPlatformBrowser(this.platformId)) {\n            const isJQueryLoaded =\n                typeof jQuery !== 'undefined' && typeof $ === 'function';\n            const isLightGalleryLoaded =\n                isJQueryLoaded &&\n                typeof ($ as any).fn.lightGallery === 'function';\n\n            if (isLightGalleryLoaded) {\n                this.executeInitLightGallery();\n            } else {\n                this.loadDependenciesAndInitialize();\n            }\n        }\n    }\n\n    ngOnDestroy() {\n        if (isPlatformBrowser(this.platformId)) {\n            this.destroyGallery();\n            this.observer?.disconnect();\n        }\n    }\n\n    private loadDependenciesAndInitialize(): void {\n        if (isPlatformBrowser(this.platformId)) {\n            Utils.loadScript$('assets/babylon/js/jquery.min.js')\n                .pipe(\n                    switchMap(() =>\n                        forkJoin([\n                            Utils.loadScript$(\n                                'assets/babylon/lightgallery/js/lightgallery.min.js'\n                            ),\n                            Utils.loadStyle$(\n                                'assets/babylon/lightgallery/css/lightgallery.min.css'\n                            ),\n                        ]).pipe(\n                            tap(() => {\n                                this.executeInitLightGallery();\n                            })\n                        )\n                    )\n                )\n                .subscribe();\n        }\n    }\n\n    private executeInitLightGallery(): void {\n        if (isPlatformBrowser(this.platformId)) {\n            setTimeout(() => {\n                try {\n                    this.initLightGallery();\n                    if (!this.observer) {\n                        // Cuando el DOM cambie (Angular repinta al filtrar) refrescamos el plugin\n                        this.observer = new MutationObserver(() =>\n                            this.refresh()\n                        );\n                        this.observer.observe(this.el.nativeElement, {\n                            childList: true,\n                            subtree: true,\n                        });\n                    }\n                } catch (error) {\n                    this.executeInitLightGallery();\n                }\n            }, 70);\n        }\n    }\n\n    private initLightGallery() {\n        if (isPlatformBrowser(this.platformId)) {\n            if (typeof $ === 'undefined') return;\n            this.galleryInstance = ($(this.el.nativeElement) as any)\n                .lightGallery({\n                    selector: '.cs_lightbox_item',\n                    thumbnail: true,\n                    mousewheel: true,\n                    share: false,\n                    fullScreen: false,\n                    autoplay: false,\n                    actualSize: false,\n                    autoplayControls: false,\n                    download: false,\n                })\n                .data('lightGallery');\n        }\n    }\n\n    private refresh() {\n        if (isPlatformBrowser(this.platformId)) {\n            // evita bucles infinitos: solo si hay elementos y el plugin está vivo\n            if (\n                this.galleryInstance &&\n                $(this.el.nativeElement).find('.cs_lightbox_item').length\n            ) {\n                this.destroyGallery();\n                this.initLightGallery();\n            }\n        }\n    }\n\n    private destroyGallery() {\n        if (isPlatformBrowser(this.platformId)) {\n            this.galleryInstance?.destroy(true);\n            this.galleryInstance = null;\n        }\n    }\n}\n"]}

package/esm2022/lib/directives/babylon-hobble-effect/babylon-hobble-effect.directive.mjs

@@ -0,0 +1,60 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BabylonHobbleEffectDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        this.hoverLayer1 = null;
+        this.hoverLayer2 = null;
+    }
+    ngOnDestroy() {
+        this.resetTransform();
+    }
+    onMouseMove(event) {
+        const target = this.el.nativeElement;
+        const rect = target.getBoundingClientRect();
+        const halfW = target.clientWidth / 2;
+        const halfH = target.clientHeight / 2;
+        const coorX = halfW - (event.clientX - rect.left);
+        const coorY = halfH - (event.clientY - rect.top);
+        const degX1 = (coorY / halfH) * 8;
+        const degY1 = (coorX / halfW) * -8;
+        const degX3 = (coorY / halfH) * -15;
+        const degY3 = (coorX / halfW) * 15;
+        this.hoverLayer1 = target.querySelector('.cs_hover_layer_1');
+        this.hoverLayer2 = target.querySelector('.cs_hover_layer_2');
+        if (this.hoverLayer1) {
+            this.renderer.setStyle(this.hoverLayer1, 'transform', `perspective(800px) translate3d(0, 0, 0) rotateX(${degX1}deg) rotateY(${degY1}deg)`);
+        }
+        if (this.hoverLayer2) {
+            this.renderer.setStyle(this.hoverLayer2, 'transform', `perspective(800px) translateX(${degX3}px) translateY(${degY3}px) scale(1.04)`);
+        }
+    }
+    onMouseLeave() {
+        this.resetTransform();
+    }
+    resetTransform() {
+        if (this.hoverLayer1) {
+            this.renderer.removeStyle(this.hoverLayer1, 'transform');
+        }
+        if (this.hoverLayer2) {
+            this.renderer.removeStyle(this.hoverLayer2, 'transform');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonHobbleEffectDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: BabylonHobbleEffectDirective, isStandalone: true, selector: "[hobbleEffect]", host: { listeners: { "mousemove": "onMouseMove($event)", "mouseleave": "onMouseLeave()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonHobbleEffectDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[hobbleEffect]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { onMouseMove: [{
+                type: HostListener,
+                args: ['mousemove', ['$event']]
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/babylon-pagination/babylon-pagination.directive.mjs

@@ -0,0 +1,127 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BabylonPaginationDirective {
+    constructor(templateRef, viewContainer, cdr) {
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+        this.cdr = cdr;
+        this._items = [];
+        this._pageSize = 8;
+        this._currentPage = 1;
+        this.context = {
+            $implicit: [],
+            pagedItems: [],
+            currentPage: 1,
+            totalPages: 0,
+            next: () => this.next(),
+            prev: () => this.prev(),
+            goToPage: (p) => this.goToPage(p),
+        };
+        this.libPaginatePageChange = new EventEmitter();
+    }
+    set libPaginate(items) {
+        this._items = Array.isArray(items) ? items : [];
+        this.resetToFirstPage();
+        this.updateView();
+    }
+    set libPaginateItems(items) {
+        this.libPaginate = items;
+    }
+    set libPaginatePageSize(size) {
+        const parsed = Number(size);
+        this._pageSize = Number.isFinite(parsed) && parsed > 0 ? parsed : 8;
+        this.ensureCurrentPageInRange();
+        this.updateView();
+    }
+    set libPaginateCurrentPage(page) {
+        const parsed = Number(page);
+        if (Number.isFinite(parsed) && parsed >= 1) {
+            this._currentPage = parsed;
+            this.ensureCurrentPageInRange();
+            this.updateView();
+        }
+    }
+    ngOnInit() {
+        this.viewRef = this.viewContainer.createEmbeddedView(this.templateRef, this.context);
+        this.updateView();
+    }
+    next() {
+        this.goToPage(this._currentPage + 1);
+    }
+    prev() {
+        this.goToPage(this._currentPage - 1);
+    }
+    goToPage(page) {
+        const totalPages = this.computeTotalPages();
+        if (totalPages === 0)
+            return;
+        const target = Math.max(1, Math.min(totalPages, Math.trunc(page)));
+        if (target !== this._currentPage) {
+            this._currentPage = target;
+            this.updateView();
+            this.libPaginatePageChange.emit(this._currentPage);
+        }
+    }
+    resetToFirstPage() {
+        this._currentPage = 1;
+    }
+    ensureCurrentPageInRange() {
+        const totalPages = this.computeTotalPages();
+        if (totalPages === 0) {
+            this._currentPage = 1;
+            return;
+        }
+        if (this._currentPage > totalPages) {
+            this._currentPage = totalPages;
+        }
+        if (this._currentPage < 1) {
+            this._currentPage = 1;
+        }
+    }
+    computeTotalPages() {
+        const totalItems = this._items.length;
+        return totalItems > 0 ? Math.ceil(totalItems / this._pageSize) : 0;
+    }
+    getPagedItems() {
+        if (!this._items.length)
+            return [];
+        const startIndex = (this._currentPage - 1) * this._pageSize;
+        const endIndex = startIndex + this._pageSize;
+        return this._items.slice(startIndex, endIndex);
+    }
+    updateView() {
+        const paged = this.getPagedItems();
+        const totalPages = this.computeTotalPages();
+        this.context.pagedItems = paged;
+        this.context.$implicit = paged;
+        this.context.currentPage = this._currentPage;
+        this.context.totalPages = totalPages;
+        if (this.viewRef) {
+            this.viewRef.markForCheck();
+        }
+        this.cdr.markForCheck();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonPaginationDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: BabylonPaginationDirective, isStandalone: true, selector: "[libPaginate]", inputs: { libPaginate: "libPaginate", libPaginateItems: "libPaginateItems", libPaginatePageSize: "libPaginatePageSize", libPaginateCurrentPage: "libPaginateCurrentPage" }, outputs: { libPaginatePageChange: "libPaginatePageChange" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonPaginationDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[libPaginate]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }], propDecorators: { libPaginate: [{
+                type: Input
+            }], libPaginateItems: [{
+                type: Input,
+                args: ['libPaginateItems']
+            }], libPaginatePageSize: [{
+                type: Input,
+                args: ['libPaginatePageSize']
+            }], libPaginateCurrentPage: [{
+                type: Input,
+                args: ['libPaginateCurrentPage']
+            }], libPaginatePageChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"babylon-pagination.directive.js","sourceRoot":"","sources":["../../../../../../projects/babylon/src/lib/directives/babylon-pagination/babylon-pagination.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Directive, EmbeddedViewRef, EventEmitter, Input, OnInit, Output, TemplateRef, ViewContainerRef } from '@angular/core';\n\ninterface PaginateContext<T> {\n  $implicit: T[];\n  pagedItems: T[];\n  currentPage: number;\n  totalPages: number;\n  next: () => void;\n  prev: () => void;\n  goToPage: (page: number) => void;\n}\n\n@Directive({\n  selector: '[libPaginate]',\n  standalone: true,\n})\nexport class BabylonPaginationDirective<T = unknown> implements OnInit {\n  private _items: T[] = [];\n  private _pageSize: number = 8;\n  private _currentPage: number = 1;\n\n  private viewRef?: EmbeddedViewRef<PaginateContext<T>>;\n  private context: PaginateContext<T> = {\n    $implicit: [],\n    pagedItems: [],\n    currentPage: 1,\n    totalPages: 0,\n    next: () => this.next(),\n    prev: () => this.prev(),\n    goToPage: (p: number) => this.goToPage(p),\n  };\n\n  constructor(\n    private readonly templateRef: TemplateRef<PaginateContext<T>>,\n    private readonly viewContainer: ViewContainerRef,\n    private readonly cdr: ChangeDetectorRef,\n  ) {}\n\n  @Input()\n  set libPaginate(items: T[] | null | undefined) {\n    this._items = Array.isArray(items) ? items : [];\n    this.resetToFirstPage();\n    this.updateView();\n  }\n\n  @Input('libPaginateItems')\n  set libPaginateItems(items: T[] | null | undefined) {\n    this.libPaginate = items as T[];\n  }\n\n  @Input('libPaginatePageSize')\n  set libPaginatePageSize(size: number | null | undefined) {\n    const parsed = Number(size);\n    this._pageSize = Number.isFinite(parsed) && parsed > 0 ? parsed : 8;\n    this.ensureCurrentPageInRange();\n    this.updateView();\n  }\n\n  @Input('libPaginateCurrentPage')\n  set libPaginateCurrentPage(page: number | null | undefined) {\n    const parsed = Number(page);\n    if (Number.isFinite(parsed) && parsed >= 1) {\n      this._currentPage = parsed;\n      this.ensureCurrentPageInRange();\n      this.updateView();\n    }\n  }\n\n  @Output()\n  libPaginatePageChange = new EventEmitter<number>();\n\n  ngOnInit(): void {\n    this.viewRef = this.viewContainer.createEmbeddedView(this.templateRef, this.context);\n    this.updateView();\n  }\n\n  next(): void {\n    this.goToPage(this._currentPage + 1);\n  }\n\n  prev(): void {\n    this.goToPage(this._currentPage - 1);\n  }\n\n  goToPage(page: number): void {\n    const totalPages = this.computeTotalPages();\n    if (totalPages === 0) return;\n    const target = Math.max(1, Math.min(totalPages, Math.trunc(page)));\n    if (target !== this._currentPage) {\n      this._currentPage = target;\n      this.updateView();\n      this.libPaginatePageChange.emit(this._currentPage);\n    }\n  }\n\n\n  private resetToFirstPage(): void {\n    this._currentPage = 1;\n  }\n\n  private ensureCurrentPageInRange(): void {\n    const totalPages = this.computeTotalPages();\n    if (totalPages === 0) {\n      this._currentPage = 1;\n      return;\n    }\n    if (this._currentPage > totalPages) {\n      this._currentPage = totalPages;\n    }\n    if (this._currentPage < 1) {\n      this._currentPage = 1;\n    }\n  }\n\n  private computeTotalPages(): number {\n    const totalItems = this._items.length;\n    return totalItems > 0 ? Math.ceil(totalItems / this._pageSize) : 0;\n  }\n\n  private getPagedItems(): T[] {\n    if (!this._items.length) return [];\n    const startIndex = (this._currentPage - 1) * this._pageSize;\n    const endIndex = startIndex + this._pageSize;\n    return this._items.slice(startIndex, endIndex);\n  }\n\n  private updateView(): void {\n    const paged = this.getPagedItems();\n    const totalPages = this.computeTotalPages();\n\n    this.context.pagedItems = paged;\n    this.context.$implicit = paged;\n    this.context.currentPage = this._currentPage;\n    this.context.totalPages = totalPages;\n\n    if (this.viewRef) {\n      this.viewRef.markForCheck();\n    }\n    this.cdr.markForCheck();\n  }\n}\n\n\n"]}

package/esm2022/lib/directives/babylon-sliders/babylon-custom-slider.directive.mjs

@@ -0,0 +1,62 @@
+import { isPlatformBrowser } from '@angular/common';
+import { Directive, inject, PLATFORM_ID, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BabylonCustomSliderDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        this.platformId = inject(PLATFORM_ID);
+    }
+    ngAfterViewInit() {
+        if (isPlatformBrowser(this.platformId)) {
+            this.initSlider();
+        }
+    }
+    initSlider() {
+        const slider = this.el.nativeElement;
+        const arrows = slider.querySelectorAll('.cs_custom_slide_arrow_right, .cs_custom_slide_arrow_left');
+        arrows.forEach((arrow) => {
+            arrow.addEventListener('click', (event) => {
+                const direction = arrow?.classList.contains('cs_custom_slide_arrow_left')
+                    ? 'prev'
+                    : 'next';
+                this.updateSlides(direction);
+            });
+        });
+        this.updateSlides('next');
+    }
+    updateSlides(direction) {
+        const activeSlide = this.el.nativeElement.querySelector('.cs_custom_slide.active');
+        const slides = this.el.nativeElement.querySelectorAll('.cs_custom_slide');
+        const totalSlides = slides.length;
+        const activeIndex = Array.from(slides).indexOf(activeSlide);
+        let nextIndex;
+        if (direction === 'next') {
+            nextIndex = activeIndex === totalSlides - 1 ? 0 : activeIndex + 1;
+        }
+        else {
+            nextIndex = activeIndex === 0 ? totalSlides - 1 : activeIndex - 1;
+        }
+        const nextSlide = slides?.[nextIndex];
+        slides?.forEach((slide) => slide?.classList.remove('prev-1', 'next-1', 'prev-2', 'next-2', 'active'));
+        nextSlide?.classList.add('active');
+        const prev1Index = nextIndex === 0 ? totalSlides - 1 : nextIndex - 1;
+        const prev2Index = prev1Index === 0 ? totalSlides - 1 : prev1Index - 1;
+        const next1Index = nextIndex === totalSlides - 1 ? 0 : nextIndex + 1;
+        const next2Index = next1Index === totalSlides - 1 ? 0 : next1Index + 1;
+        slides?.[prev1Index]?.classList.add('prev-1');
+        slides?.[prev2Index]?.classList.add('prev-2');
+        slides?.[next1Index]?.classList.add('next-1');
+        slides?.[next2Index]?.classList.add('next-2');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonCustomSliderDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: BabylonCustomSliderDirective, isStandalone: true, selector: "[BabylonCustomSlider]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BabylonCustomSliderDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[BabylonCustomSlider]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }] });
+//# sourceMappingURL=data:application/json;base64,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