VLEX/BPM-UI/node_modules/@ng-bootstrap/ng-bootstrap/esm2015/carousel/carousel.js

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChildren, Directive, EventEmitter, HostListener, Inject, Input, NgZone, Output, PLATFORM_ID, QueryList, TemplateRef, ViewEncapsulation } from '@angular/core';
import { isPlatformBrowser } from '@angular/common';
import { NgbCarouselConfig } from './carousel-config';
import { BehaviorSubject, combineLatest, NEVER, Subject, timer } from 'rxjs';
import { distinctUntilChanged, map, startWith, switchMap, takeUntil } from 'rxjs/operators';
/** @type {?} */
let nextId = 0;
/**
 * A directive that wraps the individual carousel slide.
 */
export class NgbSlide {
    /**
     * @param {?} tplRef
     */
    constructor(tplRef) {
        this.tplRef = tplRef;
        /**
         * Slide id that must be unique for the entire document.
         *
         * If not provided, will be generated in the `ngb-slide-xx` format.
         */
        this.id = `ngb-slide-${nextId++}`;
    }
}
NgbSlide.decorators = [
    { type: Directive, args: [{ selector: 'ng-template[ngbSlide]' },] }
];
/** @nocollapse */
NgbSlide.ctorParameters = () => [
    { type: TemplateRef }
];
NgbSlide.propDecorators = {
    id: [{ type: Input }]
};
if (false) {
    /**
     * Slide id that must be unique for the entire document.
     *
     * If not provided, will be generated in the `ngb-slide-xx` format.
     * @type {?}
     */
    NgbSlide.prototype.id;
    /** @type {?} */
    NgbSlide.prototype.tplRef;
}
/**
 * Carousel is a component to easily create and control slideshows.
 *
 * Allows to set intervals, change the way user interacts with the slides and provides a programmatic API.
 */
export class NgbCarousel {
    /**
     * @param {?} config
     * @param {?} _platformId
     * @param {?} _ngZone
     * @param {?} _cd
     */
    constructor(config, _platformId, _ngZone, _cd) {
        this._platformId = _platformId;
        this._ngZone = _ngZone;
        this._cd = _cd;
        this.NgbSlideEventSource = NgbSlideEventSource;
        this._destroy$ = new Subject();
        this._interval$ = new BehaviorSubject(0);
        this._mouseHover$ = new BehaviorSubject(false);
        this._pauseOnHover$ = new BehaviorSubject(false);
        this._pause$ = new BehaviorSubject(false);
        this._wrap$ = new BehaviorSubject(false);
        /**
         * An event emitted right after the slide transition is completed.
         *
         * See [`NgbSlideEvent`](#/components/carousel/api#NgbSlideEvent) for payload details.
         */
        this.slide = new EventEmitter();
        this.interval = config.interval;
        this.wrap = config.wrap;
        this.keyboard = config.keyboard;
        this.pauseOnHover = config.pauseOnHover;
        this.showNavigationArrows = config.showNavigationArrows;
        this.showNavigationIndicators = config.showNavigationIndicators;
    }
    /**
     * Time in milliseconds before the next slide is shown.
     * @param {?} value
     * @return {?}
     */
    set interval(value) {
        this._interval$.next(value);
    }
    /**
     * @return {?}
     */
    get interval() { return this._interval$.value; }
    /**
     * If `true`, will 'wrap' the carousel by switching from the last slide back to the first.
     * @param {?} value
     * @return {?}
     */
    set wrap(value) {
        this._wrap$.next(value);
    }
    /**
     * @return {?}
     */
    get wrap() { return this._wrap$.value; }
    /**
     * If `true`, will pause slide switching when mouse cursor hovers the slide.
     *
     * \@since 2.2.0
     * @param {?} value
     * @return {?}
     */
    set pauseOnHover(value) {
        this._pauseOnHover$.next(value);
    }
    /**
     * @return {?}
     */
    get pauseOnHover() { return this._pauseOnHover$.value; }
    /**
     * @return {?}
     */
    mouseEnter() {
        this._mouseHover$.next(true);
    }
    /**
     * @return {?}
     */
    mouseLeave() {
        this._mouseHover$.next(false);
    }
    /**
     * @return {?}
     */
    ngAfterContentInit() {
        // setInterval() doesn't play well with SSR and protractor,
        // so we should run it in the browser and outside Angular
        if (isPlatformBrowser(this._platformId)) {
            this._ngZone.runOutsideAngular((/**
             * @return {?}
             */
            () => {
                /** @type {?} */
                const hasNextSlide$ = combineLatest(this.slide.pipe(map((/**
                 * @param {?} slideEvent
                 * @return {?}
                 */
                slideEvent => slideEvent.current)), startWith(this.activeId)), this._wrap$, this.slides.changes.pipe(startWith(null)))
                    .pipe(map((/**
                 * @param {?} __0
                 * @return {?}
                 */
                ([currentSlideId, wrap]) => {
                    /** @type {?} */
                    const slideArr = this.slides.toArray();
                    /** @type {?} */
                    const currentSlideIdx = this._getSlideIdxById(currentSlideId);
                    return wrap ? slideArr.length > 1 : currentSlideIdx < slideArr.length - 1;
                })), distinctUntilChanged());
                combineLatest(this._pause$, this._pauseOnHover$, this._mouseHover$, this._interval$, hasNextSlide$)
                    .pipe(map((/**
                 * @param {?} __0
                 * @return {?}
                 */
                ([pause, pauseOnHover, mouseHover, interval, hasNextSlide]) => ((pause || (pauseOnHover && mouseHover) || !hasNextSlide) ? 0 : interval))), distinctUntilChanged(), switchMap((/**
                 * @param {?} interval
                 * @return {?}
                 */
                interval => interval > 0 ? timer(interval, interval) : NEVER)), takeUntil(this._destroy$))
                    .subscribe((/**
                 * @return {?}
                 */
                () => this._ngZone.run((/**
                 * @return {?}
                 */
                () => this.next(NgbSlideEventSource.TIMER)))));
            }));
        }
        this.slides.changes.pipe(takeUntil(this._destroy$)).subscribe((/**
         * @return {?}
         */
        () => this._cd.markForCheck()));
    }
    /**
     * @return {?}
     */
    ngAfterContentChecked() {
        /** @type {?} */
        let activeSlide = this._getSlideById(this.activeId);
        this.activeId = activeSlide ? activeSlide.id : (this.slides.length ? this.slides.first.id : null);
    }
    /**
     * @return {?}
     */
    ngOnDestroy() { this._destroy$.next(); }
    /**
     * Navigates to a slide with the specified identifier.
     * @param {?} slideId
     * @param {?=} source
     * @return {?}
     */
    select(slideId, source) {
        this._cycleToSelected(slideId, this._getSlideEventDirection(this.activeId, slideId), source);
    }
    /**
     * Navigates to the previous slide.
     * @param {?=} source
     * @return {?}
     */
    prev(source) {
        this._cycleToSelected(this._getPrevSlide(this.activeId), NgbSlideEventDirection.RIGHT, source);
    }
    /**
     * Navigates to the next slide.
     * @param {?=} source
     * @return {?}
     */
    next(source) {
        this._cycleToSelected(this._getNextSlide(this.activeId), NgbSlideEventDirection.LEFT, source);
    }
    /**
     * Pauses cycling through the slides.
     * @return {?}
     */
    pause() { this._pause$.next(true); }
    /**
     * Restarts cycling through the slides from left to right.
     * @return {?}
     */
    cycle() { this._pause$.next(false); }
    /**
     * @private
     * @param {?} slideIdx
     * @param {?} direction
     * @param {?=} source
     * @return {?}
     */
    _cycleToSelected(slideIdx, direction, source) {
        /** @type {?} */
        let selectedSlide = this._getSlideById(slideIdx);
        if (selectedSlide && selectedSlide.id !== this.activeId) {
            this.slide.emit({ prev: this.activeId, current: selectedSlide.id, direction: direction, paused: this._pause$.value, source });
            this.activeId = selectedSlide.id;
        }
        // we get here after the interval fires or any external API call like next(), prev() or select()
        this._cd.markForCheck();
    }
    /**
     * @private
     * @param {?} currentActiveSlideId
     * @param {?} nextActiveSlideId
     * @return {?}
     */
    _getSlideEventDirection(currentActiveSlideId, nextActiveSlideId) {
        /** @type {?} */
        const currentActiveSlideIdx = this._getSlideIdxById(currentActiveSlideId);
        /** @type {?} */
        const nextActiveSlideIdx = this._getSlideIdxById(nextActiveSlideId);
        return currentActiveSlideIdx > nextActiveSlideIdx ? NgbSlideEventDirection.RIGHT : NgbSlideEventDirection.LEFT;
    }
    /**
     * @private
     * @param {?} slideId
     * @return {?}
     */
    _getSlideById(slideId) { return this.slides.find((/**
     * @param {?} slide
     * @return {?}
     */
    slide => slide.id === slideId)); }
    /**
     * @private
     * @param {?} slideId
     * @return {?}
     */
    _getSlideIdxById(slideId) {
        return this.slides.toArray().indexOf(this._getSlideById(slideId));
    }
    /**
     * @private
     * @param {?} currentSlideId
     * @return {?}
     */
    _getNextSlide(currentSlideId) {
        /** @type {?} */
        const slideArr = this.slides.toArray();
        /** @type {?} */
        const currentSlideIdx = this._getSlideIdxById(currentSlideId);
        /** @type {?} */
        const isLastSlide = currentSlideIdx === slideArr.length - 1;
        return isLastSlide ? (this.wrap ? slideArr[0].id : slideArr[slideArr.length - 1].id) :
            slideArr[currentSlideIdx + 1].id;
    }
    /**
     * @private
     * @param {?} currentSlideId
     * @return {?}
     */
    _getPrevSlide(currentSlideId) {
        /** @type {?} */
        const slideArr = this.slides.toArray();
        /** @type {?} */
        const currentSlideIdx = this._getSlideIdxById(currentSlideId);
        /** @type {?} */
        const isFirstSlide = currentSlideIdx === 0;
        return isFirstSlide ? (this.wrap ? slideArr[slideArr.length - 1].id : slideArr[0].id) :
            slideArr[currentSlideIdx - 1].id;
    }
}
NgbCarousel.decorators = [
    { type: Component, args: [{
                selector: 'ngb-carousel',
                exportAs: 'ngbCarousel',
                changeDetection: ChangeDetectionStrategy.OnPush,
                encapsulation: ViewEncapsulation.None,
                host: {
                    'class': 'carousel slide',
                    '[style.display]': '"block"',
                    'tabIndex': '0',
                    '(keydown.arrowLeft)': 'keyboard && prev(NgbSlideEventSource.ARROW_LEFT)',
                    '(keydown.arrowRight)': 'keyboard && next(NgbSlideEventSource.ARROW_RIGHT)'
                },
                template: `
    <ol class="carousel-indicators" *ngIf="showNavigationIndicators">
      <li *ngFor="let slide of slides" [id]="slide.id" [class.active]="slide.id === activeId"
          (click)="select(slide.id, NgbSlideEventSource.INDICATOR)"></li>
    </ol>
    <div class="carousel-inner">
      <div *ngFor="let slide of slides" class="carousel-item" [class.active]="slide.id === activeId">
        <ng-template [ngTemplateOutlet]="slide.tplRef"></ng-template>
      </div>
    </div>
    <a class="carousel-control-prev" role="button" (click)="prev(NgbSlideEventSource.ARROW_LEFT)" *ngIf="showNavigationArrows">
      <span class="carousel-control-prev-icon" aria-hidden="true"></span>
      <span class="sr-only" i18n="@@ngb.carousel.previous">Previous</span>
    </a>
    <a class="carousel-control-next" role="button" (click)="next(NgbSlideEventSource.ARROW_RIGHT)" *ngIf="showNavigationArrows">
      <span class="carousel-control-next-icon" aria-hidden="true"></span>
      <span class="sr-only" i18n="@@ngb.carousel.next">Next</span>
    </a>
  `
            }] }
];
/** @nocollapse */
NgbCarousel.ctorParameters = () => [
    { type: NgbCarouselConfig },
    { type: undefined, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] },
    { type: NgZone },
    { type: ChangeDetectorRef }
];
NgbCarousel.propDecorators = {
    slides: [{ type: ContentChildren, args: [NgbSlide,] }],
    activeId: [{ type: Input }],
    interval: [{ type: Input }],
    wrap: [{ type: Input }],
    keyboard: [{ type: Input }],
    pauseOnHover: [{ type: Input }],
    showNavigationArrows: [{ type: Input }],
    showNavigationIndicators: [{ type: Input }],
    slide: [{ type: Output }],
    mouseEnter: [{ type: HostListener, args: ['mouseenter',] }],
    mouseLeave: [{ type: HostListener, args: ['mouseleave',] }]
};
if (false) {
    /** @type {?} */
    NgbCarousel.prototype.slides;
    /** @type {?} */
    NgbCarousel.prototype.NgbSlideEventSource;
    /**
     * @type {?}
     * @private
     */
    NgbCarousel.prototype._destroy$;
    /**
     * @type {?}
     * @private
     */
    NgbCarousel.prototype._interval$;
    /**
     * @type {?}
     * @private
     */
    NgbCarousel.prototype._mouseHover$;
    /**
     * @type {?}
     * @private
     */
    NgbCarousel.prototype._pauseOnHover$;
    /**
     * @type {?}
     * @private
     */
    NgbCarousel.prototype._pause$;
    /**
     * @type {?}
     * @private
     */
    NgbCarousel.prototype._wrap$;
    /**
     * The slide id that should be displayed **initially**.
     *
     * For subsequent interactions use methods `select()`, `next()`, etc. and the `(slide)` output.
     * @type {?}
     */
    NgbCarousel.prototype.activeId;
    /**
     * If `true`, allows to interact with carousel using keyboard 'arrow left' and 'arrow right'.
     * @type {?}
     */
    NgbCarousel.prototype.keyboard;
    /**
     * If `true`, 'previous' and 'next' navigation arrows will be visible on the slide.
     *
     * \@since 2.2.0
     * @type {?}
     */
    NgbCarousel.prototype.showNavigationArrows;
    /**
     * If `true`, navigation indicators at the bottom of the slide will be visible.
     *
     * \@since 2.2.0
     * @type {?}
     */
    NgbCarousel.prototype.showNavigationIndicators;
    /**
     * An event emitted right after the slide transition is completed.
     *
     * See [`NgbSlideEvent`](#/components/carousel/api#NgbSlideEvent) for payload details.
     * @type {?}
     */
    NgbCarousel.prototype.slide;
    /**
     * @type {?}
     * @private
     */
    NgbCarousel.prototype._platformId;
    /**
     * @type {?}
     * @private
     */
    NgbCarousel.prototype._ngZone;
    /**
     * @type {?}
     * @private
     */
    NgbCarousel.prototype._cd;
}
/**
 * A slide change event emitted right after the slide transition is completed.
 * @record
 */
export function NgbSlideEvent() { }
if (false) {
    /**
     * The previous slide id.
     * @type {?}
     */
    NgbSlideEvent.prototype.prev;
    /**
     * The current slide id.
     * @type {?}
     */
    NgbSlideEvent.prototype.current;
    /**
     * The slide event direction.
     *
     * Possible values are `'left' | 'right'`.
     * @type {?}
     */
    NgbSlideEvent.prototype.direction;
    /**
     * Whether the pause() method was called (and no cycle() call was done afterwards).
     *
     * \@since 5.1.0
     * @type {?}
     */
    NgbSlideEvent.prototype.paused;
    /**
     * Source triggering the slide change event.
     *
     * Possible values are `'timer' | 'arrowLeft' | 'arrowRight' | 'indicator'`
     *
     * \@since 5.1.0
     * @type {?|undefined}
     */
    NgbSlideEvent.prototype.source;
}
/** @enum {string} */
const NgbSlideEventDirection = {
    LEFT: (/** @type {?} */ ('left')),
    RIGHT: (/** @type {?} */ ('right')),
};
export { NgbSlideEventDirection };
/** @enum {string} */
const NgbSlideEventSource = {
    TIMER: 'timer',
    ARROW_LEFT: 'arrowLeft',
    ARROW_RIGHT: 'arrowRight',
    INDICATOR: 'indicator',
};
export { NgbSlideEventSource };
/** @type {?} */
export const NGB_CAROUSEL_DIRECTIVES = [NgbCarousel, NgbSlide];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"carousel.js","sourceRoot":"ng://@ng-bootstrap/ng-bootstrap/","sources":["carousel/carousel.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentChecked,\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChildren,\n  Directive,\n  EventEmitter,\n  HostListener,\n  Inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  Output,\n  PLATFORM_ID,\n  QueryList,\n  TemplateRef,\n  ViewEncapsulation\n} from '@angular/core';\nimport {isPlatformBrowser} from '@angular/common';\n\nimport {NgbCarouselConfig} from './carousel-config';\n\nimport {BehaviorSubject, combineLatest, NEVER, Subject, timer} from 'rxjs';\nimport {distinctUntilChanged, map, startWith, switchMap, takeUntil} from 'rxjs/operators';\n\nlet nextId = 0;\n\n/**\n * A directive that wraps the individual carousel slide.\n */\n@Directive({selector: 'ng-template[ngbSlide]'})\nexport class NgbSlide {\n  /**\n   * Slide id that must be unique for the entire document.\n   *\n   * If not provided, will be generated in the `ngb-slide-xx` format.\n   */\n  @Input() id = `ngb-slide-${nextId++}`;\n  constructor(public tplRef: TemplateRef<any>) {}\n}\n\n/**\n * Carousel is a component to easily create and control slideshows.\n *\n * Allows to set intervals, change the way user interacts with the slides and provides a programmatic API.\n */\n@Component({\n  selector: 'ngb-carousel',\n  exportAs: 'ngbCarousel',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  host: {\n    'class': 'carousel slide',\n    '[style.display]': '\"block\"',\n    'tabIndex': '0',\n    '(keydown.arrowLeft)': 'keyboard && prev(NgbSlideEventSource.ARROW_LEFT)',\n    '(keydown.arrowRight)': 'keyboard && next(NgbSlideEventSource.ARROW_RIGHT)'\n  },\n  template: `\n    <ol class=\"carousel-indicators\" *ngIf=\"showNavigationIndicators\">\n      <li *ngFor=\"let slide of slides\" [id]=\"slide.id\" [class.active]=\"slide.id === activeId\"\n          (click)=\"select(slide.id, NgbSlideEventSource.INDICATOR)\"></li>\n    </ol>\n    <div class=\"carousel-inner\">\n      <div *ngFor=\"let slide of slides\" class=\"carousel-item\" [class.active]=\"slide.id === activeId\">\n        <ng-template [ngTemplateOutlet]=\"slide.tplRef\"></ng-template>\n      </div>\n    </div>\n    <a class=\"carousel-control-prev\" role=\"button\" (click)=\"prev(NgbSlideEventSource.ARROW_LEFT)\" *ngIf=\"showNavigationArrows\">\n      <span class=\"carousel-control-prev-icon\" aria-hidden=\"true\"></span>\n      <span class=\"sr-only\" i18n=\"@@ngb.carousel.previous\">Previous</span>\n    </a>\n    <a class=\"carousel-control-next\" role=\"button\" (click)=\"next(NgbSlideEventSource.ARROW_RIGHT)\" *ngIf=\"showNavigationArrows\">\n      <span class=\"carousel-control-next-icon\" aria-hidden=\"true\"></span>\n      <span class=\"sr-only\" i18n=\"@@ngb.carousel.next\">Next</span>\n    </a>\n  `\n})\nexport class NgbCarousel implements AfterContentChecked,\n    AfterContentInit, OnDestroy {\n  @ContentChildren(NgbSlide) slides: QueryList<NgbSlide>;\n\n  public NgbSlideEventSource = NgbSlideEventSource;\n\n  private _destroy$ = new Subject<void>();\n  private _interval$ = new BehaviorSubject(0);\n  private _mouseHover$ = new BehaviorSubject(false);\n  private _pauseOnHover$ = new BehaviorSubject(false);\n  private _pause$ = new BehaviorSubject(false);\n  private _wrap$ = new BehaviorSubject(false);\n\n  /**\n   * The slide id that should be displayed **initially**.\n   *\n   * For subsequent interactions use methods `select()`, `next()`, etc. and the `(slide)` output.\n   */\n  @Input() activeId: string;\n\n  /**\n   * Time in milliseconds before the next slide is shown.\n   */\n  @Input()\n  set interval(value: number) {\n    this._interval$.next(value);\n  }\n\n  get interval() { return this._interval$.value; }\n\n  /**\n   * If `true`, will 'wrap' the carousel by switching from the last slide back to the first.\n   */\n  @Input()\n  set wrap(value: boolean) {\n    this._wrap$.next(value);\n  }\n\n  get wrap() { return this._wrap$.value; }\n\n  /**\n   * If `true`, allows to interact with carousel using keyboard 'arrow left' and 'arrow right'.\n   */\n  @Input() keyboard: boolean;\n\n  /**\n   * If `true`, will pause slide switching when mouse cursor hovers the slide.\n   *\n   * @since 2.2.0\n   */\n  @Input()\n  set pauseOnHover(value: boolean) {\n    this._pauseOnHover$.next(value);\n  }\n\n  get pauseOnHover() { return this._pauseOnHover$.value; }\n\n  /**\n   * If `true`, 'previous' and 'next' navigation arrows will be visible on the slide.\n   *\n   * @since 2.2.0\n   */\n  @Input() showNavigationArrows: boolean;\n\n  /**\n   * If `true`, navigation indicators at the bottom of the slide will be visible.\n   *\n   * @since 2.2.0\n   */\n  @Input() showNavigationIndicators: boolean;\n\n  /**\n   * An event emitted right after the slide transition is completed.\n   *\n   * See [`NgbSlideEvent`](#/components/carousel/api#NgbSlideEvent) for payload details.\n   */\n  @Output() slide = new EventEmitter<NgbSlideEvent>();\n\n  constructor(\n      config: NgbCarouselConfig, @Inject(PLATFORM_ID) private _platformId, private _ngZone: NgZone,\n      private _cd: ChangeDetectorRef) {\n    this.interval = config.interval;\n    this.wrap = config.wrap;\n    this.keyboard = config.keyboard;\n    this.pauseOnHover = config.pauseOnHover;\n    this.showNavigationArrows = config.showNavigationArrows;\n    this.showNavigationIndicators = config.showNavigationIndicators;\n  }\n\n  @HostListener('mouseenter')\n  mouseEnter() {\n    this._mouseHover$.next(true);\n  }\n\n  @HostListener('mouseleave')\n  mouseLeave() {\n    this._mouseHover$.next(false);\n  }\n\n  ngAfterContentInit() {\n    // setInterval() doesn't play well with SSR and protractor,\n    // so we should run it in the browser and outside Angular\n    if (isPlatformBrowser(this._platformId)) {\n      this._ngZone.runOutsideAngular(() => {\n        const hasNextSlide$ = combineLatest(\n                                  this.slide.pipe(map(slideEvent => slideEvent.current), startWith(this.activeId)),\n                                  this._wrap$, this.slides.changes.pipe(startWith(null)))\n                                  .pipe(\n                                      map(([currentSlideId, wrap]) => {\n                                        const slideArr = this.slides.toArray();\n                                        const currentSlideIdx = this._getSlideIdxById(currentSlideId);\n                                        return wrap ? slideArr.length > 1 : currentSlideIdx < slideArr.length - 1;\n                                      }),\n                                      distinctUntilChanged());\n        combineLatest(this._pause$, this._pauseOnHover$, this._mouseHover$, this._interval$, hasNextSlide$)\n            .pipe(\n                map(([pause, pauseOnHover, mouseHover, interval, hasNextSlide]) =>\n                        ((pause || (pauseOnHover && mouseHover) || !hasNextSlide) ? 0 : interval)),\n\n                distinctUntilChanged(), switchMap(interval => interval > 0 ? timer(interval, interval) : NEVER),\n                takeUntil(this._destroy$))\n            .subscribe(() => this._ngZone.run(() => this.next(NgbSlideEventSource.TIMER)));\n      });\n    }\n\n    this.slides.changes.pipe(takeUntil(this._destroy$)).subscribe(() => this._cd.markForCheck());\n  }\n\n  ngAfterContentChecked() {\n    let activeSlide = this._getSlideById(this.activeId);\n    this.activeId = activeSlide ? activeSlide.id : (this.slides.length ? this.slides.first.id : null);\n  }\n\n  ngOnDestroy() { this._destroy$.next(); }\n\n  /**\n   * Navigates to a slide with the specified identifier.\n   */\n  select(slideId: string, source?: NgbSlideEventSource) {\n    this._cycleToSelected(slideId, this._getSlideEventDirection(this.activeId, slideId), source);\n  }\n\n  /**\n   * Navigates to the previous slide.\n   */\n  prev(source?: NgbSlideEventSource) {\n    this._cycleToSelected(this._getPrevSlide(this.activeId), NgbSlideEventDirection.RIGHT, source);\n  }\n\n  /**\n   * Navigates to the next slide.\n   */\n  next(source?: NgbSlideEventSource) {\n    this._cycleToSelected(this._getNextSlide(this.activeId), NgbSlideEventDirection.LEFT, source);\n  }\n\n  /**\n   * Pauses cycling through the slides.\n   */\n  pause() { this._pause$.next(true); }\n\n  /**\n   * Restarts cycling through the slides from left to right.\n   */\n  cycle() { this._pause$.next(false); }\n\n  private _cycleToSelected(slideIdx: string, direction: NgbSlideEventDirection, source?: NgbSlideEventSource) {\n    let selectedSlide = this._getSlideById(slideIdx);\n    if (selectedSlide && selectedSlide.id !== this.activeId) {\n      this.slide.emit(\n          {prev: this.activeId, current: selectedSlide.id, direction: direction, paused: this._pause$.value, source});\n      this.activeId = selectedSlide.id;\n    }\n\n    // we get here after the interval fires or any external API call like next(), prev() or select()\n    this._cd.markForCheck();\n  }\n\n  private _getSlideEventDirection(currentActiveSlideId: string, nextActiveSlideId: string): NgbSlideEventDirection {\n    const currentActiveSlideIdx = this._getSlideIdxById(currentActiveSlideId);\n    const nextActiveSlideIdx = this._getSlideIdxById(nextActiveSlideId);\n\n    return currentActiveSlideIdx > nextActiveSlideIdx ? NgbSlideEventDirection.RIGHT : NgbSlideEventDirection.LEFT;\n  }\n\n  private _getSlideById(slideId: string): NgbSlide { return this.slides.find(slide => slide.id === slideId); }\n\n  private _getSlideIdxById(slideId: string): number {\n    return this.slides.toArray().indexOf(this._getSlideById(slideId));\n  }\n\n  private _getNextSlide(currentSlideId: string): string {\n    const slideArr = this.slides.toArray();\n    const currentSlideIdx = this._getSlideIdxById(currentSlideId);\n    const isLastSlide = currentSlideIdx === slideArr.length - 1;\n\n    return isLastSlide ? (this.wrap ? slideArr[0].id : slideArr[slideArr.length - 1].id) :\n                         slideArr[currentSlideIdx + 1].id;\n  }\n\n  private _getPrevSlide(currentSlideId: string): string {\n    const slideArr = this.slides.toArray();\n    const currentSlideIdx = this._getSlideIdxById(currentSlideId);\n    const isFirstSlide = currentSlideIdx === 0;\n\n    return isFirstSlide ? (this.wrap ? slideArr[slideArr.length - 1].id : slideArr[0].id) :\n                          slideArr[currentSlideIdx - 1].id;\n  }\n}\n\n/**\n * A slide change event emitted right after the slide transition is completed.\n */\nexport interface NgbSlideEvent {\n  /**\n   * The previous slide id.\n   */\n  prev: string;\n\n  /**\n   * The current slide id.\n   */\n  current: string;\n\n  /**\n   * The slide event direction.\n   *\n   * Possible values are `'left' | 'right'`.\n   */\n  direction: NgbSlideEventDirection;\n\n  /**\n   * Whether the pause() method was called (and no cycle() call was done afterwards).\n   *\n   * @since 5.1.0\n   */\n  paused: boolean;\n\n  /**\n   * Source triggering the slide change event.\n   *\n   * Possible values are `'timer' | 'arrowLeft' | 'arrowRight' | 'indicator'`\n   *\n   * @since 5.1.0\n   */\n  source?: NgbSlideEventSource;\n}\n\n/**\n * Defines the carousel slide transition direction.\n */\nexport enum NgbSlideEventDirection {\n  LEFT = <any>'left',\n  RIGHT = <any>'right'\n}\n\nexport enum NgbSlideEventSource {\n  TIMER = 'timer',\n  ARROW_LEFT = 'arrowLeft',\n  ARROW_RIGHT = 'arrowRight',\n  INDICATOR = 'indicator'\n}\n\nexport const NGB_CAROUSEL_DIRECTIVES = [NgbCarousel, NgbSlide];\n"]}