ngx-bootstrap 7.0.1 → 8.0.0-RC.1

package/carousel/esm2020/carousel.component.mjs

@@ -0,0 +1,711 @@
+/***
+ * pause (not yet supported) (?string='hover') - event group name which pauses
+ * the cycling of the carousel, if hover pauses on mouseenter and resumes on
+ * mouseleave keyboard (not yet supported) (?boolean=true) - if false
+ * carousel will not react to keyboard events
+ * note: swiping not yet supported
+ */
+/****
+ * Problems:
+ * 1) if we set an active slide via model changes, .active class remains on a
+ * current slide.
+ * 2) if we have only one slide, we shouldn't show prev/next nav buttons
+ * 3) if first or last slide is active and noWrap is true, there should be
+ * "disabled" class on the nav buttons.
+ * 4) default interval should be equal 5000
+ */
+import { Component, EventEmitter, Input, NgZone, Output } from '@angular/core';
+import { isBs3, LinkedList, getBsVer } from 'ngx-bootstrap/utils';
+import { CarouselConfig } from './carousel.config';
+import { findLastIndex, chunkByNumber, isNumber } from './utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./carousel.config";
+import * as i2 from "@angular/common";
+export var Direction;
+(function (Direction) {
+    Direction[Direction["UNKNOWN"] = 0] = "UNKNOWN";
+    Direction[Direction["NEXT"] = 1] = "NEXT";
+    Direction[Direction["PREV"] = 2] = "PREV";
+})(Direction || (Direction = {}));
+let _currentId = 1;
+/**
+ * Base element to create carousel
+ */
+export class CarouselComponent {
+    constructor(config, ngZone) {
+        this.ngZone = ngZone;
+        /* If `true` — carousel will not cycle continuously and will have hard stops (prevent looping) */
+        this.noWrap = false;
+        /*  If `true` — will disable pausing on carousel mouse hover */
+        this.noPause = false;
+        /*  If `true` — carousel-indicators are visible  */
+        this.showIndicators = true;
+        /*  If `true` - autoplay will be stopped on focus */
+        this.pauseOnFocus = false;
+        /* If `true` - carousel indicators indicate slides chunks
+           works ONLY if singleSlideOffset = FALSE */
+        this.indicatorsByChunk = false;
+        /* If value more then 1 — carousel works in multilist mode */
+        this.itemsPerSlide = 1;
+        /* If `true` — carousel shifts by one element. By default carousel shifts by number
+           of visible elements (itemsPerSlide field) */
+        this.singleSlideOffset = false;
+        /** Turn on/off animation. Animation doesn't work for multilist carousel */
+        this.isAnimated = false;
+        /** Will be emitted when active slide has been changed. Part of two-way-bindable [(activeSlide)] property */
+        this.activeSlideChange = new EventEmitter(false);
+        /** Will be emitted when active slides has been changed in multilist mode */
+        this.slideRangeChange = new EventEmitter();
+        /* Index to start display slides from it */
+        this.startFromIndex = 0;
+        this._interval = 5000;
+        this._slides = new LinkedList();
+        this._currentVisibleSlidesIndex = 0;
+        this.isPlaying = false;
+        this.destroyed = false;
+        this.currentId = 0;
+        this.getActive = (slide) => slide.active;
+        this.makeSlidesConsistent = (slides) => {
+            slides.forEach((slide, index) => slide.item.order = index);
+        };
+        Object.assign(this, config);
+        this.currentId = _currentId++;
+    }
+    /** Index of currently displayed slide(started for 0) */
+    set activeSlide(index) {
+        if (this.multilist) {
+            return;
+        }
+        if (isNumber(index)) {
+            this.customActiveSlide = index;
+        }
+        if (this._slides.length && index !== this._currentActiveSlide) {
+            this._select(index);
+        }
+    }
+    get activeSlide() {
+        return this._currentActiveSlide || 0;
+    }
+    /**
+     * Delay of item cycling in milliseconds. If false, carousel won't cycle
+     * automatically.
+     */
+    get interval() {
+        return this._interval;
+    }
+    set interval(value) {
+        this._interval = value;
+        this.restartTimer();
+    }
+    get slides() {
+        return this._slides.toArray();
+    }
+    get isFirstSlideVisible() {
+        const indexes = this.getVisibleIndexes();
+        if (!indexes || (indexes instanceof Array && !indexes.length)) {
+            return false;
+        }
+        return indexes.includes(0);
+    }
+    get isLastSlideVisible() {
+        const indexes = this.getVisibleIndexes();
+        if (!indexes || (indexes instanceof Array && !indexes.length)) {
+            return false;
+        }
+        return indexes.includes(this._slides.length - 1);
+    }
+    get isBs4() {
+        return !isBs3();
+    }
+    get _bsVer() {
+        return getBsVer();
+    }
+    ngAfterViewInit() {
+        setTimeout(() => {
+            if (this.singleSlideOffset) {
+                this.indicatorsByChunk = false;
+            }
+            if (this.multilist) {
+                this._chunkedSlides = chunkByNumber(this.mapSlidesAndIndexes(), this.itemsPerSlide);
+                this.selectInitialSlides();
+            }
+            if (this.customActiveSlide && !this.multilist) {
+                this._select(this.customActiveSlide);
+            }
+        }, 0);
+    }
+    ngOnDestroy() {
+        this.destroyed = true;
+    }
+    /**
+     * Adds new slide. If this slide is first in collection - set it as active
+     * and starts auto changing
+     * @param slide
+     */
+    addSlide(slide) {
+        this._slides.add(slide);
+        if (this.multilist && this._slides.length <= this.itemsPerSlide) {
+            slide.active = true;
+        }
+        if (!this.multilist && this.isAnimated) {
+            slide.isAnimated = true;
+        }
+        if (!this.multilist && this._slides.length === 1) {
+            this._currentActiveSlide = undefined;
+            if (!this.customActiveSlide) {
+                this.activeSlide = 0;
+            }
+            this.play();
+        }
+        if (this.multilist && this._slides.length > this.itemsPerSlide) {
+            this.play();
+        }
+    }
+    /**
+     * Removes specified slide. If this slide is active - will roll to another
+     * slide
+     * @param slide
+     */
+    removeSlide(slide) {
+        const remIndex = this._slides.indexOf(slide);
+        if (this._currentActiveSlide === remIndex) {
+            // removing of active slide
+            let nextSlideIndex;
+            if (this._slides.length > 1) {
+                // if this slide last - will roll to first slide, if noWrap flag is
+                // FALSE or to previous, if noWrap is TRUE in case, if this slide in
+                // middle of collection, index of next slide is same to removed
+                nextSlideIndex = !this.isLast(remIndex)
+                    ? remIndex
+                    : this.noWrap ? remIndex - 1 : 0;
+            }
+            this._slides.remove(remIndex);
+            // prevents exception with changing some value after checking
+            setTimeout(() => {
+                this._select(nextSlideIndex);
+            }, 0);
+        }
+        else {
+            this._slides.remove(remIndex);
+            const currentSlideIndex = this.getCurrentSlideIndex();
+            setTimeout(() => {
+                // after removing, need to actualize index of current active slide
+                this._currentActiveSlide = currentSlideIndex;
+                this.activeSlideChange.emit(this._currentActiveSlide);
+            }, 0);
+        }
+    }
+    nextSlideFromInterval(force = false) {
+        this.move(Direction.NEXT, force);
+    }
+    /**
+     * Rolling to next slide
+     * @param force: {boolean} if true - will ignore noWrap flag
+     */
+    nextSlide(force = false) {
+        if (this.isPlaying) {
+            this.restartTimer();
+        }
+        this.move(Direction.NEXT, force);
+    }
+    /**
+     * Rolling to previous slide
+     * @param force: {boolean} if true - will ignore noWrap flag
+     */
+    previousSlide(force = false) {
+        if (this.isPlaying) {
+            this.restartTimer();
+        }
+        this.move(Direction.PREV, force);
+    }
+    getFirstVisibleIndex() {
+        return this.slides.findIndex(this.getActive);
+    }
+    getLastVisibleIndex() {
+        return findLastIndex(this.slides, this.getActive);
+    }
+    move(direction, force = false) {
+        const firstVisibleIndex = this.getFirstVisibleIndex();
+        const lastVisibleIndex = this.getLastVisibleIndex();
+        if (this.noWrap) {
+            if (direction === Direction.NEXT &&
+                this.isLast(lastVisibleIndex) ||
+                direction === Direction.PREV &&
+                    firstVisibleIndex === 0) {
+                return;
+            }
+        }
+        if (!this.multilist) {
+            this.activeSlide = this.findNextSlideIndex(direction, force) || 0;
+        }
+        else {
+            this.moveMultilist(direction);
+        }
+    }
+    /**
+     * Swith slides by enter, space and arrows keys
+     * @internal
+     */
+    keydownPress(event) {
+        if (event.keyCode === 13 || event.key === 'Enter' || event.keyCode === 32 || event.key === 'Space') {
+            this.nextSlide();
+            event.preventDefault();
+            return;
+        }
+        if (event.keyCode === 37 || event.key === 'LeftArrow') {
+            this.previousSlide();
+            return;
+        }
+        if (event.keyCode === 39 || event.key === 'RightArrow') {
+            this.nextSlide();
+            return;
+        }
+    }
+    /**
+     * Play on mouse leave
+     * @internal
+     */
+    onMouseLeave() {
+        if (!this.pauseOnFocus) {
+            this.play();
+        }
+    }
+    /**
+     * Play on mouse up
+     * @internal
+     */
+    onMouseUp() {
+        if (!this.pauseOnFocus) {
+            this.play();
+        }
+    }
+    /**
+     * When slides on focus autoplay is stopped(optional)
+     * @internal
+     */
+    pauseFocusIn() {
+        if (this.pauseOnFocus) {
+            this.isPlaying = false;
+            this.resetTimer();
+        }
+    }
+    /**
+     * When slides out of focus autoplay is started
+     * @internal
+     */
+    pauseFocusOut() {
+        this.play();
+    }
+    /**
+     * Rolling to specified slide
+     * @param index: {number} index of slide, which must be shown
+     */
+    selectSlide(index) {
+        if (this.isPlaying) {
+            this.restartTimer();
+        }
+        if (!this.multilist) {
+            this.activeSlide = this.indicatorsByChunk ? index * this.itemsPerSlide : index;
+        }
+        else {
+            this.selectSlideRange(this.indicatorsByChunk ? index * this.itemsPerSlide : index);
+        }
+    }
+    /**
+     * Starts a auto changing of slides
+     */
+    play() {
+        if (!this.isPlaying) {
+            this.isPlaying = true;
+            this.restartTimer();
+        }
+    }
+    /**
+     * Stops a auto changing of slides
+     */
+    pause() {
+        if (!this.noPause) {
+            this.isPlaying = false;
+            this.resetTimer();
+        }
+    }
+    /**
+     * Finds and returns index of currently displayed slide
+     */
+    getCurrentSlideIndex() {
+        return this._slides.findIndex(this.getActive);
+    }
+    /**
+     * Defines, whether the specified index is last in collection
+     * @param index
+     */
+    isLast(index) {
+        return index + 1 >= this._slides.length;
+    }
+    /**
+     * Defines, whether the specified index is first in collection
+     * @param index
+     */
+    isFirst(index) {
+        return index === 0;
+    }
+    indicatorsSlides() {
+        return this.slides.filter((slide, index) => !this.indicatorsByChunk || index % this.itemsPerSlide === 0);
+    }
+    selectInitialSlides() {
+        const startIndex = this.startFromIndex <= this._slides.length
+            ? this.startFromIndex
+            : 0;
+        this.hideSlides();
+        if (this.singleSlideOffset) {
+            this._slidesWithIndexes = this.mapSlidesAndIndexes();
+            if (this._slides.length - startIndex < this.itemsPerSlide) {
+                const slidesToAppend = this._slidesWithIndexes.slice(0, startIndex);
+                this._slidesWithIndexes = [
+                    ...this._slidesWithIndexes,
+                    ...slidesToAppend
+                ]
+                    .slice(slidesToAppend.length)
+                    .slice(0, this.itemsPerSlide);
+            }
+            else {
+                this._slidesWithIndexes = this._slidesWithIndexes.slice(startIndex, startIndex + this.itemsPerSlide);
+            }
+            this._slidesWithIndexes.forEach((slide) => slide.item.active = true);
+            this.makeSlidesConsistent(this._slidesWithIndexes);
+        }
+        else {
+            this.selectRangeByNestedIndex(startIndex);
+        }
+        this.slideRangeChange.emit(this.getVisibleIndexes());
+    }
+    /**
+     * Defines next slide index, depending of direction
+     * @param direction: Direction(UNKNOWN|PREV|NEXT)
+     * @param force: {boolean} if TRUE - will ignore noWrap flag, else will
+     *   return undefined if next slide require wrapping
+     */
+    findNextSlideIndex(direction, force) {
+        let nextSlideIndex = 0;
+        if (!force &&
+            (this.isLast(this.activeSlide) &&
+                direction !== Direction.PREV &&
+                this.noWrap)) {
+            return;
+        }
+        switch (direction) {
+            case Direction.NEXT:
+                // if this is last slide, not force, looping is disabled
+                // and need to going forward - select current slide, as a next
+                if (typeof this._currentActiveSlide === 'undefined') {
+                    nextSlideIndex = 0;
+                    break;
+                }
+                if (!this.isLast(this._currentActiveSlide)) {
+                    nextSlideIndex = this._currentActiveSlide + 1;
+                    break;
+                }
+                nextSlideIndex = !force && this.noWrap ? this._currentActiveSlide : 0;
+                break;
+            case Direction.PREV:
+                // if this is first slide, not force, looping is disabled
+                // and need to going backward - select current slide, as a next
+                if (typeof this._currentActiveSlide === 'undefined') {
+                    nextSlideIndex = 0;
+                    break;
+                }
+                if (this._currentActiveSlide > 0) {
+                    nextSlideIndex = this._currentActiveSlide - 1;
+                    break;
+                }
+                if (!force && this.noWrap) {
+                    nextSlideIndex = this._currentActiveSlide;
+                    break;
+                }
+                nextSlideIndex = this._slides.length - 1;
+                break;
+            default:
+                throw new Error('Unknown direction');
+        }
+        return nextSlideIndex;
+    }
+    mapSlidesAndIndexes() {
+        return this.slides
+            .slice()
+            .map((slide, index) => {
+            return {
+                index,
+                item: slide
+            };
+        });
+    }
+    selectSlideRange(index) {
+        if (this.isIndexInRange(index)) {
+            return;
+        }
+        this.hideSlides();
+        if (!this.singleSlideOffset) {
+            this.selectRangeByNestedIndex(index);
+        }
+        else {
+            const startIndex = this.isIndexOnTheEdges(index)
+                ? index
+                : index - this.itemsPerSlide + 1;
+            const endIndex = this.isIndexOnTheEdges(index)
+                ? index + this.itemsPerSlide
+                : index + 1;
+            this._slidesWithIndexes = this.mapSlidesAndIndexes().slice(startIndex, endIndex);
+            this.makeSlidesConsistent(this._slidesWithIndexes);
+            this._slidesWithIndexes.forEach((slide) => slide.item.active = true);
+        }
+        this.slideRangeChange.emit(this.getVisibleIndexes());
+    }
+    selectRangeByNestedIndex(index) {
+        if (!this._chunkedSlides) {
+            return;
+        }
+        const selectedRange = this._chunkedSlides
+            .map((slidesList, i) => {
+            return {
+                index: i,
+                list: slidesList
+            };
+        })
+            .find((slidesList) => {
+            return slidesList.list.find(slide => slide.index === index) !== undefined;
+        });
+        if (!selectedRange) {
+            return;
+        }
+        this._currentVisibleSlidesIndex = selectedRange.index;
+        this._chunkedSlides[selectedRange.index].forEach((slide) => {
+            slide.item.active = true;
+        });
+    }
+    isIndexOnTheEdges(index) {
+        return (index + 1 - this.itemsPerSlide <= 0 ||
+            index + this.itemsPerSlide <= this._slides.length);
+    }
+    isIndexInRange(index) {
+        if (this.singleSlideOffset && this._slidesWithIndexes) {
+            const visibleIndexes = this._slidesWithIndexes.map((slide) => slide.index);
+            return visibleIndexes.indexOf(index) >= 0;
+        }
+        return (index <= this.getLastVisibleIndex() &&
+            index >= this.getFirstVisibleIndex());
+    }
+    hideSlides() {
+        this.slides.forEach((slide) => slide.active = false);
+    }
+    isVisibleSlideListLast() {
+        if (!this._chunkedSlides) {
+            return false;
+        }
+        return this._currentVisibleSlidesIndex === this._chunkedSlides.length - 1;
+    }
+    isVisibleSlideListFirst() {
+        return this._currentVisibleSlidesIndex === 0;
+    }
+    moveSliderByOneItem(direction) {
+        let firstVisibleIndex;
+        let lastVisibleIndex;
+        let indexToHide;
+        let indexToShow;
+        if (this.noWrap) {
+            firstVisibleIndex = this.getFirstVisibleIndex();
+            lastVisibleIndex = this.getLastVisibleIndex();
+            indexToHide = direction === Direction.NEXT
+                ? firstVisibleIndex
+                : lastVisibleIndex;
+            indexToShow = direction !== Direction.NEXT
+                ? firstVisibleIndex - 1
+                : !this.isLast(lastVisibleIndex)
+                    ? lastVisibleIndex + 1 : 0;
+            const slideToHide = this._slides.get(indexToHide);
+            if (slideToHide) {
+                slideToHide.active = false;
+            }
+            const slideToShow = this._slides.get(indexToShow);
+            if (slideToShow) {
+                slideToShow.active = true;
+            }
+            const slidesToReorder = this.mapSlidesAndIndexes().filter((slide) => slide.item.active);
+            this.makeSlidesConsistent(slidesToReorder);
+            if (this.singleSlideOffset) {
+                this._slidesWithIndexes = slidesToReorder;
+            }
+            this.slideRangeChange.emit(this.getVisibleIndexes());
+            return;
+        }
+        if (!this._slidesWithIndexes || !this._slidesWithIndexes[0]) {
+            return;
+        }
+        let index;
+        firstVisibleIndex = this._slidesWithIndexes[0].index;
+        lastVisibleIndex = this._slidesWithIndexes[this._slidesWithIndexes.length - 1].index;
+        if (direction === Direction.NEXT) {
+            this._slidesWithIndexes.shift();
+            index = this.isLast(lastVisibleIndex)
+                ? 0
+                : lastVisibleIndex + 1;
+            const item = this._slides.get(index);
+            if (item) {
+                this._slidesWithIndexes.push({ index, item });
+            }
+        }
+        else {
+            this._slidesWithIndexes.pop();
+            index = this.isFirst(firstVisibleIndex)
+                ? this._slides.length - 1
+                : firstVisibleIndex - 1;
+            const item = this._slides.get(index);
+            if (item) {
+                this._slidesWithIndexes = [{ index, item }, ...this._slidesWithIndexes];
+            }
+        }
+        this.hideSlides();
+        this._slidesWithIndexes.forEach(slide => slide.item.active = true);
+        this.makeSlidesConsistent(this._slidesWithIndexes);
+        this.slideRangeChange.emit(this._slidesWithIndexes.map((slide) => slide.index));
+    }
+    moveMultilist(direction) {
+        if (this.singleSlideOffset) {
+            this.moveSliderByOneItem(direction);
+        }
+        else {
+            this.hideSlides();
+            if (this.noWrap) {
+                this._currentVisibleSlidesIndex = direction === Direction.NEXT
+                    ? this._currentVisibleSlidesIndex + 1
+                    : this._currentVisibleSlidesIndex - 1;
+            }
+            else if (direction === Direction.NEXT) {
+                this._currentVisibleSlidesIndex = this.isVisibleSlideListLast()
+                    ? 0
+                    : this._currentVisibleSlidesIndex + 1;
+            }
+            else {
+                if (this.isVisibleSlideListFirst()) {
+                    this._currentVisibleSlidesIndex = this._chunkedSlides
+                        ? this._chunkedSlides.length - 1
+                        : 0;
+                }
+                else {
+                    this._currentVisibleSlidesIndex = this._currentVisibleSlidesIndex - 1;
+                }
+            }
+            if (this._chunkedSlides) {
+                this._chunkedSlides[this._currentVisibleSlidesIndex].forEach((slide) => slide.item.active = true);
+            }
+            this.slideRangeChange.emit(this.getVisibleIndexes());
+        }
+    }
+    getVisibleIndexes() {
+        if (!this.singleSlideOffset && this._chunkedSlides) {
+            return this._chunkedSlides[this._currentVisibleSlidesIndex]
+                .map((slide) => slide.index);
+        }
+        if (this._slidesWithIndexes) {
+            return this._slidesWithIndexes.map((slide) => slide.index);
+        }
+    }
+    /**
+     * Sets a slide, which specified through index, as active
+     * @param index
+     */
+    _select(index) {
+        if (isNaN(index)) {
+            this.pause();
+            return;
+        }
+        if (!this.multilist && typeof this._currentActiveSlide !== 'undefined') {
+            const currentSlide = this._slides.get(this._currentActiveSlide);
+            if (typeof currentSlide !== 'undefined') {
+                currentSlide.active = false;
+            }
+        }
+        const nextSlide = this._slides.get(index);
+        if (typeof nextSlide !== 'undefined') {
+            this._currentActiveSlide = index;
+            nextSlide.active = true;
+            this.activeSlide = index;
+            this.activeSlideChange.emit(index);
+        }
+    }
+    /**
+     * Starts loop of auto changing of slides
+     */
+    restartTimer() {
+        this.resetTimer();
+        const interval = +this.interval;
+        if (!isNaN(interval) && interval > 0) {
+            this.currentInterval = this.ngZone.runOutsideAngular(() => {
+                return window.setInterval(() => {
+                    const nInterval = +this.interval;
+                    this.ngZone.run(() => {
+                        if (this.isPlaying &&
+                            !isNaN(this.interval) &&
+                            nInterval > 0 &&
+                            this.slides.length) {
+                            this.nextSlideFromInterval();
+                        }
+                        else {
+                            this.pause();
+                        }
+                    });
+                }, interval);
+            });
+        }
+    }
+    get multilist() {
+        return this.itemsPerSlide > 1;
+    }
+    /**
+     * Stops loop of auto changing of slides
+     */
+    resetTimer() {
+        if (this.currentInterval) {
+            clearInterval(this.currentInterval);
+            this.currentInterval = void 0;
+        }
+    }
+    checkDisabledClass(buttonType) {
+        if (buttonType === 'prev') {
+            return (this.activeSlide === 0 && this.noWrap && !this.multilist) || (this.isFirstSlideVisible && this.noWrap && this.multilist);
+        }
+        return (this.isLast(this.activeSlide) && this.noWrap && !this.multilist) || (this.isLastSlideVisible && this.noWrap && this.multilist);
+    }
+}
+CarouselComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CarouselComponent, deps: [{ token: i1.CarouselConfig }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+CarouselComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: CarouselComponent, selector: "carousel", inputs: { noWrap: "noWrap", noPause: "noPause", showIndicators: "showIndicators", pauseOnFocus: "pauseOnFocus", indicatorsByChunk: "indicatorsByChunk", itemsPerSlide: "itemsPerSlide", singleSlideOffset: "singleSlideOffset", isAnimated: "isAnimated", activeSlide: "activeSlide", startFromIndex: "startFromIndex", interval: "interval" }, outputs: { activeSlideChange: "activeSlideChange", slideRangeChange: "slideRangeChange" }, ngImport: i0, template: "<div (mouseenter)=\"pause()\"\n     (mouseleave)=\"onMouseLeave()\"\n     (mouseup)=\"onMouseUp()\"\n     (keydown)=\"keydownPress($event)\"\n     (focusin)=\"pauseFocusIn()\"\n     (focusout)=\"pauseFocusOut()\"\n     [id]=\"currentId\"\n     class=\"carousel slide\" tabindex=\"0\">\n  <ng-container *ngIf=\"!_bsVer.isBs5 && showIndicators && slides.length > 1\">\n    <ol class=\"carousel-indicators\">\n      <li *ngFor=\"let slide of indicatorsSlides(); let i = index;\"\n          [class.active]=\"slide.active === true\"\n          (click)=\"selectSlide(i)\">\n      </li>\n    </ol>\n  </ng-container>\n  <ng-container *ngIf=\"_bsVer.isBs5 && showIndicators && slides.length > 1\">\n    <div class=\"carousel-indicators\">\n      <button\n        *ngFor=\"let slide of indicatorsSlides(); let i = index;\"\n        [class.active]=\"slide.active === true\"\n        (click)=\"selectSlide(i)\"\n        type=\"button\"\n        [attr.data-bs-target]=\"'#'+currentId\"\n        [attr.data-bs-slide-to]=\"i\" aria-current=\"true\"\n      >\n      </button>\n    </div>\n  </ng-container>\n  <div class=\"carousel-inner\" [ngStyle]=\"{'display': multilist ? 'flex' : 'block'}\">\n    <ng-content></ng-content>\n  </div>\n  <a class=\"left carousel-control carousel-control-prev\"\n     *ngIf=\"slides.length > 1\"\n     [class.disabled]=\"checkDisabledClass('prev')\"\n     [attr.data-bs-target]=\"'#'+currentId\"\n     (click)=\"previousSlide()\"\n      tabindex=\"0\" role=\"button\">\n    <span class=\"icon-prev carousel-control-prev-icon\" aria-hidden=\"true\"></span>\n    <span *ngIf=\"isBs4\" class=\"sr-only visually-hidden\">Previous</span>\n  </a>\n  <a class=\"right carousel-control carousel-control-next\"\n     *ngIf=\"slides.length > 1\"\n     [class.disabled]=\"checkDisabledClass('next')\"\n     [attr.data-bs-target]=\"'#'+currentId\"\n     (click)=\"nextSlide()\"\n     tabindex=\"0\" role=\"button\">\n    <span class=\"icon-next carousel-control-next-icon\" aria-hidden=\"true\"></span>\n    <span class=\"sr-only visually-hidden\">Next</span>\n  </a>\n</div>\n", directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CarouselComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'carousel', template: "<div (mouseenter)=\"pause()\"\n     (mouseleave)=\"onMouseLeave()\"\n     (mouseup)=\"onMouseUp()\"\n     (keydown)=\"keydownPress($event)\"\n     (focusin)=\"pauseFocusIn()\"\n     (focusout)=\"pauseFocusOut()\"\n     [id]=\"currentId\"\n     class=\"carousel slide\" tabindex=\"0\">\n  <ng-container *ngIf=\"!_bsVer.isBs5 && showIndicators && slides.length > 1\">\n    <ol class=\"carousel-indicators\">\n      <li *ngFor=\"let slide of indicatorsSlides(); let i = index;\"\n          [class.active]=\"slide.active === true\"\n          (click)=\"selectSlide(i)\">\n      </li>\n    </ol>\n  </ng-container>\n  <ng-container *ngIf=\"_bsVer.isBs5 && showIndicators && slides.length > 1\">\n    <div class=\"carousel-indicators\">\n      <button\n        *ngFor=\"let slide of indicatorsSlides(); let i = index;\"\n        [class.active]=\"slide.active === true\"\n        (click)=\"selectSlide(i)\"\n        type=\"button\"\n        [attr.data-bs-target]=\"'#'+currentId\"\n        [attr.data-bs-slide-to]=\"i\" aria-current=\"true\"\n      >\n      </button>\n    </div>\n  </ng-container>\n  <div class=\"carousel-inner\" [ngStyle]=\"{'display': multilist ? 'flex' : 'block'}\">\n    <ng-content></ng-content>\n  </div>\n  <a class=\"left carousel-control carousel-control-prev\"\n     *ngIf=\"slides.length > 1\"\n     [class.disabled]=\"checkDisabledClass('prev')\"\n     [attr.data-bs-target]=\"'#'+currentId\"\n     (click)=\"previousSlide()\"\n      tabindex=\"0\" role=\"button\">\n    <span class=\"icon-prev carousel-control-prev-icon\" aria-hidden=\"true\"></span>\n    <span *ngIf=\"isBs4\" class=\"sr-only visually-hidden\">Previous</span>\n  </a>\n  <a class=\"right carousel-control carousel-control-next\"\n     *ngIf=\"slides.length > 1\"\n     [class.disabled]=\"checkDisabledClass('next')\"\n     [attr.data-bs-target]=\"'#'+currentId\"\n     (click)=\"nextSlide()\"\n     tabindex=\"0\" role=\"button\">\n    <span class=\"icon-next carousel-control-next-icon\" aria-hidden=\"true\"></span>\n    <span class=\"sr-only visually-hidden\">Next</span>\n  </a>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.CarouselConfig }, { type: i0.NgZone }]; }, propDecorators: { noWrap: [{
+                type: Input
+            }], noPause: [{
+                type: Input
+            }], showIndicators: [{
+                type: Input
+            }], pauseOnFocus: [{
+                type: Input
+            }], indicatorsByChunk: [{
+                type: Input
+            }], itemsPerSlide: [{
+                type: Input
+            }], singleSlideOffset: [{
+                type: Input
+            }], isAnimated: [{
+                type: Input
+            }], activeSlideChange: [{
+                type: Output
+            }], slideRangeChange: [{
+                type: Output
+            }], activeSlide: [{
+                type: Input
+            }], startFromIndex: [{
+                type: Input
+            }], interval: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"carousel.component.js","sourceRoot":"","sources":["../../../../src/carousel/carousel.component.ts","../../../../src/carousel/carousel.component.html"],"names":[],"mappings":"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","sourcesContent":["/***\n * pause (not yet supported) (?string='hover') - event group name which pauses\n * the cycling of the carousel, if hover pauses on mouseenter and resumes on\n * mouseleave keyboard (not yet supported) (?boolean=true) - if false\n * carousel will not react to keyboard events\n * note: swiping not yet supported\n */\n/****\n * Problems:\n * 1) if we set an active slide via model changes, .active class remains on a\n * current slide.\n * 2) if we have only one slide, we shouldn't show prev/next nav buttons\n * 3) if first or last slide is active and noWrap is true, there should be\n * \"disabled\" class on the nav buttons.\n * 4) default interval should be equal 5000\n */\n\nimport {\n  Component, EventEmitter, Input, NgZone, OnDestroy, Output, AfterViewInit\n} from '@angular/core';\n\nimport { isBs3, LinkedList, getBsVer, IBsVersion } from 'ngx-bootstrap/utils';\nimport { SlideComponent } from './slide.component';\nimport { CarouselConfig } from './carousel.config';\nimport { findLastIndex, chunkByNumber, isNumber } from './utils';\nimport { SlideWithIndex, IndexedSlideList } from './models';\n\nexport enum Direction {\n  UNKNOWN,\n  NEXT,\n  PREV\n}\n\nlet _currentId = 1;\n\n/**\n * Base element to create carousel\n */\n@Component({\n  selector: 'carousel',\n  templateUrl: './carousel.component.html'\n})\nexport class CarouselComponent implements AfterViewInit, OnDestroy {\n  /* If `true` — carousel will not cycle continuously and will have hard stops (prevent looping) */\n  @Input() noWrap = false;\n  /*  If `true` — will disable pausing on carousel mouse hover */\n  @Input() noPause = false;\n  /*  If `true` — carousel-indicators are visible  */\n  @Input() showIndicators = true;\n  /*  If `true` - autoplay will be stopped on focus */\n  @Input() pauseOnFocus = false;\n  /* If `true` - carousel indicators indicate slides chunks\n     works ONLY if singleSlideOffset = FALSE */\n  @Input() indicatorsByChunk = false;\n  /* If value more then 1 — carousel works in multilist mode */\n  @Input() itemsPerSlide = 1;\n  /* If `true` — carousel shifts by one element. By default carousel shifts by number\n     of visible elements (itemsPerSlide field) */\n  @Input() singleSlideOffset = false;\n  /** Turn on/off animation. Animation doesn't work for multilist carousel */\n  @Input() isAnimated = false;\n\n  /** Will be emitted when active slide has been changed. Part of two-way-bindable [(activeSlide)] property */\n  @Output()\n  activeSlideChange = new EventEmitter<number>(false);\n\n  /** Will be emitted when active slides has been changed in multilist mode */\n  @Output()\n  slideRangeChange = new EventEmitter<number[]|void>();\n\n  /** Index of currently displayed slide(started for 0) */\n  @Input()\n  set activeSlide(index: number) {\n    if (this.multilist) {\n      return;\n    }\n\n    if (isNumber(index)) {\n      this.customActiveSlide = index;\n    }\n\n    if (this._slides.length && index !== this._currentActiveSlide) {\n      this._select(index);\n    }\n  }\n\n  get activeSlide(): number {\n    return this._currentActiveSlide || 0;\n  }\n\n  /* Index to start display slides from it */\n  @Input()\n  startFromIndex = 0;\n\n  /**\n   * Delay of item cycling in milliseconds. If false, carousel won't cycle\n   * automatically.\n   */\n  @Input()\n  get interval(): number {\n    return this._interval;\n  }\n\n  set interval(value: number) {\n    this._interval = value;\n    this.restartTimer();\n  }\n\n  get slides(): SlideComponent[] {\n    return this._slides.toArray();\n  }\n\n  get isFirstSlideVisible(): boolean {\n    const indexes = this.getVisibleIndexes();\n    if (!indexes || (indexes instanceof Array && !indexes.length)) {\n      return false;\n    }\n\n    return indexes.includes(0);\n  }\n\n  get isLastSlideVisible(): boolean {\n    const indexes = this.getVisibleIndexes();\n    if (!indexes || (indexes instanceof Array && !indexes.length)) {\n      return false;\n    }\n\n    return indexes.includes(this._slides.length -1);\n  }\n\n  protected currentInterval?: number;\n  protected _currentActiveSlide?: number;\n  protected _interval = 5000;\n  protected _slides: LinkedList<SlideComponent> = new LinkedList<SlideComponent>();\n  protected _chunkedSlides?: SlideWithIndex[][];\n  protected _slidesWithIndexes?: SlideWithIndex[];\n  protected _currentVisibleSlidesIndex = 0;\n  protected isPlaying = false;\n  protected destroyed = false;\n  private customActiveSlide?: number;\n  currentId = 0;\n\n  get isBs4(): boolean {\n    return !isBs3();\n  }\n\n  get _bsVer(): IBsVersion {\n    return getBsVer();\n  }\n\n  constructor(config: CarouselConfig, private ngZone: NgZone) {\n    Object.assign(this, config);\n    this.currentId = _currentId++;\n  }\n\n  ngAfterViewInit(): void {\n    setTimeout(() => {\n      if (this.singleSlideOffset) {\n        this.indicatorsByChunk = false;\n      }\n      if (this.multilist) {\n        this._chunkedSlides = chunkByNumber(\n          this.mapSlidesAndIndexes(),\n          this.itemsPerSlide\n        );\n        this.selectInitialSlides();\n      }\n\n      if (this.customActiveSlide && !this.multilist) {\n        this._select(this.customActiveSlide);\n      }\n    }, 0);\n  }\n\n  ngOnDestroy(): void {\n    this.destroyed = true;\n  }\n\n  /**\n   * Adds new slide. If this slide is first in collection - set it as active\n   * and starts auto changing\n   * @param slide\n   */\n  addSlide(slide: SlideComponent): void {\n    this._slides.add(slide);\n\n    if (this.multilist && this._slides.length <= this.itemsPerSlide) {\n      slide.active = true;\n    }\n\n    if (!this.multilist && this.isAnimated) {\n      slide.isAnimated = true;\n    }\n\n    if (!this.multilist && this._slides.length === 1) {\n      this._currentActiveSlide = undefined;\n      if (!this.customActiveSlide) {\n        this.activeSlide = 0;\n      }\n      this.play();\n    }\n\n    if (this.multilist && this._slides.length > this.itemsPerSlide) {\n      this.play();\n    }\n  }\n\n  /**\n   * Removes specified slide. If this slide is active - will roll to another\n   * slide\n   * @param slide\n   */\n  removeSlide(slide: SlideComponent): void {\n    const remIndex = this._slides.indexOf(slide);\n\n    if (this._currentActiveSlide === remIndex) {\n      // removing of active slide\n      let nextSlideIndex: number;\n      if (this._slides.length > 1) {\n        // if this slide last - will roll to first slide, if noWrap flag is\n        // FALSE or to previous, if noWrap is TRUE in case, if this slide in\n        // middle of collection, index of next slide is same to removed\n        nextSlideIndex = !this.isLast(remIndex)\n          ? remIndex\n          : this.noWrap ? remIndex - 1 : 0;\n      }\n      this._slides.remove(remIndex);\n\n      // prevents exception with changing some value after checking\n      setTimeout(() => {\n        this._select(nextSlideIndex);\n      }, 0);\n    } else {\n      this._slides.remove(remIndex);\n      const currentSlideIndex = this.getCurrentSlideIndex();\n      setTimeout(() => {\n        // after removing, need to actualize index of current active slide\n        this._currentActiveSlide = currentSlideIndex;\n        this.activeSlideChange.emit(this._currentActiveSlide);\n      }, 0);\n    }\n  }\n\n  nextSlideFromInterval(force = false): void {\n    this.move(Direction.NEXT, force);\n  }\n\n  /**\n   * Rolling to next slide\n   * @param force: {boolean} if true - will ignore noWrap flag\n   */\n  nextSlide(force = false): void {\n    if (this.isPlaying) {\n      this.restartTimer();\n    }\n    this.move(Direction.NEXT, force);\n  }\n\n  /**\n   * Rolling to previous slide\n   * @param force: {boolean} if true - will ignore noWrap flag\n   */\n  previousSlide(force = false): void {\n    if (this.isPlaying) {\n      this.restartTimer();\n    }\n    this.move(Direction.PREV, force);\n  }\n\n  getFirstVisibleIndex(): number {\n    return this.slides.findIndex(this.getActive);\n  }\n\n  getLastVisibleIndex(): number {\n    return findLastIndex(this.slides, this.getActive);\n  }\n\n  getActive = (slide: SlideComponent) => slide.active;\n\n  move(direction: Direction, force = false): void {\n    const firstVisibleIndex = this.getFirstVisibleIndex();\n    const lastVisibleIndex = this.getLastVisibleIndex();\n\n    if (this.noWrap) {\n      if (\n        direction === Direction.NEXT &&\n        this.isLast(lastVisibleIndex) ||\n        direction === Direction.PREV &&\n        firstVisibleIndex === 0\n      ) {\n        return;\n      }\n    }\n\n    if (!this.multilist) {\n      this.activeSlide = this.findNextSlideIndex(direction, force) || 0;\n    } else {\n      this.moveMultilist(direction);\n    }\n  }\n\n  /**\n   * Swith slides by enter, space and arrows keys\n   * @internal\n   */\n  keydownPress(event: KeyboardEvent) {\n    if (event.keyCode === 13 || event.key === 'Enter' || event.keyCode === 32 || event.key === 'Space') {\n      this.nextSlide();\n      event.preventDefault();\n\n      return;\n    }\n\n    if (event.keyCode === 37 || event.key === 'LeftArrow') {\n      this.previousSlide();\n\n      return;\n    }\n\n    if (event.keyCode === 39 || event.key === 'RightArrow') {\n      this.nextSlide();\n\n      return;\n    }\n  }\n\n  /**\n   * Play on mouse leave\n   * @internal\n   */\n  onMouseLeave(): void {\n    if (!this.pauseOnFocus) {\n      this.play();\n    }\n  }\n\n  /**\n   * Play on mouse up\n   * @internal\n   */\n  onMouseUp(): void {\n    if (!this.pauseOnFocus) {\n      this.play();\n    }\n  }\n\n  /**\n   * When slides on focus autoplay is stopped(optional)\n   * @internal\n   */\n  pauseFocusIn(): void {\n    if (this.pauseOnFocus) {\n      this.isPlaying = false;\n      this.resetTimer();\n    }\n  }\n\n  /**\n   * When slides out of focus autoplay is started\n   * @internal\n   */\n  pauseFocusOut(): void {\n    this.play();\n  }\n\n  /**\n   * Rolling to specified slide\n   * @param index: {number} index of slide, which must be shown\n   */\n  selectSlide(index: number): void {\n    if (this.isPlaying) {\n      this.restartTimer();\n    }\n\n    if (!this.multilist) {\n      this.activeSlide = this.indicatorsByChunk ? index * this.itemsPerSlide : index;\n    } else {\n      this.selectSlideRange(this.indicatorsByChunk ? index * this.itemsPerSlide : index);\n    }\n  }\n\n  /**\n   * Starts a auto changing of slides\n   */\n  play(): void {\n    if (!this.isPlaying) {\n      this.isPlaying = true;\n      this.restartTimer();\n    }\n  }\n\n  /**\n   * Stops a auto changing of slides\n   */\n  pause(): void {\n    if (!this.noPause) {\n      this.isPlaying = false;\n      this.resetTimer();\n    }\n  }\n\n  /**\n   * Finds and returns index of currently displayed slide\n   */\n  getCurrentSlideIndex(): number {\n    return this._slides.findIndex(this.getActive);\n  }\n\n  /**\n   * Defines, whether the specified index is last in collection\n   * @param index\n   */\n  isLast(index: number): boolean {\n    return index + 1 >= this._slides.length;\n  }\n\n  /**\n   * Defines, whether the specified index is first in collection\n   * @param index\n   */\n  isFirst(index: number): boolean {\n    return index === 0;\n  }\n\n  indicatorsSlides(): SlideComponent[] {\n    return this.slides.filter(\n      (slide: SlideComponent, index: number) => !this.indicatorsByChunk || index % this.itemsPerSlide === 0\n    );\n  }\n\n  private selectInitialSlides(): void {\n    const startIndex = this.startFromIndex <= this._slides.length\n      ? this.startFromIndex\n      : 0;\n\n    this.hideSlides();\n\n    if (this.singleSlideOffset) {\n      this._slidesWithIndexes = this.mapSlidesAndIndexes();\n\n      if (this._slides.length - startIndex < this.itemsPerSlide) {\n        const slidesToAppend = this._slidesWithIndexes.slice(0, startIndex);\n\n        this._slidesWithIndexes = [\n          ...this._slidesWithIndexes,\n          ...slidesToAppend\n        ]\n          .slice(slidesToAppend.length)\n          .slice(0, this.itemsPerSlide);\n      } else {\n        this._slidesWithIndexes = this._slidesWithIndexes.slice(\n          startIndex,\n          startIndex + this.itemsPerSlide\n        );\n      }\n\n      this._slidesWithIndexes.forEach((slide: SlideWithIndex) => slide.item.active = true);\n      this.makeSlidesConsistent(this._slidesWithIndexes);\n    } else {\n      this.selectRangeByNestedIndex(startIndex);\n    }\n\n    this.slideRangeChange.emit(this.getVisibleIndexes());\n  }\n\n  /**\n   * Defines next slide index, depending of direction\n   * @param direction: Direction(UNKNOWN|PREV|NEXT)\n   * @param force: {boolean} if TRUE - will ignore noWrap flag, else will\n   *   return undefined if next slide require wrapping\n   */\n  private findNextSlideIndex(direction: Direction, force: boolean): number | void {\n    let nextSlideIndex = 0;\n\n    if (\n      !force &&\n      (this.isLast(this.activeSlide) &&\n        direction !== Direction.PREV &&\n        this.noWrap)\n    ) {\n      return;\n    }\n\n    switch (direction) {\n      case Direction.NEXT:\n        // if this is last slide, not force, looping is disabled\n        // and need to going forward - select current slide, as a next\n        if (typeof this._currentActiveSlide === 'undefined') {\n          nextSlideIndex = 0;\n          break;\n        }\n        if (!this.isLast(this._currentActiveSlide)) {\n          nextSlideIndex = this._currentActiveSlide + 1;\n          break;\n        }\n        nextSlideIndex = !force && this.noWrap ? this._currentActiveSlide : 0;\n        break;\n      case Direction.PREV:\n        // if this is first slide, not force, looping is disabled\n        // and need to going backward - select current slide, as a next\n        if (typeof this._currentActiveSlide === 'undefined') {\n          nextSlideIndex = 0;\n          break;\n        }\n        if (this._currentActiveSlide > 0) {\n          nextSlideIndex = this._currentActiveSlide - 1;\n          break;\n        }\n        if (!force && this.noWrap) {\n          nextSlideIndex = this._currentActiveSlide;\n          break;\n        }\n        nextSlideIndex = this._slides.length - 1;\n        break;\n      default:\n        throw new Error('Unknown direction');\n    }\n\n    return nextSlideIndex;\n  }\n\n  private mapSlidesAndIndexes(): SlideWithIndex[] {\n    return this.slides\n      .slice()\n      .map((slide: SlideComponent, index: number) => {\n        return {\n          index,\n          item: slide\n        };\n      });\n  }\n\n\n  private selectSlideRange(index: number): void {\n    if (this.isIndexInRange(index)) {\n      return;\n    }\n\n    this.hideSlides();\n\n    if (!this.singleSlideOffset) {\n      this.selectRangeByNestedIndex(index);\n    } else {\n      const startIndex = this.isIndexOnTheEdges(index)\n        ? index\n        : index - this.itemsPerSlide + 1;\n\n      const endIndex = this.isIndexOnTheEdges(index)\n        ? index + this.itemsPerSlide\n        : index + 1;\n\n      this._slidesWithIndexes = this.mapSlidesAndIndexes().slice(startIndex, endIndex);\n      this.makeSlidesConsistent(this._slidesWithIndexes);\n\n      this._slidesWithIndexes.forEach((slide: SlideWithIndex) => slide.item.active = true);\n    }\n\n    this.slideRangeChange.emit(this.getVisibleIndexes());\n  }\n\n  private selectRangeByNestedIndex(index: number): void {\n    if (!this._chunkedSlides) {\n      return;\n    }\n\n    const selectedRange = this._chunkedSlides\n      .map((slidesList, i: number) => {\n        return {\n          index: i,\n          list: slidesList\n        };\n      })\n      .find(\n        (slidesList: IndexedSlideList) => {\n          return slidesList.list.find(slide => slide.index === index) !== undefined;\n        }\n      );\n\n    if (!selectedRange) {\n      return;\n    }\n\n    this._currentVisibleSlidesIndex = selectedRange.index;\n\n    this._chunkedSlides[selectedRange.index].forEach((slide: SlideWithIndex) => {\n      slide.item.active = true;\n    });\n  }\n\n  private isIndexOnTheEdges(index: number): boolean {\n    return (\n      index + 1 - this.itemsPerSlide <= 0 ||\n      index + this.itemsPerSlide <= this._slides.length\n    );\n  }\n\n  private isIndexInRange(index: number): boolean {\n    if (this.singleSlideOffset && this._slidesWithIndexes) {\n      const visibleIndexes = this._slidesWithIndexes.map((slide: SlideWithIndex) => slide.index);\n\n      return visibleIndexes.indexOf(index) >= 0;\n    }\n\n    return (\n      index <= this.getLastVisibleIndex() &&\n      index >= this.getFirstVisibleIndex()\n    );\n  }\n\n  private hideSlides(): void {\n    this.slides.forEach((slide: SlideComponent) => slide.active = false);\n  }\n\n  private isVisibleSlideListLast(): boolean {\n    if (!this._chunkedSlides) {\n      return false;\n    }\n\n    return this._currentVisibleSlidesIndex === this._chunkedSlides.length - 1;\n  }\n\n  private isVisibleSlideListFirst(): boolean {\n    return this._currentVisibleSlidesIndex === 0;\n  }\n\n  private moveSliderByOneItem(direction: Direction): void {\n    let firstVisibleIndex: number;\n    let lastVisibleIndex: number;\n    let indexToHide: number;\n    let indexToShow: number;\n\n    if (this.noWrap) {\n      firstVisibleIndex = this.getFirstVisibleIndex();\n      lastVisibleIndex = this.getLastVisibleIndex();\n\n      indexToHide = direction === Direction.NEXT\n        ? firstVisibleIndex\n        : lastVisibleIndex;\n\n      indexToShow = direction !== Direction.NEXT\n        ? firstVisibleIndex - 1\n        : !this.isLast(lastVisibleIndex)\n          ? lastVisibleIndex + 1 : 0;\n\n      const slideToHide = this._slides.get(indexToHide);\n      if (slideToHide) {\n        slideToHide.active = false;\n      }\n\n      const slideToShow = this._slides.get(indexToShow);\n      if (slideToShow) {\n        slideToShow.active = true;\n      }\n\n      const slidesToReorder = this.mapSlidesAndIndexes().filter(\n        (slide: SlideWithIndex) => slide.item.active\n      );\n\n      this.makeSlidesConsistent(slidesToReorder);\n      if (this.singleSlideOffset) {\n        this._slidesWithIndexes = slidesToReorder;\n      }\n\n      this.slideRangeChange.emit(this.getVisibleIndexes());\n      return;\n    }\n\n    if (!this._slidesWithIndexes || !this._slidesWithIndexes[0]) {\n      return;\n    }\n\n    let index: number;\n\n    firstVisibleIndex = this._slidesWithIndexes[0].index;\n    lastVisibleIndex = this._slidesWithIndexes[this._slidesWithIndexes.length - 1].index;\n\n    if (direction === Direction.NEXT) {\n      this._slidesWithIndexes.shift();\n\n      index = this.isLast(lastVisibleIndex)\n        ? 0\n        : lastVisibleIndex + 1;\n\n      const item = this._slides.get(index);\n\n      if (item) {\n        this._slidesWithIndexes.push({ index, item });\n      }\n    } else {\n      this._slidesWithIndexes.pop();\n      index = this.isFirst(firstVisibleIndex)\n        ? this._slides.length - 1\n        : firstVisibleIndex - 1;\n\n      const item = this._slides.get(index);\n      if (item) {\n        this._slidesWithIndexes = [{ index, item }, ...this._slidesWithIndexes];\n      }\n    }\n\n    this.hideSlides();\n\n    this._slidesWithIndexes.forEach(slide => slide.item.active = true);\n    this.makeSlidesConsistent(this._slidesWithIndexes);\n\n    this.slideRangeChange.emit(\n      this._slidesWithIndexes.map((slide: SlideWithIndex) => slide.index)\n    );\n  }\n\n  private makeSlidesConsistent = (slides: SlideWithIndex[]): void => {\n    slides.forEach((slide: SlideWithIndex, index: number) => slide.item.order = index);\n  };\n\n  private moveMultilist(direction: Direction): void {\n    if (this.singleSlideOffset) {\n      this.moveSliderByOneItem(direction);\n    } else {\n      this.hideSlides();\n\n      if (this.noWrap) {\n        this._currentVisibleSlidesIndex = direction === Direction.NEXT\n          ? this._currentVisibleSlidesIndex + 1\n          : this._currentVisibleSlidesIndex - 1;\n      } else if (direction === Direction.NEXT) {\n        this._currentVisibleSlidesIndex = this.isVisibleSlideListLast()\n          ? 0\n          : this._currentVisibleSlidesIndex + 1;\n      } else {\n        if (this.isVisibleSlideListFirst()) {\n          this._currentVisibleSlidesIndex = this._chunkedSlides\n            ? this._chunkedSlides.length - 1\n            : 0;\n        } else {\n          this._currentVisibleSlidesIndex = this._currentVisibleSlidesIndex - 1;\n        }\n      }\n\n      if (this._chunkedSlides) {\n        this._chunkedSlides[this._currentVisibleSlidesIndex].forEach(\n          (slide: SlideWithIndex) => slide.item.active = true\n        );\n      }\n      this.slideRangeChange.emit(this.getVisibleIndexes());\n    }\n  }\n\n  private getVisibleIndexes(): number[] | void {\n    if (!this.singleSlideOffset && this._chunkedSlides) {\n      return this._chunkedSlides[this._currentVisibleSlidesIndex]\n        .map((slide: SlideWithIndex) => slide.index);\n    }\n\n    if (this._slidesWithIndexes) {\n      return this._slidesWithIndexes.map((slide: SlideWithIndex) => slide.index);\n    }\n  }\n\n  /**\n   * Sets a slide, which specified through index, as active\n   * @param index\n   */\n  private _select(index: number): void {\n    if (isNaN(index)) {\n      this.pause();\n\n      return;\n    }\n\n    if (!this.multilist && typeof this._currentActiveSlide !== 'undefined') {\n      const currentSlide = this._slides.get(this._currentActiveSlide);\n      if (typeof currentSlide !== 'undefined') {\n        currentSlide.active = false;\n      }\n    }\n\n    const nextSlide = this._slides.get(index);\n\n    if (typeof nextSlide !== 'undefined') {\n      this._currentActiveSlide = index;\n      nextSlide.active = true;\n      this.activeSlide = index;\n      this.activeSlideChange.emit(index);\n    }\n  }\n\n  /**\n   * Starts loop of auto changing of slides\n   */\n  private restartTimer() {\n    this.resetTimer();\n    const interval = +this.interval;\n    if (!isNaN(interval) && interval > 0) {\n      this.currentInterval = this.ngZone.runOutsideAngular<number>(() => {\n        return window.setInterval(() => {\n          const nInterval = +this.interval;\n          this.ngZone.run(() => {\n            if (\n              this.isPlaying &&\n              !isNaN(this.interval) &&\n              nInterval > 0 &&\n              this.slides.length\n            ) {\n              this.nextSlideFromInterval();\n            } else {\n              this.pause();\n            }\n          });\n        }, interval);\n      });\n    }\n  }\n\n  get multilist(): boolean {\n    return this.itemsPerSlide > 1;\n  }\n\n  /**\n   * Stops loop of auto changing of slides\n   */\n  private resetTimer(): void {\n    if (this.currentInterval) {\n      clearInterval(this.currentInterval);\n      this.currentInterval = void 0;\n    }\n  }\n\n  checkDisabledClass(buttonType: 'prev' | 'next'): boolean {\n    if (buttonType === 'prev') {\n      return (this.activeSlide === 0 && this.noWrap && !this.multilist) || (this.isFirstSlideVisible && this.noWrap && this.multilist);\n    }\n\n    return (this.isLast(this.activeSlide) && this.noWrap && !this.multilist) || (this.isLastSlideVisible && this.noWrap && this.multilist);\n  }\n}\n","<div (mouseenter)=\"pause()\"\n     (mouseleave)=\"onMouseLeave()\"\n     (mouseup)=\"onMouseUp()\"\n     (keydown)=\"keydownPress($event)\"\n     (focusin)=\"pauseFocusIn()\"\n     (focusout)=\"pauseFocusOut()\"\n     [id]=\"currentId\"\n     class=\"carousel slide\" tabindex=\"0\">\n  <ng-container *ngIf=\"!_bsVer.isBs5 && showIndicators && slides.length > 1\">\n    <ol class=\"carousel-indicators\">\n      <li *ngFor=\"let slide of indicatorsSlides(); let i = index;\"\n          [class.active]=\"slide.active === true\"\n          (click)=\"selectSlide(i)\">\n      </li>\n    </ol>\n  </ng-container>\n  <ng-container *ngIf=\"_bsVer.isBs5 && showIndicators && slides.length > 1\">\n    <div class=\"carousel-indicators\">\n      <button\n        *ngFor=\"let slide of indicatorsSlides(); let i = index;\"\n        [class.active]=\"slide.active === true\"\n        (click)=\"selectSlide(i)\"\n        type=\"button\"\n        [attr.data-bs-target]=\"'#'+currentId\"\n        [attr.data-bs-slide-to]=\"i\" aria-current=\"true\"\n      >\n      </button>\n    </div>\n  </ng-container>\n  <div class=\"carousel-inner\" [ngStyle]=\"{'display': multilist ? 'flex' : 'block'}\">\n    <ng-content></ng-content>\n  </div>\n  <a class=\"left carousel-control carousel-control-prev\"\n     *ngIf=\"slides.length > 1\"\n     [class.disabled]=\"checkDisabledClass('prev')\"\n     [attr.data-bs-target]=\"'#'+currentId\"\n     (click)=\"previousSlide()\"\n      tabindex=\"0\" role=\"button\">\n    <span class=\"icon-prev carousel-control-prev-icon\" aria-hidden=\"true\"></span>\n    <span *ngIf=\"isBs4\" class=\"sr-only visually-hidden\">Previous</span>\n  </a>\n  <a class=\"right carousel-control carousel-control-next\"\n     *ngIf=\"slides.length > 1\"\n     [class.disabled]=\"checkDisabledClass('next')\"\n     [attr.data-bs-target]=\"'#'+currentId\"\n     (click)=\"nextSlide()\"\n     tabindex=\"0\" role=\"button\">\n    <span class=\"icon-next carousel-control-next-icon\" aria-hidden=\"true\"></span>\n    <span class=\"sr-only visually-hidden\">Next</span>\n  </a>\n</div>\n"]}