ngx-sfc-components 0.0.1

package/esm2020/lib/components/carousel/carousel.component.mjs

@@ -0,0 +1,230 @@
+import { Component, ContentChildren, EventEmitter, HostBinding, HostListener, Inject, Input, Output } from '@angular/core';
+import { any, UIClass } from 'ngx-sfc-common';
+import { DOCUMENT } from 'ngx-sfc-common';
+import { switchMap, delay, tap, filter, skip, take, map, from, of, toArray, merge } from 'rxjs';
+import { CarouselProperty } from './carousel.enum';
+import { CarouselSlideDirective } from './directive/carousel-slide.directive';
+import { CarouselAnimateService } from './service/animate/carousel-animate.service';
+import { CarouselAutoplayService } from './service/autoplay/carousel-autoplay.service';
+import { CarouselServiceConstants } from './service/carousel/carousel-service.constants';
+import { CarouselService } from './service/carousel/carousel.service';
+import { CarouselLazyLoadService } from './service/lazy/carousel-lazy-load.service';
+import { CarouselNavigationService } from './service/navigation/carousel-navigation.service';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-sfc-common";
+import * as i2 from "./service/carousel/carousel.service";
+import * as i3 from "./service/navigation/carousel-navigation.service";
+import * as i4 from "./service/autoplay/carousel-autoplay.service";
+import * as i5 from "./service/lazy/carousel-lazy-load.service";
+import * as i6 from "./service/animate/carousel-animate.service";
+import * as i7 from "./parts/stage/carousel-stage.component";
+import * as i8 from "@angular/common";
+export class CarouselComponent {
+    constructor(el, resizeService, carouselService, navigationService, autoplayService, lazyLoadService, animateService, changeDetectorRef, documentRef) {
+        this.el = el;
+        this.resizeService = resizeService;
+        this.carouselService = carouselService;
+        this.navigationService = navigationService;
+        this.autoplayService = autoplayService;
+        this.lazyLoadService = lazyLoadService;
+        this.animateService = animateService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.translated = new EventEmitter();
+        this.initialized = new EventEmitter();
+        this.changing = new EventEmitter();
+        this.changed = new EventEmitter();
+        this.slidesModel = [];
+        this.carouselLoaded = false;
+        this.carouselWindowWidth = 0;
+        this.documentRef = documentRef;
+    }
+    get rtl() {
+        return this.carouselDOMModel?.rtl || false;
+    }
+    get clientWidth() {
+        return this.el.nativeElement.querySelector('.container').clientWidth;
+    }
+    onVisibilityChange() {
+        if (this.carouselService.settings.autoplay) {
+            switch (this.documentRef.visibilityState) {
+                case UIClass.Visible:
+                    if (!this.autoplayService.isAutoplayStopped)
+                        this.autoplayService.play();
+                    break;
+                case UIClass.Hidden:
+                    this.autoplayService.pause();
+                    break;
+            }
+        }
+    }
+    ;
+    ngOnInit() {
+        this.carouselWindowWidth = this.clientWidth;
+        this.initDataStreams();
+    }
+    ngAfterContentInit() {
+        if (any(this.slides.toArray())) {
+            this.carouselService.setup(this.carouselWindowWidth, this.slides.toArray(), this.options);
+            this.carouselService.initialize(this.slides.toArray());
+            this.initResizeWatcher();
+        }
+        this.slidesChangesSubscription = this.slides.changes.pipe(tap((slides) => {
+            if (any(slides)) {
+                this.carouselService.setup(this.carouselWindowWidth, slides.toArray(), this.options);
+                this.carouselService.initialize(slides.toArray());
+            }
+            else {
+                this.carouselLoaded = false;
+            }
+        })).subscribe();
+    }
+    ngOnDestroy() {
+        if (this.resizeSubscription)
+            this.resizeSubscription.unsubscribe();
+        if (this.slidesChangesSubscription)
+            this.slidesChangesSubscription.unsubscribe();
+        if (this.carouselSubscription)
+            this.carouselSubscription.unsubscribe();
+    }
+    initDataStreams() {
+        const _viewCurSettings$ = this.carouselService.viewCurrrentSettings.pipe(tap(data => {
+            this.carouselDOMModel = data.carouselDOMModel;
+            this.stageModel = data.stageModel;
+            this.slidesModel = data.slidesModel;
+            if (!this.carouselLoaded) {
+                this.carouselLoaded = true;
+            }
+            this.navigationModel = data.navigationModel;
+            this.navigationDotsModel = data.navigationDotsModel;
+            this.changeDetectorRef.markForCheck();
+        }));
+        const _initializedCarousel$ = this.carouselService.initializedState.pipe(tap(() => {
+            this.gatherTranslatedData();
+            this.initialized.emit(this.slideEvent);
+        }));
+        const _translatedCarousel$ = this.carouselService.translatedState.pipe(tap(() => {
+            this.gatherTranslatedData();
+            this.translated.emit(this.slideEvent);
+        }));
+        const _changeCarousel$ = this.carouselService.changeState.pipe(tap(() => {
+            this.gatherTranslatedData();
+            this.changing.emit(this.slideEvent);
+        }));
+        const _changedCarousel$ = this.carouselService.changeState.pipe(switchMap(value => {
+            const changedPosition = of(value).pipe(filter(() => value.property.name === CarouselProperty.Position), switchMap(() => from(this.slidesModel)), skip(value.property.value), take(this.carouselService.settings.items || 0), map(slide => {
+                const id = slide.id.indexOf(CarouselServiceConstants.CLONE_ID_PREFIX) >= 0 ? slide.id.slice(CarouselServiceConstants.CLONE_ID_PREFIX.length) : slide.id;
+                return { ...slide, id: id, isActive: true };
+            }), toArray(), map(slides => {
+                return {
+                    slides: slides,
+                    startPosition: this.carouselService.relative(value.property.value)
+                };
+            }));
+            return merge(changedPosition);
+        }), tap(slidesData => {
+            this.gatherTranslatedData();
+            this.changed.emit(slidesData.slides?.length ? slidesData : this.slideEvent);
+        }));
+        this.carouselSubscription = merge(_viewCurSettings$, _translatedCarousel$, _changeCarousel$, _changedCarousel$, _initializedCarousel$).subscribe();
+    }
+    initResizeWatcher() {
+        if (Object.keys(this.carouselService.options.responsive || {}).length) {
+            this.resizeSubscription = this.resizeService.onResize$
+                .pipe(filter(() => this.carouselWindowWidth !== this.clientWidth), delay(this.carouselService.settings.responsiveRefreshRate || 0)).subscribe(() => {
+                this.carouselService.onResize(this.clientWidth);
+                this.carouselWindowWidth = this.clientWidth;
+            });
+        }
+    }
+    onTransitionEnd() {
+        this.carouselService.onTransitionEnd();
+    }
+    next() {
+        if (this.carouselLoaded)
+            this.navigationService.next(this.carouselService.settings.navSpeed || false);
+    }
+    previous() {
+        if (this.carouselLoaded)
+            this.navigationService.previous(this.carouselService.settings.navSpeed || false);
+    }
+    moveByDot(dotId) {
+        if (this.carouselLoaded)
+            this.navigationService.moveByDot(dotId);
+    }
+    pause() {
+        this.autoplayService.startPausing();
+    }
+    play() {
+        this.autoplayService.startPlayingMouseLeave();
+    }
+    stopAutoplay() {
+        this.autoplayService.isAutoplayStopped = true;
+        this.autoplayService.stop();
+    }
+    startAutoplay() {
+        this.autoplayService.isAutoplayStopped = false;
+        this.autoplayService.play();
+    }
+    gatherTranslatedData() {
+        let startPosition;
+        const activeSlides = this.slidesModel
+            .filter(slide => slide.isActive === true)
+            .map(slide => {
+            return {
+                id: slide.id.indexOf(CarouselServiceConstants.CLONE_ID_PREFIX) >= 0 ? slide.id.slice(CarouselServiceConstants.CLONE_ID_PREFIX.length) : slide.id,
+                width: slide.width,
+                marginL: slide.marginL,
+                marginR: slide.marginR,
+                center: slide.isCentered,
+                tplRef: null,
+                classes: {}
+            };
+        });
+        startPosition = this.carouselService.relative(this.carouselService.current() || 0);
+        this.slideEvent = {
+            startPosition: startPosition,
+            slides: activeSlides
+        };
+    }
+}
+CarouselComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselComponent, deps: [{ token: i0.ElementRef }, { token: i1.ResizeService }, { token: i2.CarouselService }, { token: i3.CarouselNavigationService }, { token: i4.CarouselAutoplayService }, { token: i5.CarouselLazyLoadService }, { token: i6.CarouselAnimateService }, { token: i0.ChangeDetectorRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+CarouselComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", type: CarouselComponent, selector: "sfc-carousel", inputs: { options: "options" }, outputs: { translated: "translated", initialized: "initialized", changing: "changing", changed: "changed" }, host: { listeners: { "document:visibilitychange": "onVisibilityChange()" }, properties: { "class.rtl": "this.rtl" } }, providers: [
+        CarouselNavigationService,
+        CarouselAutoplayService,
+        CarouselService,
+        CarouselAnimateService,
+        CarouselLazyLoadService
+    ], queries: [{ propertyName: "slides", predicate: CarouselSlideDirective }], ngImport: i0, template: "<div class=\"container\" (mouseover)=\"pause()\" (mouseleave)=\"play()\">\r\n    <div *ngIf=\"carouselLoaded\" class=\"stage\">\r\n        <sfc-carousel-stage [stageModel]=\"stageModel\" [slidesModel]=\"slidesModel\"></sfc-carousel-stage>\r\n    </div>\r\n    <ng-container *ngIf=\"slides.toArray().length\">\r\n        <div class=\"navigation\" [class.disabled]=\"navigationModel?.disabled\">\r\n            <div class=\"action previous\" [class.disabled]=\"navigationModel?.previous?.disabled\" (click)=\"previous()\">\r\n                {{navigationModel?.previous?.label}}\r\n            </div>\r\n            <div class=\"action next\" [class.disabled]=\"navigationModel?.next?.disabled\" (click)=\"next()\">\r\n                {{navigationModel?.next?.label}}\r\n            </div>\r\n        </div>\r\n        <div class=\"dots\" [class.disabled]=\"navigationDotsModel?.disabled\">\r\n            <div *ngFor=\"let dot of navigationDotsModel?.dots\" class=\"dot\" [class.active]=\"dot.active\"\r\n                (click)=\"moveByDot(dot.id)\">\r\n                <span></span>\r\n            </div>\r\n        </div>\r\n    </ng-container>\r\n</div>", styles: [":host .container{display:block;width:100%;-webkit-tap-highlight-color:transparent;position:relative;z-index:1}:host .container .stage{position:relative;overflow:hidden;transform:translate(0)}:host .container .dots{text-align:center;-webkit-tap-highlight-color:transparent}:host .container .dots.disabled{display:none}:host .container .dots .dot{display:inline-block;zoom:1;cursor:pointer;-webkit-user-select:none;user-select:none}:host .container .dots .dot span{width:10px;height:10px;margin:5px 7px;display:block;-webkit-backface-visibility:visible;backface-visibility:visible;transition:opacity .2s ease;border-radius:30px}:host-context(.sfc-default-theme) :host .container .dots .dot span{background:#d8d7d7}:host-context(.sfc-dark-theme) :host .container .dots .dot span{background:#f6f6f6}:host-context(.sfc-default-theme) :host .container .dots .dot.active span,:host-context(.sfc-default-theme) :host .container .dots .dot:hover span{background:#656d78}:host-context(.sfc-dark-theme) :host .container .dots .dot.active span,:host-context(.sfc-dark-theme) :host .container .dots .dot:hover span{background:#aab2bd}:host .container .navigation{margin-top:10px;text-align:center;-webkit-tap-highlight-color:transparent}:host .container .navigation .action{font-size:14px;margin:5px;padding:4px 7px;display:inline-block;cursor:pointer;border-radius:3px}:host-context(.sfc-default-theme) :host .container .navigation .action{color:#fff}:host-context(.sfc-dark-theme) :host .container .navigation .action{color:#545e61}:host-context(.sfc-default-theme) :host .container .navigation .action{background:#d8d7d7}:host-context(.sfc-dark-theme) :host .container .navigation .action{background:#f6f6f6}:host .container .navigation .action:hover{text-decoration:none}:host-context(.sfc-default-theme) :host .container .navigation .action:hover{background:#0000001a}:host-context(.sfc-dark-theme) :host .container .navigation .action:hover{background:#d8d7d7}:host .container .navigation .action.previous,:host .container .navigation .action.next{cursor:pointer;-webkit-user-select:none;user-select:none}:host .container .navigation .action.disabled{opacity:.5;cursor:default}:host .container .navigation.disabled{display:none}:host .container .navigation.disabled+.dots{margin-top:10px}:host.rtl .container{direction:rtl}\n"], components: [{ type: i7.CarouselStageComponent, selector: "sfc-carousel-stage", inputs: ["stageModel", "slidesModel"] }], directives: [{ type: i8.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i8.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sfc-carousel', providers: [
+                        CarouselNavigationService,
+                        CarouselAutoplayService,
+                        CarouselService,
+                        CarouselAnimateService,
+                        CarouselLazyLoadService
+                    ], template: "<div class=\"container\" (mouseover)=\"pause()\" (mouseleave)=\"play()\">\r\n    <div *ngIf=\"carouselLoaded\" class=\"stage\">\r\n        <sfc-carousel-stage [stageModel]=\"stageModel\" [slidesModel]=\"slidesModel\"></sfc-carousel-stage>\r\n    </div>\r\n    <ng-container *ngIf=\"slides.toArray().length\">\r\n        <div class=\"navigation\" [class.disabled]=\"navigationModel?.disabled\">\r\n            <div class=\"action previous\" [class.disabled]=\"navigationModel?.previous?.disabled\" (click)=\"previous()\">\r\n                {{navigationModel?.previous?.label}}\r\n            </div>\r\n            <div class=\"action next\" [class.disabled]=\"navigationModel?.next?.disabled\" (click)=\"next()\">\r\n                {{navigationModel?.next?.label}}\r\n            </div>\r\n        </div>\r\n        <div class=\"dots\" [class.disabled]=\"navigationDotsModel?.disabled\">\r\n            <div *ngFor=\"let dot of navigationDotsModel?.dots\" class=\"dot\" [class.active]=\"dot.active\"\r\n                (click)=\"moveByDot(dot.id)\">\r\n                <span></span>\r\n            </div>\r\n        </div>\r\n    </ng-container>\r\n</div>", styles: [":host .container{display:block;width:100%;-webkit-tap-highlight-color:transparent;position:relative;z-index:1}:host .container .stage{position:relative;overflow:hidden;transform:translate(0)}:host .container .dots{text-align:center;-webkit-tap-highlight-color:transparent}:host .container .dots.disabled{display:none}:host .container .dots .dot{display:inline-block;zoom:1;cursor:pointer;-webkit-user-select:none;user-select:none}:host .container .dots .dot span{width:10px;height:10px;margin:5px 7px;display:block;-webkit-backface-visibility:visible;backface-visibility:visible;transition:opacity .2s ease;border-radius:30px}:host-context(.sfc-default-theme) :host .container .dots .dot span{background:#d8d7d7}:host-context(.sfc-dark-theme) :host .container .dots .dot span{background:#f6f6f6}:host-context(.sfc-default-theme) :host .container .dots .dot.active span,:host-context(.sfc-default-theme) :host .container .dots .dot:hover span{background:#656d78}:host-context(.sfc-dark-theme) :host .container .dots .dot.active span,:host-context(.sfc-dark-theme) :host .container .dots .dot:hover span{background:#aab2bd}:host .container .navigation{margin-top:10px;text-align:center;-webkit-tap-highlight-color:transparent}:host .container .navigation .action{font-size:14px;margin:5px;padding:4px 7px;display:inline-block;cursor:pointer;border-radius:3px}:host-context(.sfc-default-theme) :host .container .navigation .action{color:#fff}:host-context(.sfc-dark-theme) :host .container .navigation .action{color:#545e61}:host-context(.sfc-default-theme) :host .container .navigation .action{background:#d8d7d7}:host-context(.sfc-dark-theme) :host .container .navigation .action{background:#f6f6f6}:host .container .navigation .action:hover{text-decoration:none}:host-context(.sfc-default-theme) :host .container .navigation .action:hover{background:#0000001a}:host-context(.sfc-dark-theme) :host .container .navigation .action:hover{background:#d8d7d7}:host .container .navigation .action.previous,:host .container .navigation .action.next{cursor:pointer;-webkit-user-select:none;user-select:none}:host .container .navigation .action.disabled{opacity:.5;cursor:default}:host .container .navigation.disabled{display:none}:host .container .navigation.disabled+.dots{margin-top:10px}:host.rtl .container{direction:rtl}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.ResizeService }, { type: i2.CarouselService }, { type: i3.CarouselNavigationService }, { type: i4.CarouselAutoplayService }, { type: i5.CarouselLazyLoadService }, { type: i6.CarouselAnimateService }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { options: [{
+                type: Input
+            }], translated: [{
+                type: Output
+            }], initialized: [{
+                type: Output
+            }], changing: [{
+                type: Output
+            }], changed: [{
+                type: Output
+            }], slides: [{
+                type: ContentChildren,
+                args: [CarouselSlideDirective]
+            }], rtl: [{
+                type: HostBinding,
+                args: ['class.rtl']
+            }], onVisibilityChange: [{
+                type: HostListener,
+                args: ['document:visibilitychange']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"carousel.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-sfc-components/src/lib/components/carousel/carousel.component.ts","../../../../../../projects/ngx-sfc-components/src/lib/components/carousel/carousel.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  AfterContentInit, ChangeDetectorRef,\r\n  Component, ContentChildren, ElementRef, EventEmitter, HostBinding, HostListener, Inject, Input, OnDestroy, OnInit, Output, QueryList\r\n} from '@angular/core';\r\nimport { any, UIClass } from 'ngx-sfc-common';\r\nimport { DOCUMENT, ResizeService } from 'ngx-sfc-common';\r\nimport { switchMap, delay, tap, Observable, Subscription, filter, skip, take, map, from, of, toArray, merge } from 'rxjs';\r\nimport { CarouselProperty } from './carousel.enum';\r\nimport { CarouselSlideDirective } from './directive/carousel-slide.directive';\r\nimport { CarouselDOMModel } from './models/dom.model';\r\nimport { CarouselNavigationDotsModel, CarouselNavigationModel } from './models/navigation.model';\r\nimport { CarouselOptionsModel } from './models/options.model';\r\nimport { CarouselSlideModel, CarouselSlideEvent } from './models/slide.model';\r\nimport { CarouselStageModel } from './parts/stage/carousel-stage.model';\r\nimport { CarouselAnimateService } from './service/animate/carousel-animate.service';\r\nimport { CarouselAutoplayService } from './service/autoplay/carousel-autoplay.service';\r\nimport { CarouselServiceConstants } from './service/carousel/carousel-service.constants';\r\nimport { CarouselService } from './service/carousel/carousel.service';\r\nimport { CarouselLazyLoadService } from './service/lazy/carousel-lazy-load.service';\r\nimport { CarouselNavigationService } from './service/navigation/carousel-navigation.service';\r\n\r\n@Component({\r\n  selector: 'sfc-carousel',\r\n  templateUrl: './carousel.component.html',\r\n  styleUrls: ['./carousel.component.scss'],\r\n  providers: [\r\n    CarouselNavigationService,\r\n    CarouselAutoplayService,\r\n    CarouselService,\r\n    CarouselAnimateService,\r\n    CarouselLazyLoadService\r\n  ]\r\n})\r\nexport class CarouselComponent implements OnInit, AfterContentInit, OnDestroy {\r\n\r\n  @Input()\r\n  options!: CarouselOptionsModel;\r\n\r\n  @Output()\r\n  translated = new EventEmitter<CarouselSlideEvent>();\r\n\r\n  @Output()\r\n  initialized = new EventEmitter<CarouselSlideEvent>();\r\n\r\n  @Output()\r\n  changing = new EventEmitter<CarouselSlideEvent>();\r\n\r\n  @Output()\r\n  changed = new EventEmitter<CarouselSlideEvent>();\r\n\r\n  @ContentChildren(CarouselSlideDirective)\r\n  slides!: QueryList<CarouselSlideDirective>;\r\n\r\n  // SUBSCRIPTIONS\r\n\r\n  private resizeSubscription!: Subscription;\r\n\r\n  private carouselSubscription!: Subscription;\r\n\r\n  private slidesChangesSubscription!: Subscription;\r\n\r\n  // END SUBSCRIPTIONS\r\n\r\n  // MODELS\r\n\r\n  carouselDOMModel!: CarouselDOMModel;\r\n\r\n  stageModel!: CarouselStageModel;\r\n\r\n  slidesModel: CarouselSlideModel[] = [];\r\n\r\n  navigationModel!: CarouselNavigationModel;\r\n\r\n  navigationDotsModel!: CarouselNavigationDotsModel;\r\n\r\n  // END MODELS\r\n\r\n  slideEvent!: CarouselSlideEvent;\r\n\r\n  carouselLoaded = false;\r\n\r\n  @HostBinding('class.rtl')\r\n  get rtl(): boolean {\r\n    return this.carouselDOMModel?.rtl || false;\r\n  }\r\n\r\n  get clientWidth(): number {\r\n    return this.el.nativeElement.querySelector('.container').clientWidth;\r\n  }\r\n\r\n  private carouselWindowWidth: number = 0;\r\n\r\n  private documentRef: Document;\r\n\r\n  constructor(\r\n    private el: ElementRef,\r\n    private resizeService: ResizeService,\r\n    private carouselService: CarouselService,\r\n    private navigationService: CarouselNavigationService,\r\n    private autoplayService: CarouselAutoplayService,\r\n    private lazyLoadService: CarouselLazyLoadService,\r\n    private animateService: CarouselAnimateService,\r\n    private changeDetectorRef: ChangeDetectorRef,\r\n    @Inject(DOCUMENT) documentRef: any\r\n  ) {\r\n    this.documentRef = documentRef as Document;\r\n  }\r\n\r\n  @HostListener('document:visibilitychange')\r\n  onVisibilityChange() {\r\n    if (this.carouselService.settings.autoplay) {\r\n      switch (this.documentRef.visibilityState) {\r\n        case UIClass.Visible:\r\n          if (!this.autoplayService.isAutoplayStopped)\r\n            this.autoplayService.play();\r\n          break;\r\n        case UIClass.Hidden:\r\n          this.autoplayService.pause();\r\n          break;\r\n      }\r\n    }\r\n  };\r\n\r\n  ngOnInit() {\r\n    this.carouselWindowWidth = this.clientWidth;\r\n    this.initDataStreams();\r\n  }\r\n\r\n  ngAfterContentInit() {\r\n    if (any(this.slides.toArray())) {\r\n      this.carouselService.setup(this.carouselWindowWidth, this.slides.toArray(), this.options);\r\n      this.carouselService.initialize(this.slides.toArray());\r\n\r\n      this.initResizeWatcher();\r\n    }\r\n\r\n    this.slidesChangesSubscription = this.slides.changes.pipe(\r\n      tap((slides) => {\r\n        if (any(slides)) {\r\n          this.carouselService.setup(this.carouselWindowWidth, slides.toArray(), this.options);\r\n          this.carouselService.initialize(slides.toArray());\r\n        } else {\r\n          this.carouselLoaded = false;\r\n        }\r\n      })\r\n    ).subscribe();\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    if (this.resizeSubscription)\r\n      this.resizeSubscription.unsubscribe();\r\n\r\n    if (this.slidesChangesSubscription)\r\n      this.slidesChangesSubscription.unsubscribe();\r\n\r\n    if (this.carouselSubscription)\r\n      this.carouselSubscription.unsubscribe();\r\n  }\r\n\r\n  initDataStreams() {\r\n    const _viewCurSettings$ = this.carouselService.viewCurrrentSettings.pipe(\r\n      tap(data => {\r\n        this.carouselDOMModel = data.carouselDOMModel;\r\n        this.stageModel = data.stageModel;\r\n        this.slidesModel = data.slidesModel;\r\n        if (!this.carouselLoaded) {\r\n          this.carouselLoaded = true;\r\n        }\r\n        this.navigationModel = data.navigationModel;\r\n        this.navigationDotsModel = data.navigationDotsModel;\r\n        this.changeDetectorRef.markForCheck();\r\n      })\r\n    );\r\n\r\n    const _initializedCarousel$ = this.carouselService.initializedState.pipe(\r\n      tap(() => {\r\n        this.gatherTranslatedData();\r\n        this.initialized.emit(this.slideEvent);\r\n      })\r\n    )\r\n\r\n    const _translatedCarousel$ = this.carouselService.translatedState.pipe(\r\n      tap(() => {\r\n        this.gatherTranslatedData();\r\n        this.translated.emit(this.slideEvent);\r\n      })\r\n    );\r\n\r\n    const _changeCarousel$ = this.carouselService.changeState.pipe(\r\n      tap(() => {\r\n        this.gatherTranslatedData();\r\n        this.changing.emit(this.slideEvent);\r\n      })\r\n    );\r\n\r\n    const _changedCarousel$ = this.carouselService.changeState.pipe(\r\n      switchMap(value => {\r\n        const changedPosition: Observable<CarouselSlideEvent> = of(value).pipe(\r\n          filter(() => value.property.name === CarouselProperty.Position),\r\n          switchMap(() => from(this.slidesModel)),\r\n          skip(value.property.value),\r\n          take(this.carouselService.settings.items || 0),\r\n          map(slide => {\r\n            const id = slide.id.indexOf(CarouselServiceConstants.CLONE_ID_PREFIX) >= 0 ? slide.id.slice(CarouselServiceConstants.CLONE_ID_PREFIX.length) : slide.id;\r\n            return { ...slide, id: id, isActive: true };\r\n          }),\r\n          toArray(),\r\n          map(slides => {\r\n            return {\r\n              slides: slides,\r\n              startPosition: this.carouselService.relative(value.property.value)\r\n            }\r\n          })\r\n        );\r\n\r\n        return merge(changedPosition);\r\n      }),\r\n      tap(slidesData => {\r\n        this.gatherTranslatedData();\r\n        this.changed.emit(slidesData.slides?.length ? slidesData : this.slideEvent);\r\n      })\r\n    );\r\n\r\n    this.carouselSubscription = merge(\r\n      _viewCurSettings$,\r\n      _translatedCarousel$,\r\n      _changeCarousel$,\r\n      _changedCarousel$,\r\n      _initializedCarousel$\r\n    ).subscribe();\r\n  }\r\n\r\n  private initResizeWatcher() {\r\n    if (Object.keys(this.carouselService.options.responsive || {}).length) {\r\n      this.resizeSubscription = this.resizeService.onResize$\r\n        .pipe(\r\n          filter(() => this.carouselWindowWidth !== this.clientWidth),\r\n          delay(this.carouselService.settings.responsiveRefreshRate || 0)\r\n        ).subscribe(() => {\r\n          this.carouselService.onResize(this.clientWidth);\r\n          this.carouselWindowWidth = this.clientWidth;\r\n        });\r\n    }\r\n  }\r\n\r\n  onTransitionEnd() {\r\n    this.carouselService.onTransitionEnd();\r\n  }\r\n\r\n  next() {\r\n    if (this.carouselLoaded)\r\n      this.navigationService.next(this.carouselService.settings.navSpeed || false);\r\n  }\r\n\r\n  previous() {\r\n    if (this.carouselLoaded)\r\n      this.navigationService.previous(this.carouselService.settings.navSpeed || false);\r\n  }\r\n\r\n  moveByDot(dotId: string) {\r\n    if (this.carouselLoaded)\r\n      this.navigationService.moveByDot(dotId);\r\n  }\r\n\r\n  pause() {\r\n    this.autoplayService.startPausing();\r\n  }\r\n\r\n  play() {\r\n    this.autoplayService.startPlayingMouseLeave();\r\n  }\r\n\r\n  stopAutoplay() {\r\n    this.autoplayService.isAutoplayStopped = true;\r\n    this.autoplayService.stop();\r\n  }\r\n\r\n  startAutoplay() {\r\n    this.autoplayService.isAutoplayStopped = false;\r\n    this.autoplayService.play();\r\n  }\r\n\r\n  private gatherTranslatedData() {\r\n    let startPosition: number;\r\n    const activeSlides: CarouselSlideModel[] = this.slidesModel\r\n      .filter(slide => slide.isActive === true)\r\n      .map(slide => {\r\n        return {\r\n          id: slide.id.indexOf(CarouselServiceConstants.CLONE_ID_PREFIX) >= 0 ? slide.id.slice(CarouselServiceConstants.CLONE_ID_PREFIX.length) : slide.id,\r\n          width: slide.width,\r\n          marginL: slide.marginL,\r\n          marginR: slide.marginR,\r\n          center: slide.isCentered,\r\n          tplRef: null,\r\n          classes: {}\r\n        }\r\n      });\r\n    startPosition = this.carouselService.relative(this.carouselService.current() || 0);\r\n    this.slideEvent = {\r\n      startPosition: startPosition,\r\n      slides: activeSlides\r\n    }\r\n  }\r\n}\r\n","<div class=\"container\" (mouseover)=\"pause()\" (mouseleave)=\"play()\">\r\n    <div *ngIf=\"carouselLoaded\" class=\"stage\">\r\n        <sfc-carousel-stage [stageModel]=\"stageModel\" [slidesModel]=\"slidesModel\"></sfc-carousel-stage>\r\n    </div>\r\n    <ng-container *ngIf=\"slides.toArray().length\">\r\n        <div class=\"navigation\" [class.disabled]=\"navigationModel?.disabled\">\r\n            <div class=\"action previous\" [class.disabled]=\"navigationModel?.previous?.disabled\" (click)=\"previous()\">\r\n                {{navigationModel?.previous?.label}}\r\n            </div>\r\n            <div class=\"action next\" [class.disabled]=\"navigationModel?.next?.disabled\" (click)=\"next()\">\r\n                {{navigationModel?.next?.label}}\r\n            </div>\r\n        </div>\r\n        <div class=\"dots\" [class.disabled]=\"navigationDotsModel?.disabled\">\r\n            <div *ngFor=\"let dot of navigationDotsModel?.dots\" class=\"dot\" [class.active]=\"dot.active\"\r\n                (click)=\"moveByDot(dot.id)\">\r\n                <span></span>\r\n            </div>\r\n        </div>\r\n    </ng-container>\r\n</div>"]}

package/esm2020/lib/components/carousel/carousel.enum.mjs

@@ -0,0 +1,33 @@
+export var CarouselProperty;
+(function (CarouselProperty) {
+    CarouselProperty["Position"] = "position";
+    CarouselProperty["Settings"] = "settings";
+    CarouselProperty["Width"] = "width";
+    CarouselProperty["Items"] = "items";
+})(CarouselProperty || (CarouselProperty = {}));
+;
+export var CarouselState;
+(function (CarouselState) {
+    CarouselState["Busy"] = "busy";
+    CarouselState["Interacting"] = "interacting";
+    CarouselState["Rotating"] = "rotating";
+})(CarouselState || (CarouselState = {}));
+;
+export var CarouselEventType;
+(function (CarouselEventType) {
+    CarouselEventType["Initializing"] = "initializing";
+    CarouselEventType["Initialized"] = "initialized";
+    CarouselEventType["Change"] = "change";
+    CarouselEventType["Changed"] = "changed";
+    CarouselEventType["Resize"] = "resize";
+    CarouselEventType["Resizing"] = "resizing";
+    CarouselEventType["Resized"] = "resized";
+    CarouselEventType["Refresh"] = "refresh";
+    CarouselEventType["Refreshed"] = "refreshed";
+    CarouselEventType["Translate"] = "translate";
+    CarouselEventType["Translated"] = "translated";
+    CarouselEventType["Animating"] = "animating";
+    CarouselEventType["Refreshing"] = "refreshing";
+})(CarouselEventType || (CarouselEventType = {}));
+;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/carousel/directive/carousel-slide.directive.mjs

@@ -0,0 +1,31 @@
+import { Directive, Input } from "@angular/core";
+import { isNumeric } from "ngx-sfc-common";
+import * as i0 from "@angular/core";
+let nextId = 0;
+/* eslint-disable */
+export class CarouselSlideDirective {
+    constructor(tplRef) {
+        this.tplRef = tplRef;
+        this.id = `slide-${nextId++}`;
+        this._dataMerge = 1;
+        this.width = 0;
+    }
+    set dataMerge(data) {
+        this._dataMerge = isNumeric(data) ? data : 1;
+    }
+    ;
+    get dataMerge() { return this._dataMerge; }
+}
+CarouselSlideDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselSlideDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+CarouselSlideDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.7", type: CarouselSlideDirective, selector: "ng-template[sfcCarouselSlide]", inputs: { id: "id", dataMerge: "dataMerge", width: "width" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselSlideDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[sfcCarouselSlide]' }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; }, propDecorators: { id: [{
+                type: Input
+            }], dataMerge: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/carousel/models/dom.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9tLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXNmYy1jb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9jYXJvdXNlbC9tb2RlbHMvZG9tLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIENhcm91c2VsRE9NTW9kZWwge1xyXG4gICAgcnRsOiBib29sZWFuO1xyXG4gICAgaXNSZXNwb25zaXZlOiBib29sZWFuO1xyXG4gICAgaXNSZWZyZXNoZWQ6IGJvb2xlYW47XHJcbiAgICBpc0xvYWRlZDogYm9vbGVhbjtcclxuICAgIGlzTG9hZGluZzogYm9vbGVhbjtcclxufSJdfQ==

package/esm2020/lib/components/carousel/models/navigation.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdGlvbi5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1zZmMtY29tcG9uZW50cy9zcmMvbGliL2NvbXBvbmVudHMvY2Fyb3VzZWwvbW9kZWxzL25hdmlnYXRpb24ubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQ2Fyb3VzZWxOYXZpZ2F0aW9uQnV0dG9uTW9kZWwge1xyXG4gICAgZGlzYWJsZWQ6IGJvb2xlYW47XHJcbiAgICBsYWJlbDogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIENhcm91c2VsTmF2aWdhdGlvbk1vZGVsIHtcclxuICAgIGRpc2FibGVkOiBib29sZWFuO1xyXG4gICAgcHJldmlvdXM6IENhcm91c2VsTmF2aWdhdGlvbkJ1dHRvbk1vZGVsO1xyXG4gICAgbmV4dDogQ2Fyb3VzZWxOYXZpZ2F0aW9uQnV0dG9uTW9kZWw7XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQ2Fyb3VzZWxOYXZpZ2F0aW9uRG90IHtcclxuICAgIGlkOiBzdHJpbmc7XHJcbiAgICBhY3RpdmU6IGJvb2xlYW47XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQ2Fyb3VzZWxOYXZpZ2F0aW9uRG90c01vZGVsIHtcclxuICAgIGRpc2FibGVkOiBib29sZWFuO1xyXG4gICAgZG90czogQ2Fyb3VzZWxOYXZpZ2F0aW9uRG90W107XHJcbn0iXX0=

package/esm2020/lib/components/carousel/models/options.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1zZmMtY29tcG9uZW50cy9zcmMvbGliL2NvbXBvbmVudHMvY2Fyb3VzZWwvbW9kZWxzL29wdGlvbnMubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQ2Fyb3VzZWxPcHRpb25zIHtcclxuICAgIGl0ZW1zPzogbnVtYmVyO1xyXG4gICAgc2tpcF92YWxpZGF0ZUl0ZW1zPzogYm9vbGVhbjtcclxuICAgIGxvb3A/OiBib29sZWFuO1xyXG4gICAgY2VudGVyPzogYm9vbGVhbjtcclxuICAgIHJld2luZD86IGJvb2xlYW47XHJcbiAgICBtYXJnaW4/OiBudW1iZXI7XHJcbiAgICBzdGFnZVBhZGRpbmc/OiBudW1iZXI7XHJcbiAgICBtZXJnZT86IGJvb2xlYW47XHJcbiAgICBtZXJnZUZpdD86IGJvb2xlYW47XHJcbiAgICBhdXRvV2lkdGg/OiBib29sZWFuO1xyXG4gICAgcmVzcG9uc2l2ZVJlZnJlc2hSYXRlPzogbnVtYmVyO1xyXG4gICAgbmF2PzogYm9vbGVhbjtcclxuICAgIG5hdlNwZWVkPzogbnVtYmVyIHwgYm9vbGVhbjtcclxuICAgIHNsaWRlQnk/OiBudW1iZXIgfCBzdHJpbmc7XHJcbiAgICBkb3RzPzogYm9vbGVhbjtcclxuICAgIGRvdHNFYWNoPzogbnVtYmVyIHwgYm9vbGVhbjtcclxuICAgIGRvdHNTcGVlZD86IG51bWJlciB8IGJvb2xlYW47XHJcbiAgICBhdXRvcGxheT86IGJvb2xlYW47XHJcbiAgICBhdXRvcGxheVRpbWVvdXQ/OiBudW1iZXI7XHJcbiAgICBhdXRvcGxheVNwZWVkPzogbnVtYmVyIHwgYm9vbGVhbjtcclxuICAgIGF1dG9wbGF5TW91c2VsZWF2ZVRpbWVvdXQ/OiBudW1iZXI7XHJcbiAgICBzbGlkZVRyYW5zaXRpb24/OiBzdHJpbmc7XHJcbiAgICBhbmltYXRlT3V0Pzogc3RyaW5nIHwgYm9vbGVhbjtcclxuICAgIGFuaW1hdGVJbj86IHN0cmluZyB8IGJvb2xlYW47XHJcbiAgICBhdXRvSGVpZ2h0PzogYm9vbGVhbjtcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBDYXJvdXNlbFJlc3BvbnNpdmVNb2RlbCB7XHJcbiAgICBba2V5OiBudW1iZXJdOiBDYXJvdXNlbE9wdGlvbnM7XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQ2Fyb3VzZWxPcHRpb25zTW9kZWwgZXh0ZW5kcyBDYXJvdXNlbE9wdGlvbnMge1xyXG4gICAgc3RhcnRQb3NpdGlvbj86IG51bWJlciB8IHN0cmluZztcclxuICAgIHJ0bD86IGJvb2xlYW47XHJcbiAgICByZXNwb25zaXZlPzogQ2Fyb3VzZWxSZXNwb25zaXZlTW9kZWw7XHJcbiAgICBuYXZUZXh0Pzogc3RyaW5nW107XHJcbiAgICBuYXZpZ2F0aW9uRG90c01vZGVsPzogYm9vbGVhbjtcclxuICAgIGF1dG9wbGF5SG92ZXJQYXVzZT86IGJvb2xlYW47XHJcbiAgICBsYXp5TG9hZD86IGJvb2xlYW47XHJcbiAgICBsYXp5TG9hZEVhZ2VyPzogbnVtYmVyO1xyXG59Il19

package/esm2020/lib/components/carousel/models/slide.model.mjs

@@ -0,0 +1,3 @@
+;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpZGUubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtc2ZjLWNvbXBvbmVudHMvc3JjL2xpYi9jb21wb25lbnRzL2Nhcm91c2VsL21vZGVscy9zbGlkZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUEyQkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFRlbXBsYXRlUmVmIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQ2Fyb3VzZWxTbGlkZU1vZGVsIHtcclxuICAgIGlkOiBzdHJpbmc7XHJcbiAgICBpc0FjdGl2ZT86IGJvb2xlYW47XHJcbiAgICB0cGxSZWY6IFRlbXBsYXRlUmVmPGFueT4gfCBudWxsO1xyXG4gICAgZGF0YU1lcmdlPzogbnVtYmVyO1xyXG4gICAgd2lkdGg/OiBudW1iZXIgfCBzdHJpbmc7XHJcbiAgICBtYXJnaW5MPzogbnVtYmVyIHwgc3RyaW5nO1xyXG4gICAgbWFyZ2luUj86IG51bWJlciB8IHN0cmluZztcclxuICAgIGlzQ2VudGVyZWQ/OiBib29sZWFuO1xyXG4gICAgY2VudGVyPzogYm9vbGVhbjtcclxuICAgIGlzQ2xvbmVkPzogYm9vbGVhbjtcclxuICAgIGxvYWQ/OiBib29sZWFuO1xyXG4gICAgbGVmdD86IG51bWJlciB8IHN0cmluZztcclxuICAgIGNsYXNzZXM6IHsgW2tleTogc3RyaW5nXTogYm9vbGVhbiB9O1xyXG4gICAgaXNBbmltYXRlZD86IGJvb2xlYW47XHJcbiAgICBpc0RlZkFuaW1hdGVkSW4/OiBib29sZWFuOyAgIFxyXG4gICAgaXNEZWZBbmltYXRlZE91dD86IGJvb2xlYW47ICAgXHJcbiAgICBpc0N1c3RvbUFuaW1hdGVkSW4/OiBib29sZWFuOyAgIFxyXG4gICAgaXNDdXN0b21BbmltYXRlZE91dD86IGJvb2xlYW47XHJcbiAgICBoZWlnaHRTdGF0ZT86IHN0cmluZztcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBDYXJvdXNlbFNsaWRlRXZlbnQge1xyXG4gICAgc3RhcnRQb3NpdGlvbj86IG51bWJlcjtcclxuICAgIHNsaWRlcz86IENhcm91c2VsU2xpZGVNb2RlbFtdO1xyXG59OyJdfQ==

package/esm2020/lib/components/carousel/parts/stage/carousel-stage.component.mjs

@@ -0,0 +1,83 @@
+import { animate, state, style, transition, trigger } from '@angular/animations';
+import { Component, Input } from '@angular/core';
+import { CommonConstants } from 'ngx-sfc-common';
+import { getCssLikeValue } from 'ngx-sfc-common';
+import * as i0 from "@angular/core";
+import * as i1 from "../../service/carousel/carousel.service";
+import * as i2 from "../../service/animate/carousel-animate.service";
+import * as i3 from "@angular/common";
+export class CarouselStageComponent {
+    constructor(carouselService, animateService) {
+        this.carouselService = carouselService;
+        this.animateService = animateService;
+        this.stageModel = {
+            width: 0,
+            paddingL: 0,
+            paddingR: 0,
+            transform: CommonConstants.EMPTY_STRING,
+            transition: CommonConstants.EMPTY_STRING
+        };
+        this.slidesModel = [];
+        this.preparePublicSlide = (slide) => {
+            const newSlide = { ...slide };
+            newSlide.tplRef = null;
+            return newSlide;
+        };
+    }
+    get styles() {
+        return {
+            width: getCssLikeValue(this.stageModel.width),
+            transform: this.stageModel.transform,
+            transition: this.stageModel.transition,
+            paddingLeft: getCssLikeValue(this.stageModel.paddingL),
+            paddingRight: getCssLikeValue(this.stageModel.paddingR)
+        };
+    }
+    getItemStyles(slide) {
+        return {
+            width: getCssLikeValue(slide.width),
+            marginLeft: getCssLikeValue(slide.marginL),
+            marginRight: getCssLikeValue(slide.marginR),
+            left: getCssLikeValue(slide.left)
+        };
+    }
+    onTransitionEnd() {
+        this.carouselService.onTransitionEnd();
+    }
+    clear(id) {
+        this.animateService.clear(id);
+    }
+}
+CarouselStageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselStageComponent, deps: [{ token: i1.CarouselService }, { token: i2.CarouselAnimateService }], target: i0.ɵɵFactoryTarget.Component });
+CarouselStageComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", type: CarouselStageComponent, selector: "sfc-carousel-stage", inputs: { stageModel: "stageModel", slidesModel: "slidesModel" }, ngImport: i0, template: "<div class=\"container\" [ngStyle]=\"styles\" (transitionend)=\"onTransitionEnd()\">\r\n    <ng-container *ngFor=\"let slide of slidesModel; let i = index\">\r\n        <div class=\"item\" [ngClass]=\"slide.classes\" [ngStyle]=\"getItemStyles(slide)\" (animationend)=\"clear(slide.id)\"\r\n            [@autoHeight]=\"slide.heightState\">\r\n            <ng-template *ngIf=\"slide.load\" [ngTemplateOutlet]=\"slide.tplRef\"\r\n                [ngTemplateOutletContext]=\"{ $implicit: preparePublicSlide(slide), index: i }\">\r\n            </ng-template>\r\n        </div>\r\n    </ng-container>\r\n</div>", styles: [":host .container{position:relative;touch-action:pan-y;touch-action:manipulation;-webkit-backface-visibility:hidden;backface-visibility:hidden}:host .container:after{content:\".\";display:block;clear:both;visibility:hidden;line-height:0;height:0}:host .container .item{-webkit-backface-visibility:hidden;backface-visibility:hidden;transform:translate(0);position:relative;min-height:1px;float:left;-webkit-tap-highlight-color:transparent;-webkit-touch-callout:none}:host .container .item.center{z-index:5}:host .container .item img{display:block;width:100%}\n"], directives: [{ type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], animations: [
+        trigger('autoHeight', [
+            state('nulled', style({ height: 0 })),
+            state('full', style({ height: '*' })),
+            transition('full => nulled', [
+                animate('700ms 350ms')
+            ]),
+            transition('nulled => full', [
+                animate(350)
+            ]),
+        ])
+    ] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselStageComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sfc-carousel-stage', animations: [
+                        trigger('autoHeight', [
+                            state('nulled', style({ height: 0 })),
+                            state('full', style({ height: '*' })),
+                            transition('full => nulled', [
+                                animate('700ms 350ms')
+                            ]),
+                            transition('nulled => full', [
+                                animate(350)
+                            ]),
+                        ])
+                    ], template: "<div class=\"container\" [ngStyle]=\"styles\" (transitionend)=\"onTransitionEnd()\">\r\n    <ng-container *ngFor=\"let slide of slidesModel; let i = index\">\r\n        <div class=\"item\" [ngClass]=\"slide.classes\" [ngStyle]=\"getItemStyles(slide)\" (animationend)=\"clear(slide.id)\"\r\n            [@autoHeight]=\"slide.heightState\">\r\n            <ng-template *ngIf=\"slide.load\" [ngTemplateOutlet]=\"slide.tplRef\"\r\n                [ngTemplateOutletContext]=\"{ $implicit: preparePublicSlide(slide), index: i }\">\r\n            </ng-template>\r\n        </div>\r\n    </ng-container>\r\n</div>", styles: [":host .container{position:relative;touch-action:pan-y;touch-action:manipulation;-webkit-backface-visibility:hidden;backface-visibility:hidden}:host .container:after{content:\".\";display:block;clear:both;visibility:hidden;line-height:0;height:0}:host .container .item{-webkit-backface-visibility:hidden;backface-visibility:hidden;transform:translate(0);position:relative;min-height:1px;float:left;-webkit-tap-highlight-color:transparent;-webkit-touch-callout:none}:host .container .item.center{z-index:5}:host .container .item img{display:block;width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.CarouselService }, { type: i2.CarouselAnimateService }]; }, propDecorators: { stageModel: [{
+                type: Input
+            }], slidesModel: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/carousel/parts/stage/carousel-stage.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fyb3VzZWwtc3RhZ2UubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtc2ZjLWNvbXBvbmVudHMvc3JjL2xpYi9jb21wb25lbnRzL2Nhcm91c2VsL3BhcnRzL3N0YWdlL2Nhcm91c2VsLXN0YWdlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIENhcm91c2VsU3RhZ2VNb2RlbCB7XHJcbiAgICB0cmFuc2Zvcm06IHN0cmluZztcclxuICAgIHRyYW5zaXRpb246IHN0cmluZztcclxuICAgIHdpZHRoOiBudW1iZXIgfCBzdHJpbmc7XHJcbiAgICBwYWRkaW5nTDogbnVtYmVyIHwgc3RyaW5nO1xyXG4gICAgcGFkZGluZ1I6IG51bWJlciB8IHN0cmluZztcclxufVxyXG4iXX0=

package/esm2020/lib/components/carousel/service/animate/carousel-animate.service.mjs

@@ -0,0 +1,86 @@
+import { Injectable } from '@angular/core';
+import { CommonConstants } from 'ngx-sfc-common';
+import { getCssLikeValue } from 'ngx-sfc-common';
+import { tap, merge } from 'rxjs';
+import { CarouselProperty } from '../../carousel.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../carousel/carousel.service";
+export class CarouselAnimateService {
+    constructor(carouselService) {
+        this.carouselService = carouselService;
+        this.swapping = true;
+        this.next = undefined;
+        this.initDataStreams();
+    }
+    ngOnDestroy() {
+        this.animateSubscription.unsubscribe();
+    }
+    initDataStreams() {
+        const changeSettings$ = this.carouselService.changeState.pipe(tap(data => {
+            if (data.property.name === CarouselProperty.Position) {
+                this.previous = this.carouselService.current();
+                this.next = data.property.value;
+            }
+        }));
+        const translateCarousel$ = this.carouselService.translateState.pipe(tap(() => {
+            if (this.swapping && (this.carouselService.options.animateOut || this.carouselService.options.animateIn)) {
+                this.swap();
+            }
+        }));
+        this.animateSubscription = merge(changeSettings$, translateCarousel$).subscribe();
+    }
+    swap() {
+        if (this.carouselService.settings.items !== 1)
+            return;
+        this.carouselService.speed(0);
+        let left;
+        const previous = this.carouselService.slidesModel[this.previous || 0], next = this.carouselService.slidesModel[this.next || 0], incoming = this.carouselService.settings.animateIn, outgoing = this.carouselService.settings.animateOut;
+        if (this.carouselService.current() === this.previous)
+            return;
+        if (outgoing) {
+            left = +this.carouselService.coordinates(this.previous) - +this.carouselService.coordinates(this.next);
+            this.carouselService.slidesModel.forEach(slide => {
+                if (slide.id === previous.id) {
+                    slide.left = getCssLikeValue(left);
+                    slide.isAnimated = true;
+                    slide.isDefAnimatedOut = true;
+                    slide.isCustomAnimatedOut = true;
+                }
+            });
+        }
+        if (incoming) {
+            this.carouselService.slidesModel.forEach(slide => {
+                if (slide.id === next.id) {
+                    slide.isAnimated = true;
+                    slide.isDefAnimatedIn = true;
+                    slide.isCustomAnimatedIn = true;
+                }
+            });
+        }
+    }
+    ;
+    clear(id) {
+        this.carouselService.slidesModel.forEach(slide => {
+            if (slide.id === id) {
+                slide.left = CommonConstants.EMPTY_STRING;
+                slide.isAnimated = false;
+                slide.isDefAnimatedOut = false;
+                slide.isCustomAnimatedOut = false;
+                slide.isDefAnimatedIn = false;
+                slide.isCustomAnimatedIn = false;
+                slide.classes = this.carouselService.setCurrentSlideClasses(slide);
+            }
+        });
+        this.carouselService.onTransitionEnd();
+    }
+    ;
+}
+CarouselAnimateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselAnimateService, deps: [{ token: i1.CarouselService }], target: i0.ɵɵFactoryTarget.Injectable });
+CarouselAnimateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselAnimateService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselAnimateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CarouselService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"carousel-animate.service.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-sfc-components/src/lib/components/carousel/service/animate/carousel-animate.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAa,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,GAAG,EAA4B,KAAK,EAAE,MAAM,MAAM,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;;;AAMvD,MAAM,OAAO,sBAAsB;IAUjC,YAAoB,eAAgC;QAAhC,oBAAe,GAAf,eAAe,CAAiB;QAR5C,aAAQ,GAAG,IAAI,CAAC;QAIhB,SAAI,GAAG,SAAS,CAAC;QAKvB,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;IAED,WAAW;QACT,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC;IACzC,CAAC;IAEO,eAAe;QACrB,MAAM,eAAe,GAAoB,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,CAC5E,GAAG,CAAC,IAAI,CAAC,EAAE;YACT,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,gBAAgB,CAAC,QAAQ,EAAE;gBACpD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC;gBAC/C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;aACjC;QACH,CAAC,CAAC,CACH,CAAC;QAEF,MAAM,kBAAkB,GAAuB,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,IAAI,CACrF,GAAG,CAAC,GAAG,EAAE;YACP,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,UAAU,IAAI,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE;gBACxG,IAAI,CAAC,IAAI,EAAE,CAAC;aACb;QACH,CAAC,CAAC,CACH,CAAC;QAEF,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC,eAAe,EAAE,kBAAkB,CAAC,CAAC,SAAS,EAAE,CAAC;IACpF,CAAC;IAEO,IAAI;QACV,IAAI,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,KAAK,KAAK,CAAC;YAC3C,OAAO;QAET,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAE9B,IAAI,IAAY,CAAC;QACjB,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,EACnE,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,EACvD,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,SAAS,EAClD,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,UAAU,CAAC;QAEtD,IAAI,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,KAAK,IAAI,CAAC,QAAQ;YAClD,OAAO;QAET,IAAI,QAAQ,EAAE;YACZ,IAAI,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACvG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBAC/C,IAAI,KAAK,CAAC,EAAE,KAAK,QAAQ,CAAC,EAAE,EAAE;oBAC5B,KAAK,CAAC,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;oBACnC,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC;oBACxB,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC;oBAC9B,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC;iBAClC;YACH,CAAC,CAAC,CAAC;SACJ;QAED,IAAI,QAAQ,EAAE;YACZ,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBAC/C,IAAI,KAAK,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,EAAE;oBACxB,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC;oBACxB,KAAK,CAAC,eAAe,GAAG,IAAI,CAAC;oBAC7B,KAAK,CAAC,kBAAkB,GAAG,IAAI,CAAC;iBACjC;YACH,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAAA,CAAC;IAEF,KAAK,CAAC,EAAU;QACd,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YAC/C,IAAI,KAAK,CAAC,EAAE,KAAK,EAAE,EAAE;gBACnB,KAAK,CAAC,IAAI,GAAG,eAAe,CAAC,YAAY,CAAC;gBAC1C,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC;gBACzB,KAAK,CAAC,gBAAgB,GAAG,KAAK,CAAC;gBAC/B,KAAK,CAAC,mBAAmB,GAAG,KAAK,CAAC;gBAClC,KAAK,CAAC,eAAe,GAAG,KAAK,CAAC;gBAC9B,KAAK,CAAC,kBAAkB,GAAG,KAAK,CAAC;gBACjC,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;aACpE;QACH,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,CAAC,eAAe,EAAE,CAAC;IACzC,CAAC;IAAA,CAAC;;mHA1FS,sBAAsB;uHAAtB,sBAAsB,cAFrB,MAAM;2FAEP,sBAAsB;kBAHlC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\r\nimport { CommonConstants } from 'ngx-sfc-common';\r\nimport { getCssLikeValue } from 'ngx-sfc-common';\r\nimport { tap, Observable, Subscription, merge } from 'rxjs';\r\nimport { CarouselProperty } from '../../carousel.enum';\r\nimport { CarouselService } from '../carousel/carousel.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CarouselAnimateService implements OnDestroy {\r\n\r\n  private swapping = true;\r\n\r\n  private previous?: number;\r\n\r\n  private next = undefined;\r\n\r\n  private animateSubscription!: Subscription;\r\n\r\n  constructor(private carouselService: CarouselService) {\r\n    this.initDataStreams();\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.animateSubscription.unsubscribe();\r\n  }\r\n\r\n  private initDataStreams() {\r\n    const changeSettings$: Observable<any> = this.carouselService.changeState.pipe(\r\n      tap(data => {\r\n        if (data.property.name === CarouselProperty.Position) {\r\n          this.previous = this.carouselService.current();\r\n          this.next = data.property.value;\r\n        }\r\n      })\r\n    );\r\n\r\n    const translateCarousel$: Observable<string> = this.carouselService.translateState.pipe(\r\n      tap(() => {\r\n        if (this.swapping && (this.carouselService.options.animateOut || this.carouselService.options.animateIn)) {\r\n          this.swap();\r\n        }\r\n      })\r\n    );\r\n\r\n    this.animateSubscription = merge(changeSettings$, translateCarousel$).subscribe();\r\n  }\r\n\r\n  private swap(): void {\r\n    if (this.carouselService.settings.items !== 1)\r\n      return;\r\n\r\n    this.carouselService.speed(0);\r\n\r\n    let left: number;\r\n    const previous = this.carouselService.slidesModel[this.previous || 0],\r\n      next = this.carouselService.slidesModel[this.next || 0],\r\n      incoming = this.carouselService.settings.animateIn,\r\n      outgoing = this.carouselService.settings.animateOut;\r\n\r\n    if (this.carouselService.current() === this.previous)\r\n      return;\r\n\r\n    if (outgoing) {\r\n      left = +this.carouselService.coordinates(this.previous) - +this.carouselService.coordinates(this.next);\r\n      this.carouselService.slidesModel.forEach(slide => {\r\n        if (slide.id === previous.id) {\r\n          slide.left = getCssLikeValue(left);\r\n          slide.isAnimated = true;\r\n          slide.isDefAnimatedOut = true;\r\n          slide.isCustomAnimatedOut = true;\r\n        }\r\n      });\r\n    }\r\n\r\n    if (incoming) {\r\n      this.carouselService.slidesModel.forEach(slide => {\r\n        if (slide.id === next.id) {\r\n          slide.isAnimated = true;\r\n          slide.isDefAnimatedIn = true;\r\n          slide.isCustomAnimatedIn = true;\r\n        }\r\n      });\r\n    }\r\n  };\r\n\r\n  clear(id: string) {\r\n    this.carouselService.slidesModel.forEach(slide => {\r\n      if (slide.id === id) {\r\n        slide.left = CommonConstants.EMPTY_STRING;\r\n        slide.isAnimated = false;\r\n        slide.isDefAnimatedOut = false;\r\n        slide.isCustomAnimatedOut = false;\r\n        slide.isDefAnimatedIn = false;\r\n        slide.isCustomAnimatedIn = false;\r\n        slide.classes = this.carouselService.setCurrentSlideClasses(slide);\r\n      }\r\n    });\r\n    this.carouselService.onTransitionEnd();\r\n  };\r\n}\r\n"]}