ngx-edge-slider 2.1.4 → 2.1.6

package/esm2022/lib/component/simple-slider.component.mjs

@@ -0,0 +1,215 @@
+import { Component, ChangeDetectionStrategy, Input, EventEmitter, Output, ViewChild, ViewEncapsulation, } from "@angular/core";
+import { Subject, takeUntil } from "rxjs";
+import { SliderEngine } from "../engine/slider-engine.service";
+import { SliderStore } from "../store/slider-store.service";
+import { SliderAutoplayPlugin } from "../plugins/autoplay/autoplay.plugin";
+import { SliderDraggablePlugin } from "../plugins/draggable/draggable.plugin";
+import { SliderNavigationPlugin } from "../plugins/navigation/navigation.plugin";
+import { SliderPaginationPlugin } from "../plugins/pagination/pagination.plugin";
+import { CommonModule } from "@angular/common";
+import * as i0 from "@angular/core";
+import * as i1 from "../engine/slider-engine.service";
+import * as i2 from "../store/slider-store.service";
+import * as i3 from "../plugins/draggable/draggable.plugin";
+import * as i4 from "../plugins/pagination/pagination.plugin";
+import * as i5 from "../plugins/navigation/navigation.plugin";
+import * as i6 from "../plugins/autoplay/autoplay.plugin";
+import * as i7 from "@angular/common";
+export class SimpleSliderComponent {
+    engine;
+    store;
+    draggable;
+    pagination;
+    navigation;
+    autoplay;
+    config;
+    slideTemplate;
+    navigationTemplate;
+    paginationTemplate;
+    slideChange = new EventEmitter();
+    isDraggingPointer = false;
+    dragStartX = 0;
+    dragStartY = 0;
+    lastIndex = -1;
+    lastSlidesRef = null;
+    destroy$ = new Subject();
+    state$;
+    sliderHost;
+    constructor(engine, store, draggable, pagination, navigation, autoplay) {
+        this.engine = engine;
+        this.store = store;
+        this.draggable = draggable;
+        this.pagination = pagination;
+        this.navigation = navigation;
+        this.autoplay = autoplay;
+    }
+    ngOnInit() {
+        this.state$ = this.store.view$;
+        this.state$.pipe(takeUntil(this.destroy$)).subscribe((state) => {
+            if (state.currentSlide !== this.lastIndex) {
+                this.lastIndex = state.currentSlide;
+                this.slideChange.emit(state.currentSlide);
+            }
+        });
+        this.lastSlidesRef = this.config?.slides ?? null;
+        this.resolvePlugins(this.config);
+    }
+    ngAfterViewInit() {
+        if (this.sliderHost?.nativeElement) {
+            this.engine.attachContainer(this.sliderHost.nativeElement);
+        }
+    }
+    ngOnChanges(changes) {
+        if (!changes["config"] || !this.config)
+            return;
+        const newSlidesRef = this.config.slides ?? null;
+        if (newSlidesRef !== this.lastSlidesRef) {
+            this.lastSlidesRef = newSlidesRef;
+            this.engine.destroy();
+            this.resolvePlugins(this.config);
+        }
+    }
+    ngOnDestroy() {
+        this.destroySlider();
+    }
+    goTo(index) {
+        this.engine.selectSlide(index); // add this line
+        //this.slideChange.emit(index);
+    }
+    destroySlider() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.engine.destroy();
+    } // destroys plugins and clears store
+    onNext() {
+        this.engine.next();
+    }
+    onPrevious() {
+        this.engine.previous();
+    }
+    selectSlide(index) {
+        this.engine.selectSlide(index);
+    }
+    onRecalculate() {
+        this.engine.recalculate();
+    }
+    // Navigation
+    /** Expose navigation observables safely */
+    get canPrev$() {
+        if (!this.navigation) {
+            console.warn("Navigation plugin is not enabled.");
+            return null;
+        }
+        return this.navigation.canPrev$;
+    }
+    get canNext$() {
+        if (!this.navigation) {
+            console.warn("Navigation plugin is not enabled.");
+            return null;
+        }
+        return this.navigation.canNext$;
+    }
+    /** Expose next/prev methods */
+    next() {
+        this.navigation?.next();
+    }
+    prev() {
+        this.navigation?.prev();
+    }
+    /** Expose pagination observable */
+    get pager$() {
+        if (!this.pagination) {
+            console.warn("Pagination plugin is not enabled for this slider.");
+            return null;
+        }
+        return this.pagination.pager$;
+    }
+    /** Expose a goToSlide method */
+    goToSlide(index) {
+        this.pagination.goToSlide(index);
+    }
+    // Handle Pointers
+    onPointerDown(event) {
+        // Only start drag if not clicking a nav button
+        if (event.target.closest(".nav-btn")) {
+            return; // ignore
+        }
+        this.dragStartX = event.clientX;
+        this.dragStartY = event.clientY;
+        this.isDraggingPointer = false;
+        // Do not capture yet; wait until movement exceeds threshold
+        this.engine.handleDragStart(event);
+    }
+    onPointerMove(event) {
+        const dx = Math.abs(event.clientX - this.dragStartX);
+        const dy = Math.abs(event.clientY - this.dragStartY);
+        if (!this.isDraggingPointer && (dx > 5 || dy > 5)) {
+            this.isDraggingPointer = true;
+            // Now start capturing pointer so dragging works outside the slider bounds
+            event.currentTarget.setPointerCapture(event.pointerId);
+        }
+        if (this.isDraggingPointer) {
+            this.engine.handleDragMove(event);
+        }
+    }
+    onPointerUp(event) {
+        if (!event)
+            return;
+        if (!this.isDraggingPointer) {
+            const target = event.target;
+            // Only select the slide if click is not on an interactive child
+            const slideEl = target.closest(".slide");
+            if (slideEl && !target.closest("button, video, a")) {
+                const indexAttr = slideEl.getAttribute("data-index");
+                const index = indexAttr ? parseInt(indexAttr, 10) : null;
+                if (index !== null)
+                    this.engine.selectSlide(index);
+            }
+        }
+        this.engine.handleDragEnd();
+        this.isDraggingPointer = false;
+        // Release pointer capture if it was captured
+        try {
+            event.currentTarget.releasePointerCapture(event.pointerId);
+        }
+        catch { }
+    }
+    resolvePlugins(config) {
+        const runtimePlugins = [];
+        const cfg = config.plugins ?? {}; // <-- safe fallback
+        if (cfg.draggable)
+            runtimePlugins.push(this.draggable);
+        if (cfg.pagination)
+            runtimePlugins.push(this.pagination);
+        if (cfg.navigation)
+            runtimePlugins.push(this.navigation);
+        if (cfg.autoplay) {
+            this.autoplay.setConfig(cfg.autoplay);
+            runtimePlugins.push(this.autoplay);
+        }
+        this.engine.init({ ...config, plugins: undefined }, runtimePlugins);
+        if (cfg.navigation) {
+            setTimeout(() => this.navigation?.updateArrows?.());
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SimpleSliderComponent, deps: [{ token: i1.SliderEngine }, { token: i2.SliderStore }, { token: i3.SliderDraggablePlugin }, { token: i4.SliderPaginationPlugin }, { token: i5.SliderNavigationPlugin }, { token: i6.SliderAutoplayPlugin }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: SimpleSliderComponent, isStandalone: true, selector: "app-simple-slider", inputs: { config: "config", slideTemplate: "slideTemplate", navigationTemplate: "navigationTemplate", paginationTemplate: "paginationTemplate" }, outputs: { slideChange: "slideChange" }, providers: [SliderEngine, SliderStore, SliderDraggablePlugin, SliderPaginationPlugin, SliderNavigationPlugin, SliderAutoplayPlugin], viewQueries: [{ propertyName: "sliderHost", first: true, predicate: ["sliderHost"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"state$ | async as state\">\r\n  <div\r\n    class=\"slider\"\r\n    #sliderHost\r\n    [class.slider-vertical]=\"state.vertical\"\r\n    [class.slider-draggable]=\"state.isDragging\"\r\n    [class.slider--main]=\"!config.isThumbs\"\r\n    [class.slider--thumbs]=\"config.isThumbs\"\r\n    *ngIf=\"state.visibleSlides?.length > 0 && state.isVisible\"\r\n    (pointerdown)=\"onPointerDown($event)\"\r\n    (pointermove)=\"onPointerMove($event)\"\r\n    (pointerup)=\"onPointerUp($event)\"\r\n    (pointercancel)=\"onPointerUp($event)\">\r\n    <div\r\n      class=\"slider__wrapper\"\r\n      [ngStyle]=\"{\r\n        transform: state.translate,\r\n        transition: draggable.isDraggingPointer ? 'none' : 'transform 0.3s ease',\r\n        display: 'flex',\r\n        'flex-direction': state.vertical ? 'column' : 'row',\r\n        'justify-content': state.visibleSlides?.length < state.slidesPerView ? 'center' : 'flex-start',\r\n        gap: (state.slidesPerView > 1 ? state.gap || 0 : 0) + 'px',\r\n      }\">\r\n      <div\r\n        *ngFor=\"let slide of state.visibleSlides; let i = index\"\r\n        class=\"slide\"\r\n        [attr.data-index]=\"i\"\r\n        [class.slide--current]=\"state.selectedSlide === i\"\r\n        [style.flex]=\"\r\n          !config.isThumbs\r\n            ? '0 0 calc(' +\r\n              100 / state.slidesPerView +\r\n              '% - ' +\r\n              ((state.gap || 0) * (state.slidesPerView - 1)) / state.slidesPerView +\r\n              'px)'\r\n            : '0 0 ' + thumbSize + 'px'\r\n        \"\r\n        [style.width]=\"config.isThumbs ? thumbSize + 'px' : null\"\r\n        [style.height]=\"config.isThumbs ? thumbSize + 'px' : null\"\r\n        (click)=\"engine.selectSlide(i)\">\r\n        <ng-container\r\n          *ngTemplateOutlet=\"slideTemplate ? slideTemplate : defaultSlideTemplate; context: { slide: slide, index: i }\"></ng-container>\r\n      </div>\r\n    </div>\r\n  </div>\r\n</ng-container>\r\n", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i7.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i7.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "pipe", type: i7.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SimpleSliderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "app-simple-slider", changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, standalone: true, imports: [CommonModule], providers: [SliderEngine, SliderStore, SliderDraggablePlugin, SliderPaginationPlugin, SliderNavigationPlugin, SliderAutoplayPlugin], template: "<ng-container *ngIf=\"state$ | async as state\">\r\n  <div\r\n    class=\"slider\"\r\n    #sliderHost\r\n    [class.slider-vertical]=\"state.vertical\"\r\n    [class.slider-draggable]=\"state.isDragging\"\r\n    [class.slider--main]=\"!config.isThumbs\"\r\n    [class.slider--thumbs]=\"config.isThumbs\"\r\n    *ngIf=\"state.visibleSlides?.length > 0 && state.isVisible\"\r\n    (pointerdown)=\"onPointerDown($event)\"\r\n    (pointermove)=\"onPointerMove($event)\"\r\n    (pointerup)=\"onPointerUp($event)\"\r\n    (pointercancel)=\"onPointerUp($event)\">\r\n    <div\r\n      class=\"slider__wrapper\"\r\n      [ngStyle]=\"{\r\n        transform: state.translate,\r\n        transition: draggable.isDraggingPointer ? 'none' : 'transform 0.3s ease',\r\n        display: 'flex',\r\n        'flex-direction': state.vertical ? 'column' : 'row',\r\n        'justify-content': state.visibleSlides?.length < state.slidesPerView ? 'center' : 'flex-start',\r\n        gap: (state.slidesPerView > 1 ? state.gap || 0 : 0) + 'px',\r\n      }\">\r\n      <div\r\n        *ngFor=\"let slide of state.visibleSlides; let i = index\"\r\n        class=\"slide\"\r\n        [attr.data-index]=\"i\"\r\n        [class.slide--current]=\"state.selectedSlide === i\"\r\n        [style.flex]=\"\r\n          !config.isThumbs\r\n            ? '0 0 calc(' +\r\n              100 / state.slidesPerView +\r\n              '% - ' +\r\n              ((state.gap || 0) * (state.slidesPerView - 1)) / state.slidesPerView +\r\n              'px)'\r\n            : '0 0 ' + thumbSize + 'px'\r\n        \"\r\n        [style.width]=\"config.isThumbs ? thumbSize + 'px' : null\"\r\n        [style.height]=\"config.isThumbs ? thumbSize + 'px' : null\"\r\n        (click)=\"engine.selectSlide(i)\">\r\n        <ng-container\r\n          *ngTemplateOutlet=\"slideTemplate ? slideTemplate : defaultSlideTemplate; context: { slide: slide, index: i }\"></ng-container>\r\n      </div>\r\n    </div>\r\n  </div>\r\n</ng-container>\r\n" }]
+        }], ctorParameters: () => [{ type: i1.SliderEngine }, { type: i2.SliderStore }, { type: i3.SliderDraggablePlugin }, { type: i4.SliderPaginationPlugin }, { type: i5.SliderNavigationPlugin }, { type: i6.SliderAutoplayPlugin }], propDecorators: { config: [{
+                type: Input
+            }], slideTemplate: [{
+                type: Input
+            }], navigationTemplate: [{
+                type: Input
+            }], paginationTemplate: [{
+                type: Input
+            }], slideChange: [{
+                type: Output
+            }], sliderHost: [{
+                type: ViewChild,
+                args: ["sliderHost", { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-slider.component.js","sourceRoot":"","sources":["../../../../../projects/ngx-edge-slider/src/lib/component/simple-slider.component.ts","../../../../../projects/ngx-edge-slider/src/lib/component/simple-slider.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  ChangeDetectionStrategy,\r\n  OnInit,\r\n  TemplateRef,\r\n  Input,\r\n  EventEmitter,\r\n  Output,\r\n  SimpleChanges,\r\n  OnChanges,\r\n  OnDestroy,\r\n  ViewChild,\r\n  ElementRef,\r\n  AfterViewInit,\r\n  ViewEncapsulation,\r\n} from \"@angular/core\";\r\nimport { SliderViewState } from \"../models/slider-state.model\";\r\nimport { Observable, Subject, takeUntil } from \"rxjs\";\r\nimport { SliderConfig } from \"../models/slider-config.model\";\r\nimport { SliderEngine } from \"../engine/slider-engine.service\";\r\nimport { SliderStore } from \"../store/slider-store.service\";\r\nimport { SliderAutoplayPlugin } from \"../plugins/autoplay/autoplay.plugin\";\r\nimport { SliderDraggablePlugin } from \"../plugins/draggable/draggable.plugin\";\r\nimport { SliderNavigationPlugin } from \"../plugins/navigation/navigation.plugin\";\r\nimport { SliderPaginationPlugin } from \"../plugins/pagination/pagination.plugin\";\r\nimport { Pager, SliderPlugin } from \"../plugins/slider-plugin\";\r\nimport { CommonModule } from \"@angular/common\";\r\n\r\n@Component({\r\n  selector: \"app-simple-slider\",\r\n  templateUrl: \"./simple-slider.component.html\",\r\n  styleUrl: \"./simple-slider.component.scss\",\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  encapsulation: ViewEncapsulation.None,\r\n  standalone: true,\r\n  imports: [CommonModule],\r\n  providers: [SliderEngine, SliderStore, SliderDraggablePlugin, SliderPaginationPlugin, SliderNavigationPlugin, SliderAutoplayPlugin],\r\n})\r\nexport class SimpleSliderComponent implements OnInit, AfterViewInit, OnChanges, OnDestroy {\r\n  @Input() config!: SliderConfig;\r\n  @Input() slideTemplate?: TemplateRef<any>;\r\n  @Input() navigationTemplate?: TemplateRef<any>;\r\n  @Input() paginationTemplate?: TemplateRef<any>;\r\n  @Output() slideChange = new EventEmitter<number>();\r\n\r\n  private isDraggingPointer = false;\r\n  private dragStartX = 0;\r\n  private dragStartY = 0;\r\n  private lastIndex = -1;\r\n  private lastSlidesRef: any[] | null = null;\r\n  private destroy$ = new Subject<void>();\r\n\r\n  state$!: Observable<SliderViewState>;\r\n  @ViewChild(\"sliderHost\", { static: false }) sliderHost?: ElementRef<HTMLElement>;\r\n\r\n  constructor(\r\n    private engine: SliderEngine,\r\n    private store: SliderStore,\r\n    private draggable: SliderDraggablePlugin,\r\n    private pagination: SliderPaginationPlugin,\r\n    private navigation: SliderNavigationPlugin,\r\n    private autoplay: SliderAutoplayPlugin,\r\n  ) {}\r\n\r\n  ngOnInit() {\r\n    this.state$ = this.store.view$;\r\n\r\n    this.state$.pipe(takeUntil(this.destroy$)).subscribe((state) => {\r\n      if (state.currentSlide !== this.lastIndex) {\r\n        this.lastIndex = state.currentSlide;\r\n        this.slideChange.emit(state.currentSlide);\r\n      }\r\n    });\r\n    this.lastSlidesRef = this.config?.slides ?? null;\r\n    this.resolvePlugins(this.config);\r\n  }\r\n  ngAfterViewInit() {\r\n    if (this.sliderHost?.nativeElement) {\r\n      this.engine.attachContainer(this.sliderHost.nativeElement);\r\n    }\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    if (!changes[\"config\"] || !this.config) return;\r\n\r\n    const newSlidesRef = this.config.slides ?? null;\r\n\r\n    if (newSlidesRef !== this.lastSlidesRef) {\r\n      this.lastSlidesRef = newSlidesRef;\r\n      this.engine.destroy();\r\n      this.resolvePlugins(this.config);\r\n    }\r\n  }\r\n  ngOnDestroy() {\r\n    this.destroySlider();\r\n  }\r\n\r\n  public goTo(index: number) {\r\n    this.engine.selectSlide(index); // add this line\r\n    //this.slideChange.emit(index);\r\n  }\r\n\r\n  destroySlider() {\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n    this.engine.destroy();\r\n  } // destroys plugins and clears store\r\n\r\n  onNext() {\r\n    this.engine.next();\r\n  }\r\n  onPrevious() {\r\n    this.engine.previous();\r\n  }\r\n  selectSlide(index: number) {\r\n    this.engine.selectSlide(index);\r\n  }\r\n  onRecalculate() {\r\n    this.engine.recalculate();\r\n  }\r\n  // Navigation\r\n  /** Expose navigation observables safely */\r\n  get canPrev$(): Observable<boolean> | null {\r\n    if (!this.navigation) {\r\n      console.warn(\"Navigation plugin is not enabled.\");\r\n      return null;\r\n    }\r\n    return this.navigation.canPrev$;\r\n  }\r\n\r\n  get canNext$(): Observable<boolean> | null {\r\n    if (!this.navigation) {\r\n      console.warn(\"Navigation plugin is not enabled.\");\r\n      return null;\r\n    }\r\n    return this.navigation.canNext$;\r\n  }\r\n\r\n  /** Expose next/prev methods */\r\n  public next() {\r\n    this.navigation?.next();\r\n  }\r\n\r\n  public prev() {\r\n    this.navigation?.prev();\r\n  }\r\n\r\n  /** Expose pagination observable */\r\n  get pager$(): Observable<Pager | null> | null {\r\n    if (!this.pagination) {\r\n      console.warn(\"Pagination plugin is not enabled for this slider.\");\r\n      return null;\r\n    }\r\n    return this.pagination.pager$;\r\n  }\r\n\r\n  /** Expose a goToSlide method */\r\n  public goToSlide(index: number) {\r\n    this.pagination.goToSlide(index);\r\n  }\r\n\r\n  // Handle Pointers\r\n\r\n  onPointerDown(event: PointerEvent) {\r\n    // Only start drag if not clicking a nav button\r\n    if ((event.target as HTMLElement).closest(\".nav-btn\")) {\r\n      return; // ignore\r\n    }\r\n    this.dragStartX = event.clientX;\r\n    this.dragStartY = event.clientY;\r\n    this.isDraggingPointer = false;\r\n\r\n    // Do not capture yet; wait until movement exceeds threshold\r\n    this.engine.handleDragStart(event);\r\n  }\r\n\r\n  onPointerMove(event: PointerEvent) {\r\n    const dx = Math.abs(event.clientX - this.dragStartX);\r\n    const dy = Math.abs(event.clientY - this.dragStartY);\r\n\r\n    if (!this.isDraggingPointer && (dx > 5 || dy > 5)) {\r\n      this.isDraggingPointer = true;\r\n\r\n      // Now start capturing pointer so dragging works outside the slider bounds\r\n      (event.currentTarget as HTMLElement).setPointerCapture(event.pointerId);\r\n    }\r\n\r\n    if (this.isDraggingPointer) {\r\n      this.engine.handleDragMove(event);\r\n    }\r\n  }\r\n\r\n  onPointerUp(event: PointerEvent) {\r\n    if (!event) return;\r\n\r\n    if (!this.isDraggingPointer) {\r\n      const target = event.target as HTMLElement;\r\n\r\n      // Only select the slide if click is not on an interactive child\r\n      const slideEl = target.closest(\".slide\");\r\n      if (slideEl && !target.closest(\"button, video, a\")) {\r\n        const indexAttr = slideEl.getAttribute(\"data-index\");\r\n        const index = indexAttr ? parseInt(indexAttr, 10) : null;\r\n        if (index !== null) this.engine.selectSlide(index);\r\n      }\r\n    }\r\n\r\n    this.engine.handleDragEnd();\r\n    this.isDraggingPointer = false;\r\n\r\n    // Release pointer capture if it was captured\r\n    try {\r\n      (event.currentTarget as HTMLElement).releasePointerCapture(event.pointerId);\r\n    } catch {}\r\n  }\r\n\r\n  private resolvePlugins(config: SliderConfig) {\r\n    const runtimePlugins: SliderPlugin[] = [];\r\n\r\n    const cfg = config.plugins ?? {}; // <-- safe fallback\r\n\r\n    if (cfg.draggable) runtimePlugins.push(this.draggable);\r\n    if (cfg.pagination) runtimePlugins.push(this.pagination);\r\n    if (cfg.navigation) runtimePlugins.push(this.navigation);\r\n\r\n    if (cfg.autoplay) {\r\n      this.autoplay.setConfig(cfg.autoplay);\r\n      runtimePlugins.push(this.autoplay);\r\n    }\r\n\r\n    this.engine.init({ ...config, plugins: undefined }, runtimePlugins);\r\n\r\n    if (cfg.navigation) {\r\n      setTimeout(() => this.navigation?.updateArrows?.());\r\n    }\r\n  }\r\n}\r\n","<ng-container *ngIf=\"state$ | async as state\">\r\n  <div\r\n    class=\"slider\"\r\n    #sliderHost\r\n    [class.slider-vertical]=\"state.vertical\"\r\n    [class.slider-draggable]=\"state.isDragging\"\r\n    [class.slider--main]=\"!config.isThumbs\"\r\n    [class.slider--thumbs]=\"config.isThumbs\"\r\n    *ngIf=\"state.visibleSlides?.length > 0 && state.isVisible\"\r\n    (pointerdown)=\"onPointerDown($event)\"\r\n    (pointermove)=\"onPointerMove($event)\"\r\n    (pointerup)=\"onPointerUp($event)\"\r\n    (pointercancel)=\"onPointerUp($event)\">\r\n    <div\r\n      class=\"slider__wrapper\"\r\n      [ngStyle]=\"{\r\n        transform: state.translate,\r\n        transition: draggable.isDraggingPointer ? 'none' : 'transform 0.3s ease',\r\n        display: 'flex',\r\n        'flex-direction': state.vertical ? 'column' : 'row',\r\n        'justify-content': state.visibleSlides?.length < state.slidesPerView ? 'center' : 'flex-start',\r\n        gap: (state.slidesPerView > 1 ? state.gap || 0 : 0) + 'px',\r\n      }\">\r\n      <div\r\n        *ngFor=\"let slide of state.visibleSlides; let i = index\"\r\n        class=\"slide\"\r\n        [attr.data-index]=\"i\"\r\n        [class.slide--current]=\"state.selectedSlide === i\"\r\n        [style.flex]=\"\r\n          !config.isThumbs\r\n            ? '0 0 calc(' +\r\n              100 / state.slidesPerView +\r\n              '% - ' +\r\n              ((state.gap || 0) * (state.slidesPerView - 1)) / state.slidesPerView +\r\n              'px)'\r\n            : '0 0 ' + thumbSize + 'px'\r\n        \"\r\n        [style.width]=\"config.isThumbs ? thumbSize + 'px' : null\"\r\n        [style.height]=\"config.isThumbs ? thumbSize + 'px' : null\"\r\n        (click)=\"engine.selectSlide(i)\">\r\n        <ng-container\r\n          *ngTemplateOutlet=\"slideTemplate ? slideTemplate : defaultSlideTemplate; context: { slide: slide, index: i }\"></ng-container>\r\n      </div>\r\n    </div>\r\n  </div>\r\n</ng-container>\r\n"]}

package/esm2022/lib/engine/slider-engine.service.mjs

@@ -0,0 +1,288 @@
+import { Injectable } from "@angular/core";
+import { fromEvent, merge, Subject, auditTime, takeUntil } from "rxjs";
+import { DEFAULT_CONFIG } from "../models/slider-config.model";
+import * as i0 from "@angular/core";
+import * as i1 from "../store/slider-store.service";
+export class SliderEngine {
+    store;
+    config;
+    plugins = [];
+    syncThumbsEngine;
+    // RX lifecycle
+    destroy$ = new Subject();
+    // Container-based breakpoints
+    containerEl;
+    ro;
+    measuredSlideSizePx;
+    constructor(store) {
+        this.store = store;
+    }
+    /* ---------------- Public API ---------------- */
+    init(config, plugins = []) {
+        this.config = { ...DEFAULT_CONFIG, ...config, plugins: { ...(config.plugins ?? {}) } };
+        this.plugins = plugins;
+        this.plugins.forEach((p) => p.init?.(this));
+        this.setupViewportSignals();
+        this.applyBreakpoint();
+        this.clampIndicesAfterLayoutChange();
+        this.recalculate();
+    }
+    /** Call this from the component once you have the slider host element */
+    attachContainer(el) {
+        this.containerEl = el;
+        // Observe container size changes (robust in grids/sidebars/tabs)
+        this.ro?.disconnect();
+        this.ro = new ResizeObserver(() => {
+            // We reuse the same debounced layout handler
+            this.onLayoutSignal();
+        });
+        this.ro.observe(el);
+        this.measureSlideSize();
+        // Apply immediately based on real container width
+        this.onLayoutSignal();
+    }
+    measureSlideSize() {
+        if (!this.containerEl)
+            return;
+        const firstSlide = this.containerEl.querySelector(".slide");
+        if (!firstSlide)
+            return;
+        const rect = firstSlide.getBoundingClientRect();
+        if (rect.width > 0)
+            this.measuredSlideSizePx = rect.width;
+    }
+    destroy() {
+        // Stop Rx streams
+        this.destroy$.next();
+        this.destroy$.complete();
+        // Disconnect ResizeObserver
+        this.ro?.disconnect();
+        this.ro = undefined;
+        this.containerEl = undefined;
+        // Plugin cleanup
+        this.plugins.forEach((p) => p.destroy?.());
+        this.plugins = [];
+        // Reset store
+        this.store.reset();
+    }
+    next() {
+        this.goTo(this.store.snapshot.currentSlide + this.slideStep());
+        this.plugins.forEach((p) => p.onNext?.());
+    }
+    previous() {
+        this.goTo(this.store.snapshot.currentSlide - this.slideStep());
+        this.plugins.forEach((p) => p.onPrevious?.());
+    }
+    getContainerEl() {
+        return this.containerEl;
+    }
+    selectSlide(index) {
+        const slidesPerView = this.store.snapshot.slidesPerView;
+        // 1️⃣ Mark selected
+        this.store.update({ selectedSlide: index });
+        // 2️⃣ Calculate page start
+        let pageStart = Math.floor(index / slidesPerView) * slidesPerView;
+        // 3️⃣ Clamp to maxStartIndex
+        pageStart = Math.min(pageStart, this.maxStartIndex);
+        // 4️⃣ If synced with thumbs, also clamp to their max index
+        if (this.syncThumbsEngine) {
+            const thumbMaxIndex = this.syncThumbsEngine.getMaxStartIndex();
+            pageStart = Math.min(pageStart, thumbMaxIndex);
+        }
+        // 5️⃣ Move main slider
+        if (pageStart !== this.store.snapshot.currentSlide) {
+            this.goToSlide(pageStart);
+        }
+        // 6️⃣ Notify plugins
+        this.plugins.forEach((p) => p.onSlideClick?.(index));
+    }
+    /* ---------------- Drag ---------------- */
+    handleDragStart(event) {
+        this.store.update({ isDragging: true });
+        this.plugins.forEach((p) => p.onDragStart?.(event));
+    }
+    handleDragMove(event) {
+        this.plugins.forEach((p) => p.onDragMove?.(event));
+    }
+    handleDragEnd() {
+        this.store.update({ isDragging: false });
+        this.plugins.forEach((p) => p.onDragEnd?.());
+    }
+    goTo(index) {
+        this.goToSlide(index); // reuse your existing private method
+    }
+    /* ---------------- Internals ---------------- */
+    goToSlide(index) {
+        const clamped = Math.max(0, Math.min(index, this.maxStartIndex));
+        // console.log("[Engine] goToSlide index:", index, "clamped:", clamped);
+        this.store.update({ currentSlide: clamped });
+        this.recalculate();
+        // NOTE: calling onSlideClick here is a bit semantically odd (since it’s not always a click),
+        // but I preserved your behavior.
+        this.plugins.forEach((p) => p.onSlideClick?.(index));
+    }
+    recalculate() {
+        if (this.store.snapshot.isDragging)
+            return; // skip during drag
+        const slides = this.config.slides ?? [];
+        const maxStartIndex = this.getMaxStartIndex();
+        const current = this.store.snapshot.currentSlide;
+        this.store.update({
+            visibleSlides: slides,
+            translate: this.translate(current),
+            pager: this.buildPager(),
+            maxStartIndex,
+            canPrev: current > 0,
+            canNext: current < maxStartIndex,
+        });
+    }
+    translate(index) {
+        const axis = this.config.vertical ? "Y" : "X";
+        const containerSize = this.containerEl
+            ? this.config.vertical
+                ? this.containerEl.clientHeight
+                : this.containerEl.clientWidth
+            : this.config.vertical
+                ? window.innerHeight
+                : window.innerWidth;
+        const gap = this.store.snapshot.gap ?? 0;
+        const spv = this.store.snapshot.slidesPerView;
+        const slideSize = this.config.isThumbs && this.measuredSlideSizePx
+            ? this.measuredSlideSizePx
+            : spv > 0
+                ? (containerSize - gap * (spv - 1)) / spv
+                : containerSize;
+        // move by "pageStart * (slideSize + gap)"
+        const offset = index * (slideSize + gap);
+        return `translate${axis}(-${offset}px)`;
+    }
+    /** Debounced layout signals for resize/orientation/container changes */
+    setupViewportSignals() {
+        // If you want "only after resizing stops", replace auditTime with debounceTime(120)
+        const resize$ = fromEvent(window, "resize", { passive: true });
+        const orientation$ = fromEvent(window, "orientationchange", { passive: true });
+        merge(resize$, orientation$)
+            .pipe(auditTime(80), // good compromise: responsive without over-recalc
+        takeUntil(this.destroy$))
+            .subscribe(() => this.onLayoutSignal());
+    }
+    onLayoutSignal() {
+        const beforeSlidesPerView = this.store.snapshot.slidesPerView;
+        const beforeVisible = this.store.snapshot.isVisible;
+        this.applyBreakpoint();
+        const afterSlidesPerView = this.store.snapshot.slidesPerView;
+        const afterVisible = this.store.snapshot.isVisible;
+        if (beforeSlidesPerView !== afterSlidesPerView || beforeVisible !== afterVisible) {
+            this.clampIndicesAfterLayoutChange();
+        }
+        this.measureSlideSize();
+        this.recalculate();
+    }
+    getBreakpointWidth() {
+        if (this.containerEl) {
+            // Prefer clientWidth (layout), fallback to rect width
+            return this.containerEl.clientWidth || this.containerEl.getBoundingClientRect().width || window.innerWidth;
+        }
+        return window.innerWidth;
+    }
+    applyBreakpoint() {
+        const width = this.getBreakpointWidth();
+        const bp = this.config.breakpoints;
+        let override;
+        let device = "desktop";
+        if (width < 768) {
+            override = bp?.mobile;
+            device = "mobile";
+        }
+        else if (width < 1024) {
+            override = bp?.tablet;
+            device = "tablet";
+        }
+        else {
+            override = bp?.desktop;
+            device = "desktop";
+        }
+        // Merge overrides
+        this.config = { ...this.config, ...override };
+        this.store.update({
+            slidesPerView: this.config.slidesPerView,
+            gap: this.config.gap ?? 0, // ✅ NEW
+            isVisible: this.config.showOn?.[device] ?? true,
+        });
+    }
+    clampIndicesAfterLayoutChange() {
+        const max = this.getMaxStartIndex();
+        const current = this.store.snapshot.currentSlide;
+        const selected = this.store.snapshot.selectedSlide;
+        const clampedCurrent = Math.max(0, Math.min(current, max));
+        const clampedSelected = selected === -1 ? -1 : Math.max(0, Math.min(selected, (this.config.slides?.length ?? 0) - 1));
+        this.store.update({
+            currentSlide: clampedCurrent,
+            selectedSlide: clampedSelected,
+        });
+    }
+    buildPager() {
+        const totalSlides = this.config.slides.length;
+        const currentSlide = this.store.snapshot.selectedSlide !== -1 ? this.store.snapshot.selectedSlide : this.store.snapshot.currentSlide;
+        const maxVisibleDots = 5;
+        let start = Math.max(0, currentSlide - Math.floor(maxVisibleDots / 2));
+        let end = start + maxVisibleDots;
+        if (end > totalSlides) {
+            end = totalSlides;
+            start = Math.max(0, end - maxVisibleDots);
+        }
+        const visibleDots = Array.from({ length: end - start }, (_, i) => start + i);
+        const activeDotIndex = visibleDots.indexOf(currentSlide);
+        return {
+            currentPage: currentSlide,
+            totalPages: totalSlides,
+            visibleDots,
+            activeDotIndex,
+        };
+    }
+    slideStep() {
+        return this.store.snapshot.slidesPerView;
+    }
+    get maxStartIndex() {
+        const total = this.config.slides?.length ?? 0;
+        return Math.max(0, total - this.store.snapshot.slidesPerView);
+    }
+    getMaxStartIndex() {
+        const total = this.config.slides?.length ?? 0;
+        const spv = this.store.snapshot.slidesPerView || 1;
+        return Math.max(0, total - spv);
+    }
+    /* -------- Plugin-safe API -------- */
+    getState() {
+        return this.store.snapshot;
+    }
+    getStateObservable() {
+        return this.store.view$;
+    }
+    setState(patch) {
+        this.store.update(patch);
+    }
+    getConfig() {
+        return this.config;
+    }
+    /** Link this slider to thumbs */
+    syncWithThumbs(thumbsEngine) {
+        this.syncThumbsEngine = thumbsEngine;
+    }
+    /* -------- Read-only helpers -------- */
+    getSlidesPerView() {
+        return this.store.snapshot.slidesPerView;
+    }
+    getCurrentSlide() {
+        return this.store.snapshot.currentSlide;
+    }
+    getSelectedSlide() {
+        return this.store.snapshot.selectedSlide;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SliderEngine, deps: [{ token: i1.SliderStore }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SliderEngine });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SliderEngine, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.SliderStore }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider-engine.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-edge-slider/src/lib/engine/slider-engine.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport { fromEvent, merge, Subject, auditTime, takeUntil } from \"rxjs\";\r\nimport { SliderConfig, DEFAULT_CONFIG } from \"../models/slider-config.model\";\r\nimport { SliderViewState } from \"../models/slider-state.model\";\r\nimport { SliderPlugin } from \"../plugins/slider-plugin\";\r\nimport { SliderStore } from \"../store/slider-store.service\";\r\n\r\n@Injectable()\r\nexport class SliderEngine {\r\n  private config!: SliderConfig;\r\n  private plugins: SliderPlugin[] = [];\r\n  private syncThumbsEngine?: SliderEngine;\r\n\r\n  // RX lifecycle\r\n  private destroy$ = new Subject<void>();\r\n\r\n  // Container-based breakpoints\r\n  private containerEl?: HTMLElement;\r\n  private ro?: ResizeObserver;\r\n\r\n  private measuredSlideSizePx?: number;\r\n\r\n  constructor(private store: SliderStore) {}\r\n\r\n  /* ---------------- Public API ---------------- */\r\n\r\n  init(config: SliderConfig, plugins: SliderPlugin[] = []) {\r\n    this.config = { ...DEFAULT_CONFIG, ...config, plugins: { ...(config.plugins ?? {}) } };\r\n    this.plugins = plugins;\r\n\r\n    this.plugins.forEach((p) => p.init?.(this));\r\n\r\n    this.setupViewportSignals();\r\n    this.applyBreakpoint();\r\n    this.clampIndicesAfterLayoutChange();\r\n    this.recalculate();\r\n  }\r\n\r\n  /** Call this from the component once you have the slider host element */\r\n  attachContainer(el: HTMLElement) {\r\n    this.containerEl = el;\r\n\r\n    // Observe container size changes (robust in grids/sidebars/tabs)\r\n    this.ro?.disconnect();\r\n    this.ro = new ResizeObserver(() => {\r\n      // We reuse the same debounced layout handler\r\n      this.onLayoutSignal();\r\n    });\r\n    this.ro.observe(el);\r\n\r\n    this.measureSlideSize();\r\n    // Apply immediately based on real container width\r\n    this.onLayoutSignal();\r\n  }\r\n  private measureSlideSize() {\r\n    if (!this.containerEl) return;\r\n    const firstSlide = this.containerEl.querySelector<HTMLElement>(\".slide\");\r\n    if (!firstSlide) return;\r\n    const rect = firstSlide.getBoundingClientRect();\r\n    if (rect.width > 0) this.measuredSlideSizePx = rect.width;\r\n  }\r\n  destroy() {\r\n    // Stop Rx streams\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n\r\n    // Disconnect ResizeObserver\r\n    this.ro?.disconnect();\r\n    this.ro = undefined;\r\n    this.containerEl = undefined;\r\n\r\n    // Plugin cleanup\r\n    this.plugins.forEach((p) => p.destroy?.());\r\n    this.plugins = [];\r\n\r\n    // Reset store\r\n    this.store.reset();\r\n  }\r\n\r\n  next() {\r\n    this.goTo(this.store.snapshot.currentSlide + this.slideStep());\r\n    this.plugins.forEach((p) => p.onNext?.());\r\n  }\r\n\r\n  previous() {\r\n    this.goTo(this.store.snapshot.currentSlide - this.slideStep());\r\n    this.plugins.forEach((p) => p.onPrevious?.());\r\n  }\r\n  public getContainerEl(): HTMLElement | undefined {\r\n    return this.containerEl;\r\n  }\r\n  selectSlide(index: number) {\r\n    const slidesPerView = this.store.snapshot.slidesPerView;\r\n\r\n    // 1️⃣ Mark selected\r\n    this.store.update({ selectedSlide: index });\r\n\r\n    // 2️⃣ Calculate page start\r\n    let pageStart = Math.floor(index / slidesPerView) * slidesPerView;\r\n\r\n    // 3️⃣ Clamp to maxStartIndex\r\n    pageStart = Math.min(pageStart, this.maxStartIndex);\r\n\r\n    // 4️⃣ If synced with thumbs, also clamp to their max index\r\n    if (this.syncThumbsEngine) {\r\n      const thumbMaxIndex = this.syncThumbsEngine.getMaxStartIndex();\r\n      pageStart = Math.min(pageStart, thumbMaxIndex);\r\n    }\r\n\r\n    // 5️⃣ Move main slider\r\n    if (pageStart !== this.store.snapshot.currentSlide) {\r\n      this.goToSlide(pageStart);\r\n    }\r\n\r\n    // 6️⃣ Notify plugins\r\n    this.plugins.forEach((p) => p.onSlideClick?.(index));\r\n  }\r\n\r\n  /* ---------------- Drag ---------------- */\r\n\r\n  handleDragStart(event: PointerEvent) {\r\n    this.store.update({ isDragging: true });\r\n    this.plugins.forEach((p) => p.onDragStart?.(event));\r\n  }\r\n  handleDragMove(event: PointerEvent) {\r\n    this.plugins.forEach((p) => p.onDragMove?.(event));\r\n  }\r\n  handleDragEnd() {\r\n    this.store.update({ isDragging: false });\r\n    this.plugins.forEach((p) => p.onDragEnd?.());\r\n  }\r\n  public goTo(index: number) {\r\n    this.goToSlide(index); // reuse your existing private method\r\n  }\r\n  /* ---------------- Internals ---------------- */\r\n\r\n  private goToSlide(index: number) {\r\n    const clamped = Math.max(0, Math.min(index, this.maxStartIndex));\r\n    // console.log(\"[Engine] goToSlide index:\", index, \"clamped:\", clamped);\r\n\r\n    this.store.update({ currentSlide: clamped });\r\n    this.recalculate();\r\n\r\n    // NOTE: calling onSlideClick here is a bit semantically odd (since it’s not always a click),\r\n    // but I preserved your behavior.\r\n    this.plugins.forEach((p) => p.onSlideClick?.(index));\r\n  }\r\n\r\n  public recalculate() {\r\n    if (this.store.snapshot.isDragging) return; // skip during drag\r\n    const slides = this.config.slides ?? [];\r\n    const maxStartIndex = this.getMaxStartIndex();\r\n    const current = this.store.snapshot.currentSlide;\r\n\r\n    this.store.update({\r\n      visibleSlides: slides,\r\n      translate: this.translate(current),\r\n      pager: this.buildPager(),\r\n      maxStartIndex,\r\n      canPrev: current > 0,\r\n      canNext: current < maxStartIndex,\r\n    });\r\n  }\r\n\r\n  private translate(index: number): string {\r\n    const axis = this.config.vertical ? \"Y\" : \"X\";\r\n\r\n    const containerSize = this.containerEl\r\n      ? this.config.vertical\r\n        ? this.containerEl.clientHeight\r\n        : this.containerEl.clientWidth\r\n      : this.config.vertical\r\n        ? window.innerHeight\r\n        : window.innerWidth;\r\n\r\n    const gap = this.store.snapshot.gap ?? 0;\r\n\r\n    const spv = this.store.snapshot.slidesPerView;\r\n    const slideSize =\r\n      this.config.isThumbs && this.measuredSlideSizePx\r\n        ? this.measuredSlideSizePx\r\n        : spv > 0\r\n          ? (containerSize - gap * (spv - 1)) / spv\r\n          : containerSize;\r\n\r\n    // move by \"pageStart * (slideSize + gap)\"\r\n    const offset = index * (slideSize + gap);\r\n\r\n    return `translate${axis}(-${offset}px)`;\r\n  }\r\n\r\n  /** Debounced layout signals for resize/orientation/container changes */\r\n  private setupViewportSignals() {\r\n    // If you want \"only after resizing stops\", replace auditTime with debounceTime(120)\r\n    const resize$ = fromEvent(window, \"resize\", { passive: true } as any);\r\n    const orientation$ = fromEvent(window, \"orientationchange\", { passive: true } as any);\r\n\r\n    merge(resize$, orientation$)\r\n      .pipe(\r\n        auditTime(80), // good compromise: responsive without over-recalc\r\n        takeUntil(this.destroy$),\r\n      )\r\n      .subscribe(() => this.onLayoutSignal());\r\n  }\r\n\r\n  private onLayoutSignal() {\r\n    const beforeSlidesPerView = this.store.snapshot.slidesPerView;\r\n    const beforeVisible = this.store.snapshot.isVisible;\r\n\r\n    this.applyBreakpoint();\r\n\r\n    const afterSlidesPerView = this.store.snapshot.slidesPerView;\r\n    const afterVisible = this.store.snapshot.isVisible;\r\n\r\n    if (beforeSlidesPerView !== afterSlidesPerView || beforeVisible !== afterVisible) {\r\n      this.clampIndicesAfterLayoutChange();\r\n    }\r\n\r\n    this.measureSlideSize();\r\n\r\n    this.recalculate();\r\n  }\r\n\r\n  private getBreakpointWidth(): number {\r\n    if (this.containerEl) {\r\n      // Prefer clientWidth (layout), fallback to rect width\r\n      return this.containerEl.clientWidth || this.containerEl.getBoundingClientRect().width || window.innerWidth;\r\n    }\r\n    return window.innerWidth;\r\n  }\r\n\r\n  private applyBreakpoint() {\r\n    const width = this.getBreakpointWidth();\r\n    const bp = this.config.breakpoints;\r\n\r\n    let override: Partial<SliderConfig> | undefined;\r\n    let device: \"mobile\" | \"tablet\" | \"desktop\" = \"desktop\";\r\n\r\n    if (width < 768) {\r\n      override = bp?.mobile;\r\n      device = \"mobile\";\r\n    } else if (width < 1024) {\r\n      override = bp?.tablet;\r\n      device = \"tablet\";\r\n    } else {\r\n      override = bp?.desktop;\r\n      device = \"desktop\";\r\n    }\r\n\r\n    // Merge overrides\r\n    this.config = { ...this.config, ...override };\r\n\r\n    this.store.update({\r\n      slidesPerView: this.config.slidesPerView,\r\n      gap: this.config.gap ?? 0, // ✅ NEW\r\n      isVisible: this.config.showOn?.[device] ?? true,\r\n    });\r\n  }\r\n\r\n  private clampIndicesAfterLayoutChange() {\r\n    const max = this.getMaxStartIndex();\r\n\r\n    const current = this.store.snapshot.currentSlide;\r\n    const selected = this.store.snapshot.selectedSlide;\r\n\r\n    const clampedCurrent = Math.max(0, Math.min(current, max));\r\n    const clampedSelected = selected === -1 ? -1 : Math.max(0, Math.min(selected, (this.config.slides?.length ?? 0) - 1));\r\n\r\n    this.store.update({\r\n      currentSlide: clampedCurrent,\r\n      selectedSlide: clampedSelected,\r\n    });\r\n  }\r\n\r\n  private buildPager() {\r\n    const totalSlides = this.config.slides.length;\r\n    const currentSlide = this.store.snapshot.selectedSlide !== -1 ? this.store.snapshot.selectedSlide : this.store.snapshot.currentSlide;\r\n\r\n    const maxVisibleDots = 5;\r\n\r\n    let start = Math.max(0, currentSlide - Math.floor(maxVisibleDots / 2));\r\n    let end = start + maxVisibleDots;\r\n\r\n    if (end > totalSlides) {\r\n      end = totalSlides;\r\n      start = Math.max(0, end - maxVisibleDots);\r\n    }\r\n\r\n    const visibleDots = Array.from({ length: end - start }, (_, i) => start + i);\r\n    const activeDotIndex = visibleDots.indexOf(currentSlide);\r\n\r\n    return {\r\n      currentPage: currentSlide,\r\n      totalPages: totalSlides,\r\n      visibleDots,\r\n      activeDotIndex,\r\n    };\r\n  }\r\n\r\n  private slideStep() {\r\n    return this.store.snapshot.slidesPerView;\r\n  }\r\n\r\n  private get maxStartIndex() {\r\n    const total = this.config.slides?.length ?? 0;\r\n    return Math.max(0, total - this.store.snapshot.slidesPerView);\r\n  }\r\n  getMaxStartIndex() {\r\n    const total = this.config.slides?.length ?? 0;\r\n    const spv = this.store.snapshot.slidesPerView || 1;\r\n    return Math.max(0, total - spv);\r\n  }\r\n  /* -------- Plugin-safe API -------- */\r\n\r\n  getState() {\r\n    return this.store.snapshot;\r\n  }\r\n\r\n  getStateObservable() {\r\n    return this.store.view$;\r\n  }\r\n\r\n  setState(patch: Partial<SliderViewState>) {\r\n    this.store.update(patch);\r\n  }\r\n\r\n  getConfig() {\r\n    return this.config;\r\n  }\r\n\r\n  /** Link this slider to thumbs */\r\n  syncWithThumbs(thumbsEngine: SliderEngine) {\r\n    this.syncThumbsEngine = thumbsEngine;\r\n  }\r\n\r\n  /* -------- Read-only helpers -------- */\r\n\r\n  getSlidesPerView(): number {\r\n    return this.store.snapshot.slidesPerView;\r\n  }\r\n\r\n  getCurrentSlide(): number {\r\n    return this.store.snapshot.currentSlide;\r\n  }\r\n\r\n  getSelectedSlide(): number {\r\n    return this.store.snapshot.selectedSlide;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/models/slider-config.model.mjs

@@ -0,0 +1,18 @@
+export const DEFAULT_CONFIG = {
+    slides: [],
+    slidesPerView: 1,
+    slidesToSlide: 1,
+    loop: 0,
+    vertical: false,
+    changeToClickedSlide: false,
+    isThumbs: false,
+    plugins: {
+        draggable: false,
+        pagination: false,
+        navigation: false,
+        autoplay: undefined,
+    },
+    gap: 0,
+    showOn: { mobile: true, tablet: true, desktop: true },
+};
+//# sourceMappingURL=data:application/json;base64,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