@elxjs/ui 0.0.178 → 0.0.179

package/esm2022/lib/components/carousel-fixed/carousel-fixed.component.mjs

@@ -0,0 +1,313 @@
+import { CommonModule } from '@angular/common';
+import { Component, ContentChildren, ElementRef, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { EluxIcon } from '../icon';
+import * as i0 from "@angular/core";
+export class EluxCarouselFixedComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.itemWidth = 200; // Fixed width in pixels
+        this.gap = 16; // Gap between items in pixels
+        this.removeArrows = false;
+        this.previousClickEventEmitter = new EventEmitter();
+        this.nextClickEventEmitter = new EventEmitter();
+        this.currentIndex = 0;
+        this.translateX = 0;
+        this.isDragging = false;
+        this.startX = 0;
+        this.currentX = 0;
+        this.initialTranslateX = 0;
+        this.dragOffset = 0;
+        this.containerWidth = 0;
+        this.maxTranslateX = 0;
+        this.minTranslateX = 0;
+        this.velocity = 0;
+        this.lastMoveTime = 0;
+        this.lastMoveX = 0;
+    }
+    ngAfterContentInit() {
+        this.calculateDimensions();
+        this.setItemWidths();
+        this.updateLimits();
+        this.items.changes.subscribe(() => {
+            this.calculateDimensions();
+            this.setItemWidths();
+            this.updateLimits();
+            this.goToFirstItem();
+        });
+        window.addEventListener('resize', () => this.onResize());
+    }
+    ngOnDestroy() {
+        window.removeEventListener('resize', () => this.onResize());
+    }
+    calculateDimensions() {
+        if (this.slidesContainer) {
+            this.containerWidth = this.slidesContainer.nativeElement.offsetWidth;
+        }
+    }
+    updateLimits() {
+        const totalWidth = this.items.length * (this.itemWidth + this.gap) - this.gap;
+        this.maxTranslateX = 0;
+        // Calculate minimum translateX to ensure last item is fully visible
+        if (totalWidth > this.containerWidth) {
+            this.minTranslateX = this.containerWidth - totalWidth;
+            // Add some padding to ensure last item is completely visible
+            const paddingOffset = this.gap;
+            this.minTranslateX -= paddingOffset;
+        }
+        else {
+            this.minTranslateX = 0;
+        }
+    }
+    onResize() {
+        this.calculateDimensions();
+        this.updateLimits();
+        this.updateTransform();
+    }
+    setItemWidths() {
+        this.items.forEach((item) => {
+            this.renderer.setStyle(item.nativeElement, 'width', `${this.itemWidth}px`);
+            this.renderer.setStyle(item.nativeElement, 'flex-shrink', '0');
+            this.renderer.setStyle(item.nativeElement, 'margin-right', `${this.gap}px`);
+        });
+        // Remove margin from last item
+        if (this.items.last) {
+            this.renderer.setStyle(this.items.last.nativeElement, 'margin-right', '0');
+        }
+    }
+    // Mouse events
+    onMouseDown(event) {
+        event.preventDefault();
+        this.startDrag(event.clientX);
+    }
+    onMouseMove(event) {
+        if (this.isDragging) {
+            event.preventDefault();
+            this.updateDrag(event.clientX);
+        }
+    }
+    onMouseUp(event) {
+        if (this.isDragging) {
+            this.endDrag();
+        }
+    }
+    onMouseLeave(event) {
+        if (this.isDragging) {
+            this.endDrag();
+        }
+    }
+    // Touch events
+    onTouchStart(event) {
+        event.preventDefault();
+        this.startDrag(event.touches[0].clientX);
+    }
+    onTouchMove(event) {
+        if (this.isDragging) {
+            event.preventDefault();
+            this.updateDrag(event.touches[0].clientX);
+        }
+    }
+    onTouchEnd(event) {
+        if (this.isDragging) {
+            this.endDrag();
+        }
+    }
+    startDrag(clientX) {
+        this.isDragging = true;
+        this.startX = clientX;
+        this.currentX = clientX;
+        this.initialTranslateX = this.translateX;
+        this.dragOffset = 0;
+        this.velocity = 0;
+        this.lastMoveTime = Date.now();
+        this.lastMoveX = clientX;
+        this.calculateDimensions();
+        this.renderer.setStyle(this.slidesContainer.nativeElement, 'transition', 'none');
+    }
+    updateDrag(clientX) {
+        if (!this.isDragging)
+            return;
+        this.currentX = clientX;
+        const deltaX = this.currentX - this.startX;
+        const now = Date.now();
+        const timeDelta = now - this.lastMoveTime;
+        if (timeDelta > 0) {
+            this.velocity = (clientX - this.lastMoveX) / timeDelta;
+        }
+        this.lastMoveTime = now;
+        this.lastMoveX = clientX;
+        let resistedDeltaX = deltaX;
+        const potentialTranslateX = this.initialTranslateX + deltaX;
+        // Apply softer resistance at boundaries
+        if (potentialTranslateX > this.maxTranslateX) {
+            const overDrag = potentialTranslateX - this.maxTranslateX;
+            resistedDeltaX = deltaX - (overDrag * 0.5); // Reduced resistance for more natural feel
+        }
+        else if (potentialTranslateX < this.minTranslateX) {
+            const overDrag = this.minTranslateX - potentialTranslateX;
+            resistedDeltaX = deltaX + (overDrag * 0.5); // Reduced resistance for more natural feel
+        }
+        this.dragOffset = resistedDeltaX;
+        this.updateDragPosition();
+    }
+    updateDragPosition() {
+        const newTranslateX = this.initialTranslateX + this.dragOffset;
+        this.renderer.setStyle(this.slidesContainer.nativeElement, 'transform', `translateX(${newTranslateX}px)`);
+    }
+    endDrag() {
+        if (!this.isDragging)
+            return;
+        this.isDragging = false;
+        this.renderer.setStyle(this.slidesContainer.nativeElement, 'transition', 'transform 0.3s ease-out');
+        // Calculate how far we've actually moved in terms of items
+        const currentTranslateX = this.initialTranslateX + this.dragOffset;
+        const itemStep = this.itemWidth + this.gap;
+        const movedItemsFloat = Math.abs(currentTranslateX - this.initialTranslateX) / itemStep;
+        // More sensitive thresholds
+        const minThreshold = 0.3; // 30% of an item width
+        const dragDistance = Math.abs(this.currentX - this.startX);
+        const momentumThreshold = 0.3;
+        const hasSignificantVelocity = Math.abs(this.velocity) > momentumThreshold;
+        // If we've moved more than 30% of an item width OR have significant velocity
+        if (movedItemsFloat > minThreshold || hasSignificantVelocity || dragDistance > 60) {
+            // Calculate how many items to advance based on actual drag distance
+            let itemsToAdvance = Math.round(movedItemsFloat);
+            // For velocity-based movement, use a separate calculation
+            if (hasSignificantVelocity && movedItemsFloat < 1) {
+                const velocityMultiplier = Math.abs(this.velocity) * 2;
+                itemsToAdvance = Math.max(1, Math.floor(velocityMultiplier));
+            }
+            // Ensure minimum 1 item for significant drags, but don't double count
+            if (itemsToAdvance === 0 && movedItemsFloat >= minThreshold) {
+                itemsToAdvance = 1;
+            }
+            if (this.dragOffset > 0 || (hasSignificantVelocity && this.velocity > 0)) {
+                // Dragged right - go to previous items
+                this.goToPreviousItems(itemsToAdvance);
+            }
+            else if (this.dragOffset < 0 || (hasSignificantVelocity && this.velocity < 0)) {
+                // Dragged left - go to next items
+                this.goToNextItems(itemsToAdvance);
+            }
+            else {
+                this.snapToNearestItem();
+            }
+        }
+        else {
+            // Small movement - snap to nearest item
+            this.snapToNearestItem();
+        }
+        this.dragOffset = 0;
+        this.velocity = 0;
+    }
+    snapToNearestItem() {
+        const currentTranslateX = this.initialTranslateX + this.dragOffset;
+        const itemStep = this.itemWidth + this.gap;
+        // Find the closest valid position
+        let targetIndex = Math.round(-currentTranslateX / itemStep);
+        // Clamp to valid bounds
+        const maxIndex = this.getMaxIndex();
+        targetIndex = Math.max(0, Math.min(targetIndex, maxIndex));
+        this.currentIndex = targetIndex;
+        this.updateTransform();
+    }
+    goToPreviousItems(itemCount) {
+        // Use the current index instead of visual calculation to avoid double movement
+        const newIndex = Math.max(0, this.currentIndex - itemCount);
+        if (newIndex !== this.currentIndex) {
+            this.currentIndex = newIndex;
+            this.updateTransform();
+            this.previousClickEventEmitter.emit();
+        }
+        else {
+            this.snapToNearestItem();
+        }
+    }
+    goToNextItems(itemCount) {
+        // Use the current index instead of visual calculation to avoid double movement
+        const maxIndex = this.getMaxIndex();
+        const newIndex = Math.min(maxIndex, this.currentIndex + itemCount);
+        if (newIndex !== this.currentIndex) {
+            this.currentIndex = newIndex;
+            this.updateTransform();
+            this.nextClickEventEmitter.emit();
+        }
+        else {
+            this.snapToNearestItem();
+        }
+    }
+    canGoPrevious() {
+        return this.currentIndex > 0;
+    }
+    canGoNext() {
+        return this.currentIndex < this.getMaxIndex();
+    }
+    goToFirstItem() {
+        this.currentIndex = 0;
+        this.updateTransform();
+    }
+    prevItem() {
+        if (this.canGoPrevious()) {
+            this.currentIndex--;
+            this.updateTransform();
+            this.previousClickEventEmitter.emit();
+        }
+    }
+    nextItem() {
+        if (this.canGoNext()) {
+            this.currentIndex++;
+            this.updateTransform();
+            this.nextClickEventEmitter.emit();
+        }
+    }
+    updateTransform() {
+        const itemStep = this.itemWidth + this.gap;
+        this.translateX = -this.currentIndex * itemStep;
+        // Apply strict boundaries to ensure last item is always fully visible
+        this.translateX = Math.max(this.minTranslateX, Math.min(this.maxTranslateX, this.translateX));
+        // Recalculate currentIndex based on actual translateX to stay in sync
+        if (this.translateX <= this.minTranslateX) {
+            this.currentIndex = this.getMaxIndex();
+        }
+        else {
+            this.currentIndex = Math.max(0, Math.min(this.currentIndex, this.getMaxIndex()));
+        }
+        if (!this.isDragging && this.slidesContainer) {
+            this.renderer.setStyle(this.slidesContainer.nativeElement, 'transform', `translateX(${this.translateX}px)`);
+        }
+    }
+    getMaxIndex() {
+        const visibleWidth = this.containerWidth;
+        const totalItemsWidth = this.items.length * (this.itemWidth + this.gap) - this.gap;
+        if (totalItemsWidth <= visibleWidth) {
+            return 0;
+        }
+        // Calculate how many complete items can fit in the visible area
+        const itemsPerView = Math.floor(visibleWidth / (this.itemWidth + this.gap));
+        // Maximum index ensures the last item is always fully visible
+        const maxIndex = Math.max(0, this.items.length - itemsPerView);
+        return maxIndex;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EluxCarouselFixedComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: EluxCarouselFixedComponent, isStandalone: true, selector: "lib-elux-carousel-fixed", inputs: { itemWidth: "itemWidth", gap: "gap", removeArrows: "removeArrows" }, outputs: { previousClickEventEmitter: "previousClickEventEmitter", nextClickEventEmitter: "nextClickEventEmitter" }, queries: [{ propertyName: "items", predicate: ["carouselItem"], read: ElementRef }], viewQueries: [{ propertyName: "slidesContainer", first: true, predicate: ["slidesContainer"], descendants: true }], ngImport: i0, template: "<div class=\"c-carousel-fixed-container\">\n  <div \n    class=\"c-carousel-fixed-slides\" \n    #slidesContainer\n    [style.transform]=\"'translateX(' + translateX + 'px)'\" \n    (mousedown)=\"onMouseDown($event)\"\n    (mousemove)=\"onMouseMove($event)\"\n    (mouseup)=\"onMouseUp($event)\"\n    (mouseleave)=\"onMouseLeave($event)\"\n    (touchstart)=\"onTouchStart($event)\" \n    (touchmove)=\"onTouchMove($event)\" \n    (touchend)=\"onTouchEnd($event)\">\n    <ng-content></ng-content>\n  </div>\n\n  <div class=\"c-carousel-fixed-footer\" [hidden]=\"removeArrows\">\n    <button \n      class=\"c-carousel-fixed-nav prev\" \n      [disabled]=\"!canGoPrevious()\"\n      title=\"Item anterior\" \n      aria-label=\"Item anterior\" \n      (click)=\"prevItem()\">\n      <lib-elux-icon [icon]=\"'Chevron_Left.svg'\" [size]=\"'16'\" [sizeType]=\"'px'\" [color]=\"'#020F2E'\"></lib-elux-icon>\n    </button>\n\n    <button \n      class=\"c-carousel-fixed-nav next\" \n      [disabled]=\"!canGoNext()\"\n      title=\"Pr\u00F3ximo item\" \n      aria-label=\"Pr\u00F3ximo item\" \n      (click)=\"nextItem()\">\n      <lib-elux-icon [icon]=\"'Chevron_Right.svg'\" [size]=\"'16'\" [sizeType]=\"'px'\" [color]=\"'#020F2E'\"></lib-elux-icon>\n    </button>\n  </div>\n</div>\n", styles: [".c-carousel-fixed-container{position:relative;width:100%;padding-right:16px}.c-carousel-fixed-slides{display:flex;transition:transform .3s ease-out;touch-action:pan-y;cursor:grab;-webkit-user-select:none;user-select:none;will-change:transform;padding-right:16px}.c-carousel-fixed-slides:active{cursor:grabbing}.c-carousel-fixed-footer{display:flex;align-items:center;justify-content:center;gap:16px;padding:16px 0}.c-carousel-fixed-footer .c-carousel-fixed-nav{background:none;border:none;cursor:pointer;padding:8px;border-radius:50px;background-color:#dfe7ea;transition:all ease-in-out .2s;z-index:2}.c-carousel-fixed-footer .c-carousel-fixed-nav:hover:not(:disabled){transform:scale(1.1)}.c-carousel-fixed-footer .c-carousel-fixed-nav:disabled{opacity:.5;cursor:not-allowed}.c-carousel-fixed-footer .c-carousel-fixed-nav:disabled:hover{transform:none}.c-carousel-fixed-footer .c-carousel-fixed-nav ::ng-deep span{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: EluxIcon, selector: "lib-elux-icon", inputs: ["color", "useSubscription", "icon", "description", "size", "height", "width", "sizeType"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EluxCarouselFixedComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'lib-elux-carousel-fixed', imports: [CommonModule, EluxIcon], template: "<div class=\"c-carousel-fixed-container\">\n  <div \n    class=\"c-carousel-fixed-slides\" \n    #slidesContainer\n    [style.transform]=\"'translateX(' + translateX + 'px)'\" \n    (mousedown)=\"onMouseDown($event)\"\n    (mousemove)=\"onMouseMove($event)\"\n    (mouseup)=\"onMouseUp($event)\"\n    (mouseleave)=\"onMouseLeave($event)\"\n    (touchstart)=\"onTouchStart($event)\" \n    (touchmove)=\"onTouchMove($event)\" \n    (touchend)=\"onTouchEnd($event)\">\n    <ng-content></ng-content>\n  </div>\n\n  <div class=\"c-carousel-fixed-footer\" [hidden]=\"removeArrows\">\n    <button \n      class=\"c-carousel-fixed-nav prev\" \n      [disabled]=\"!canGoPrevious()\"\n      title=\"Item anterior\" \n      aria-label=\"Item anterior\" \n      (click)=\"prevItem()\">\n      <lib-elux-icon [icon]=\"'Chevron_Left.svg'\" [size]=\"'16'\" [sizeType]=\"'px'\" [color]=\"'#020F2E'\"></lib-elux-icon>\n    </button>\n\n    <button \n      class=\"c-carousel-fixed-nav next\" \n      [disabled]=\"!canGoNext()\"\n      title=\"Pr\u00F3ximo item\" \n      aria-label=\"Pr\u00F3ximo item\" \n      (click)=\"nextItem()\">\n      <lib-elux-icon [icon]=\"'Chevron_Right.svg'\" [size]=\"'16'\" [sizeType]=\"'px'\" [color]=\"'#020F2E'\"></lib-elux-icon>\n    </button>\n  </div>\n</div>\n", styles: [".c-carousel-fixed-container{position:relative;width:100%;padding-right:16px}.c-carousel-fixed-slides{display:flex;transition:transform .3s ease-out;touch-action:pan-y;cursor:grab;-webkit-user-select:none;user-select:none;will-change:transform;padding-right:16px}.c-carousel-fixed-slides:active{cursor:grabbing}.c-carousel-fixed-footer{display:flex;align-items:center;justify-content:center;gap:16px;padding:16px 0}.c-carousel-fixed-footer .c-carousel-fixed-nav{background:none;border:none;cursor:pointer;padding:8px;border-radius:50px;background-color:#dfe7ea;transition:all ease-in-out .2s;z-index:2}.c-carousel-fixed-footer .c-carousel-fixed-nav:hover:not(:disabled){transform:scale(1.1)}.c-carousel-fixed-footer .c-carousel-fixed-nav:disabled{opacity:.5;cursor:not-allowed}.c-carousel-fixed-footer .c-carousel-fixed-nav:disabled:hover{transform:none}.c-carousel-fixed-footer .c-carousel-fixed-nav ::ng-deep span{display:block}\n"] }]
+        }], ctorParameters: () => [{ type: i0.Renderer2 }], propDecorators: { items: [{
+                type: ContentChildren,
+                args: ['carouselItem', { read: ElementRef }]
+            }], slidesContainer: [{
+                type: ViewChild,
+                args: ['slidesContainer']
+            }], itemWidth: [{
+                type: Input
+            }], gap: [{
+                type: Input
+            }], removeArrows: [{
+                type: Input
+            }], previousClickEventEmitter: [{
+                type: Output
+            }], nextClickEventEmitter: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"carousel-fixed.component.js","sourceRoot":"","sources":["../../../../../../../ui/library/src/lib/components/carousel-fixed/carousel-fixed.component.ts","../../../../../../../ui/library/src/lib/components/carousel-fixed/carousel-fixed.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { AfterContentInit, Component, ContentChildren, ElementRef, EventEmitter, Input, OnDestroy, Output, QueryList, Renderer2, ViewChild } from '@angular/core';\nimport { EluxIcon } from '../icon';\n\n@Component({\n  standalone: true,\n  selector: 'lib-elux-carousel-fixed',\n  templateUrl: './carousel-fixed.component.html',\n  styleUrls: ['./carousel-fixed.component.scss'],\n  imports: [CommonModule, EluxIcon],\n})\nexport class EluxCarouselFixedComponent implements AfterContentInit, OnDestroy {\n  @ContentChildren('carouselItem', { read: ElementRef }) items!: QueryList<ElementRef>;\n  @ViewChild('slidesContainer') slidesContainer!: ElementRef;\n\n  @Input() itemWidth: number = 200; // Fixed width in pixels\n  @Input() gap: number = 16; // Gap between items in pixels\n  @Input() removeArrows: boolean = false;\n\n  @Output() previousClickEventEmitter = new EventEmitter<Event>();\n  @Output() nextClickEventEmitter = new EventEmitter<Event>();\n\n  currentIndex = 0;\n  translateX = 0;\n\n  private isDragging = false;\n  private startX = 0;\n  private currentX = 0;\n  private initialTranslateX = 0;\n  private dragOffset = 0;\n  private containerWidth = 0;\n  private maxTranslateX = 0;\n  private minTranslateX = 0;\n  private velocity = 0;\n  private lastMoveTime = 0;\n  private lastMoveX = 0;\n\n  constructor(private renderer: Renderer2) {}\n\n  ngAfterContentInit() {\n    this.calculateDimensions();\n    this.setItemWidths();\n    this.updateLimits();\n\n    this.items.changes.subscribe(() => {\n      this.calculateDimensions();\n      this.setItemWidths();\n      this.updateLimits();\n      this.goToFirstItem();\n    });\n\n    window.addEventListener('resize', () => this.onResize());\n  }\n\n  ngOnDestroy() {\n    window.removeEventListener('resize', () => this.onResize());\n  }\n\n  private calculateDimensions() {\n    if (this.slidesContainer) {\n      this.containerWidth = this.slidesContainer.nativeElement.offsetWidth;\n    }\n  }\n\n  private updateLimits() {\n    const totalWidth = this.items.length * (this.itemWidth + this.gap) - this.gap;\n    this.maxTranslateX = 0;\n    \n    // Calculate minimum translateX to ensure last item is fully visible\n    if (totalWidth > this.containerWidth) {\n      this.minTranslateX = this.containerWidth - totalWidth;\n      \n      // Add some padding to ensure last item is completely visible\n      const paddingOffset = this.gap;\n      this.minTranslateX -= paddingOffset;\n    } else {\n      this.minTranslateX = 0;\n    }\n  }\n\n  private onResize() {\n    this.calculateDimensions();\n    this.updateLimits();\n    this.updateTransform();\n  }\n\n  private setItemWidths() {\n    this.items.forEach((item) => {\n      this.renderer.setStyle(item.nativeElement, 'width', `${this.itemWidth}px`);\n      this.renderer.setStyle(item.nativeElement, 'flex-shrink', '0');\n      this.renderer.setStyle(item.nativeElement, 'margin-right', `${this.gap}px`);\n    });\n    \n    // Remove margin from last item\n    if (this.items.last) {\n      this.renderer.setStyle(this.items.last.nativeElement, 'margin-right', '0');\n    }\n  }\n\n  // Mouse events\n  onMouseDown(event: MouseEvent) {\n    event.preventDefault();\n    this.startDrag(event.clientX);\n  }\n\n  onMouseMove(event: MouseEvent) {\n    if (this.isDragging) {\n      event.preventDefault();\n      this.updateDrag(event.clientX);\n    }\n  }\n\n  onMouseUp(event: MouseEvent) {\n    if (this.isDragging) {\n      this.endDrag();\n    }\n  }\n\n  onMouseLeave(event: MouseEvent) {\n    if (this.isDragging) {\n      this.endDrag();\n    }\n  }\n\n  // Touch events\n  onTouchStart(event: TouchEvent) {\n    event.preventDefault();\n    this.startDrag(event.touches[0].clientX);\n  }\n\n  onTouchMove(event: TouchEvent) {\n    if (this.isDragging) {\n      event.preventDefault();\n      this.updateDrag(event.touches[0].clientX);\n    }\n  }\n\n  onTouchEnd(event: TouchEvent) {\n    if (this.isDragging) {\n      this.endDrag();\n    }\n  }\n\n  private startDrag(clientX: number) {\n    this.isDragging = true;\n    this.startX = clientX;\n    this.currentX = clientX;\n    this.initialTranslateX = this.translateX;\n    this.dragOffset = 0;\n    this.velocity = 0;\n    this.lastMoveTime = Date.now();\n    this.lastMoveX = clientX;\n    \n    this.calculateDimensions();\n    \n    this.renderer.setStyle(this.slidesContainer.nativeElement, 'transition', 'none');\n  }\n\n  private updateDrag(clientX: number) {\n    if (!this.isDragging) return;\n\n    this.currentX = clientX;\n    const deltaX = this.currentX - this.startX;\n    \n    const now = Date.now();\n    const timeDelta = now - this.lastMoveTime;\n    if (timeDelta > 0) {\n      this.velocity = (clientX - this.lastMoveX) / timeDelta;\n    }\n    this.lastMoveTime = now;\n    this.lastMoveX = clientX;\n\n    let resistedDeltaX = deltaX;\n    const potentialTranslateX = this.initialTranslateX + deltaX;\n    \n    // Apply softer resistance at boundaries\n    if (potentialTranslateX > this.maxTranslateX) {\n      const overDrag = potentialTranslateX - this.maxTranslateX;\n      resistedDeltaX = deltaX - (overDrag * 0.5); // Reduced resistance for more natural feel\n    } else if (potentialTranslateX < this.minTranslateX) {\n      const overDrag = this.minTranslateX - potentialTranslateX;\n      resistedDeltaX = deltaX + (overDrag * 0.5); // Reduced resistance for more natural feel\n    }\n\n    this.dragOffset = resistedDeltaX;\n    this.updateDragPosition();\n  }\n\n  private updateDragPosition() {\n    const newTranslateX = this.initialTranslateX + this.dragOffset;\n    this.renderer.setStyle(\n      this.slidesContainer.nativeElement, \n      'transform', \n      `translateX(${newTranslateX}px)`\n    );\n  }\n\n  private endDrag() {\n    if (!this.isDragging) return;\n\n    this.isDragging = false;\n    \n    this.renderer.setStyle(this.slidesContainer.nativeElement, 'transition', 'transform 0.3s ease-out');\n\n    // Calculate how far we've actually moved in terms of items\n    const currentTranslateX = this.initialTranslateX + this.dragOffset;\n    const itemStep = this.itemWidth + this.gap;\n    const movedItemsFloat = Math.abs(currentTranslateX - this.initialTranslateX) / itemStep;\n    \n    // More sensitive thresholds\n    const minThreshold = 0.3; // 30% of an item width\n    const dragDistance = Math.abs(this.currentX - this.startX);\n    const momentumThreshold = 0.3;\n    const hasSignificantVelocity = Math.abs(this.velocity) > momentumThreshold;\n    \n    // If we've moved more than 30% of an item width OR have significant velocity\n    if (movedItemsFloat > minThreshold || hasSignificantVelocity || dragDistance > 60) {\n      \n      // Calculate how many items to advance based on actual drag distance\n      let itemsToAdvance = Math.round(movedItemsFloat);\n      \n      // For velocity-based movement, use a separate calculation\n      if (hasSignificantVelocity && movedItemsFloat < 1) {\n        const velocityMultiplier = Math.abs(this.velocity) * 2;\n        itemsToAdvance = Math.max(1, Math.floor(velocityMultiplier));\n      }\n      \n      // Ensure minimum 1 item for significant drags, but don't double count\n      if (itemsToAdvance === 0 && movedItemsFloat >= minThreshold) {\n        itemsToAdvance = 1;\n      }\n      \n      if (this.dragOffset > 0 || (hasSignificantVelocity && this.velocity > 0)) {\n        // Dragged right - go to previous items\n        this.goToPreviousItems(itemsToAdvance);\n      } else if (this.dragOffset < 0 || (hasSignificantVelocity && this.velocity < 0)) {\n        // Dragged left - go to next items\n        this.goToNextItems(itemsToAdvance);\n      } else {\n        this.snapToNearestItem();\n      }\n    } else {\n      // Small movement - snap to nearest item\n      this.snapToNearestItem();\n    }\n\n    this.dragOffset = 0;\n    this.velocity = 0;\n  }\n\n  private snapToNearestItem() {\n    const currentTranslateX = this.initialTranslateX + this.dragOffset;\n    const itemStep = this.itemWidth + this.gap;\n    \n    // Find the closest valid position\n    let targetIndex = Math.round(-currentTranslateX / itemStep);\n    \n    // Clamp to valid bounds\n    const maxIndex = this.getMaxIndex();\n    targetIndex = Math.max(0, Math.min(targetIndex, maxIndex));\n    \n    this.currentIndex = targetIndex;\n    this.updateTransform();\n  }\n\n  private goToPreviousItems(itemCount: number) {\n    // Use the current index instead of visual calculation to avoid double movement\n    const newIndex = Math.max(0, this.currentIndex - itemCount);\n    \n    if (newIndex !== this.currentIndex) {\n      this.currentIndex = newIndex;\n      this.updateTransform();\n      this.previousClickEventEmitter.emit();\n    } else {\n      this.snapToNearestItem();\n    }\n  }\n\n  private goToNextItems(itemCount: number) {\n    // Use the current index instead of visual calculation to avoid double movement\n    const maxIndex = this.getMaxIndex();\n    const newIndex = Math.min(maxIndex, this.currentIndex + itemCount);\n    \n    if (newIndex !== this.currentIndex) {\n      this.currentIndex = newIndex;\n      this.updateTransform();\n      this.nextClickEventEmitter.emit();\n    } else {\n      this.snapToNearestItem();\n    }\n  }\n\n  canGoPrevious(): boolean {\n    return this.currentIndex > 0;\n  }\n\n  canGoNext(): boolean {\n    return this.currentIndex < this.getMaxIndex();\n  }\n\n  goToFirstItem() {\n    this.currentIndex = 0;\n    this.updateTransform();\n  }\n\n  prevItem() {\n    if (this.canGoPrevious()) {\n      this.currentIndex--;\n      this.updateTransform();\n      this.previousClickEventEmitter.emit();\n    }\n  }\n\n  nextItem() {\n    if (this.canGoNext()) {\n      this.currentIndex++;\n      this.updateTransform();\n      this.nextClickEventEmitter.emit();\n    }\n  }\n\n  private updateTransform() {\n    const itemStep = this.itemWidth + this.gap;\n    this.translateX = -this.currentIndex * itemStep;\n    \n    // Apply strict boundaries to ensure last item is always fully visible\n    this.translateX = Math.max(this.minTranslateX, Math.min(this.maxTranslateX, this.translateX));\n    \n    // Recalculate currentIndex based on actual translateX to stay in sync\n    if (this.translateX <= this.minTranslateX) {\n      this.currentIndex = this.getMaxIndex();\n    } else {\n      this.currentIndex = Math.max(0, Math.min(this.currentIndex, this.getMaxIndex()));\n    }\n    \n    if (!this.isDragging && this.slidesContainer) {\n      this.renderer.setStyle(\n        this.slidesContainer.nativeElement, \n        'transform', \n        `translateX(${this.translateX}px)`\n      );\n    }\n  }\n\n  private getMaxIndex(): number {\n    const visibleWidth = this.containerWidth;\n    const totalItemsWidth = this.items.length * (this.itemWidth + this.gap) - this.gap;\n    \n    if (totalItemsWidth <= visibleWidth) {\n      return 0;\n    }\n    \n    // Calculate how many complete items can fit in the visible area\n    const itemsPerView = Math.floor(visibleWidth / (this.itemWidth + this.gap));\n    \n    // Maximum index ensures the last item is always fully visible\n    const maxIndex = Math.max(0, this.items.length - itemsPerView);\n    \n    return maxIndex;\n  }\n}\n","<div class=\"c-carousel-fixed-container\">\n  <div \n    class=\"c-carousel-fixed-slides\" \n    #slidesContainer\n    [style.transform]=\"'translateX(' + translateX + 'px)'\" \n    (mousedown)=\"onMouseDown($event)\"\n    (mousemove)=\"onMouseMove($event)\"\n    (mouseup)=\"onMouseUp($event)\"\n    (mouseleave)=\"onMouseLeave($event)\"\n    (touchstart)=\"onTouchStart($event)\" \n    (touchmove)=\"onTouchMove($event)\" \n    (touchend)=\"onTouchEnd($event)\">\n    <ng-content></ng-content>\n  </div>\n\n  <div class=\"c-carousel-fixed-footer\" [hidden]=\"removeArrows\">\n    <button \n      class=\"c-carousel-fixed-nav prev\" \n      [disabled]=\"!canGoPrevious()\"\n      title=\"Item anterior\" \n      aria-label=\"Item anterior\" \n      (click)=\"prevItem()\">\n      <lib-elux-icon [icon]=\"'Chevron_Left.svg'\" [size]=\"'16'\" [sizeType]=\"'px'\" [color]=\"'#020F2E'\"></lib-elux-icon>\n    </button>\n\n    <button \n      class=\"c-carousel-fixed-nav next\" \n      [disabled]=\"!canGoNext()\"\n      title=\"Próximo item\" \n      aria-label=\"Próximo item\" \n      (click)=\"nextItem()\">\n      <lib-elux-icon [icon]=\"'Chevron_Right.svg'\" [size]=\"'16'\" [sizeType]=\"'px'\" [color]=\"'#020F2E'\"></lib-elux-icon>\n    </button>\n  </div>\n</div>\n"]}

package/esm2022/lib/components/index.mjs

@@ -57,7 +57,8 @@ export * from './card-4';
 export * from './dropdown-multiple';
 export * from './loading-2';
 export * from './carousel';
+export * from './carousel-fixed/carousel-fixed.component';
 export * from './arrow-link';
 export * from './switch';
 export * from './chip';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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