ngx-bootstrap 3.0.1 → 3.1.4

package/carousel/bundles/ngx-bootstrap-carousel.umd.js

@@ -0,0 +1,567 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('ngx-bootstrap/utils'), require('@angular/common')) :
+    typeof define === 'function' && define.amd ? define('ngx-bootstrap/carousel', ['exports', '@angular/core', 'ngx-bootstrap/utils', '@angular/common'], factory) :
+    (factory((global['ngx-bootstrap'] = global['ngx-bootstrap'] || {}, global['ngx-bootstrap'].carousel = {}),global.ng.core,global.utils,global.ng.common));
+}(this, (function (exports,core,utils,common) { 'use strict';
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var CarouselConfig = (function () {
+        function CarouselConfig() {
+            /**
+             * Default interval of auto changing of slides
+             */
+            this.interval = 5000;
+            /**
+             * Is loop of auto changing of slides can be paused
+             */
+            this.noPause = false;
+            /**
+             * Is slides can wrap from the last to the first slide
+             */
+            this.noWrap = false;
+            /**
+             * Show carousel-indicators
+             */
+            this.showIndicators = true;
+        }
+        CarouselConfig.decorators = [
+            { type: core.Injectable }
+        ];
+        return CarouselConfig;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /** @enum {number} */
+    var Direction = {
+        UNKNOWN: 0,
+        NEXT: 1,
+        PREV: 2,
+    };
+    Direction[Direction.UNKNOWN] = "UNKNOWN";
+    Direction[Direction.NEXT] = "NEXT";
+    Direction[Direction.PREV] = "PREV";
+    /**
+     * Base element to create carousel
+     */
+    var CarouselComponent = (function () {
+        function CarouselComponent(config, ngZone) {
+            this.ngZone = ngZone;
+            /**
+             * Will be emitted when active slide has been changed. Part of two-way-bindable [(activeSlide)] property
+             */
+            this.activeSlideChange = new core.EventEmitter(false);
+            this._slides = new utils.LinkedList();
+            this.destroyed = false;
+            Object.assign(this, config);
+        }
+        Object.defineProperty(CarouselComponent.prototype, "activeSlide", {
+            get: /**
+             * @return {?}
+             */ function () {
+                return this._currentActiveSlide;
+            },
+            set: /**
+             * Index of currently displayed slide(started for 0)
+             * @param {?} index
+             * @return {?}
+             */ function (index) {
+                if (this._slides.length && index !== this._currentActiveSlide) {
+                    this._select(index);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(CarouselComponent.prototype, "interval", {
+            get: /**
+             * Delay of item cycling in milliseconds. If false, carousel won't cycle
+             * automatically.
+             * @return {?}
+             */ function () {
+                return this._interval;
+            },
+            set: /**
+             * @param {?} value
+             * @return {?}
+             */ function (value) {
+                this._interval = value;
+                this.restartTimer();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(CarouselComponent.prototype, "slides", {
+            get: /**
+             * @return {?}
+             */ function () {
+                return this._slides.toArray();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(CarouselComponent.prototype, "isBs4", {
+            get: /**
+             * @return {?}
+             */ function () {
+                return !utils.isBs3();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @return {?}
+         */
+        CarouselComponent.prototype.ngOnDestroy = /**
+         * @return {?}
+         */
+            function () {
+                this.destroyed = true;
+            };
+        /**
+         * Adds new slide. If this slide is first in collection - set it as active
+         * and starts auto changing
+         * @param slide
+         */
+        /**
+         * Adds new slide. If this slide is first in collection - set it as active
+         * and starts auto changing
+         * @param {?} slide
+         * @return {?}
+         */
+        CarouselComponent.prototype.addSlide = /**
+         * Adds new slide. If this slide is first in collection - set it as active
+         * and starts auto changing
+         * @param {?} slide
+         * @return {?}
+         */
+            function (slide) {
+                this._slides.add(slide);
+                if (this._slides.length === 1) {
+                    this._currentActiveSlide = void 0;
+                    this.activeSlide = 0;
+                    this.play();
+                }
+            };
+        /**
+         * Removes specified slide. If this slide is active - will roll to another
+         * slide
+         * @param slide
+         */
+        /**
+         * Removes specified slide. If this slide is active - will roll to another
+         * slide
+         * @param {?} slide
+         * @return {?}
+         */
+        CarouselComponent.prototype.removeSlide = /**
+         * Removes specified slide. If this slide is active - will roll to another
+         * slide
+         * @param {?} slide
+         * @return {?}
+         */
+            function (slide) {
+                var _this = this;
+                var /** @type {?} */ remIndex = this._slides.indexOf(slide);
+                if (this._currentActiveSlide === remIndex) {
+                    // removing of active slide
+                    var /** @type {?} */ nextSlideIndex_1 = void 0;
+                    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
+                        // 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_1 = !this.isLast(remIndex)
+                            ? remIndex
+                            : this.noWrap ? remIndex - 1 : 0;
+                    }
+                    this._slides.remove(remIndex);
+                    // prevents exception with changing some value after checking
+                    setTimeout(function () {
+                        _this._select(nextSlideIndex_1);
+                    }, 0);
+                }
+                else {
+                    this._slides.remove(remIndex);
+                    var /** @type {?} */ currentSlideIndex_1 = this.getCurrentSlideIndex();
+                    setTimeout(function () {
+                        // after removing, need to actualize index of current active slide
+                        // after removing, need to actualize index of current active slide
+                        _this._currentActiveSlide = currentSlideIndex_1;
+                        _this.activeSlideChange.emit(_this._currentActiveSlide);
+                    }, 0);
+                }
+            };
+        /**
+         * Rolling to next slide
+         * @param force: {boolean} if true - will ignore noWrap flag
+         */
+        /**
+         * Rolling to next slide
+         * @param {?=} force
+         * @return {?}
+         */
+        CarouselComponent.prototype.nextSlide = /**
+         * Rolling to next slide
+         * @param {?=} force
+         * @return {?}
+         */
+            function (force) {
+                if (force === void 0) {
+                    force = false;
+                }
+                this.activeSlide = this.findNextSlideIndex(Direction.NEXT, force);
+            };
+        /**
+         * Rolling to previous slide
+         * @param force: {boolean} if true - will ignore noWrap flag
+         */
+        /**
+         * Rolling to previous slide
+         * @param {?=} force
+         * @return {?}
+         */
+        CarouselComponent.prototype.previousSlide = /**
+         * Rolling to previous slide
+         * @param {?=} force
+         * @return {?}
+         */
+            function (force) {
+                if (force === void 0) {
+                    force = false;
+                }
+                this.activeSlide = this.findNextSlideIndex(Direction.PREV, force);
+            };
+        /**
+         * Rolling to specified slide
+         * @param index: {number} index of slide, which must be shown
+         */
+        /**
+         * Rolling to specified slide
+         * @param {?} index
+         * @return {?}
+         */
+        CarouselComponent.prototype.selectSlide = /**
+         * Rolling to specified slide
+         * @param {?} index
+         * @return {?}
+         */
+            function (index) {
+                this.activeSlide = index;
+            };
+        /**
+         * Starts a auto changing of slides
+         */
+        /**
+         * Starts a auto changing of slides
+         * @return {?}
+         */
+        CarouselComponent.prototype.play = /**
+         * Starts a auto changing of slides
+         * @return {?}
+         */
+            function () {
+                if (!this.isPlaying) {
+                    this.isPlaying = true;
+                    this.restartTimer();
+                }
+            };
+        /**
+         * Stops a auto changing of slides
+         */
+        /**
+         * Stops a auto changing of slides
+         * @return {?}
+         */
+        CarouselComponent.prototype.pause = /**
+         * Stops a auto changing of slides
+         * @return {?}
+         */
+            function () {
+                if (!this.noPause) {
+                    this.isPlaying = false;
+                    this.resetTimer();
+                }
+            };
+        /**
+         * Finds and returns index of currently displayed slide
+         */
+        /**
+         * Finds and returns index of currently displayed slide
+         * @return {?}
+         */
+        CarouselComponent.prototype.getCurrentSlideIndex = /**
+         * Finds and returns index of currently displayed slide
+         * @return {?}
+         */
+            function () {
+                return this._slides.findIndex(function (slide) { return slide.active; });
+            };
+        /**
+         * Defines, whether the specified index is last in collection
+         * @param index
+         */
+        /**
+         * Defines, whether the specified index is last in collection
+         * @param {?} index
+         * @return {?}
+         */
+        CarouselComponent.prototype.isLast = /**
+         * Defines, whether the specified index is last in collection
+         * @param {?} index
+         * @return {?}
+         */
+            function (index) {
+                return index + 1 >= this._slides.length;
+            };
+        /**
+         * Defines next slide index, depending of direction
+         * @param {?} direction
+         * @param {?} force
+         * @return {?}
+         */
+        CarouselComponent.prototype.findNextSlideIndex = /**
+         * Defines next slide index, depending of direction
+         * @param {?} direction
+         * @param {?} force
+         * @return {?}
+         */
+            function (direction, force) {
+                var /** @type {?} */ nextSlideIndex = 0;
+                if (!force &&
+                    (this.isLast(this.activeSlide) &&
+                        direction !== Direction.PREV &&
+                        this.noWrap)) {
+                    return void 0;
+                }
+                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
+                        nextSlideIndex = !this.isLast(this._currentActiveSlide)
+                            ? this._currentActiveSlide + 1
+                            : !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
+                        nextSlideIndex =
+                            this._currentActiveSlide > 0
+                                ? this._currentActiveSlide - 1
+                                : !force && this.noWrap
+                                    ? this._currentActiveSlide
+                                    : this._slides.length - 1;
+                        break;
+                    default:
+                        throw new Error('Unknown direction');
+                }
+                return nextSlideIndex;
+            };
+        /**
+         * Sets a slide, which specified through index, as active
+         * @param {?} index
+         * @return {?}
+         */
+        CarouselComponent.prototype._select = /**
+         * Sets a slide, which specified through index, as active
+         * @param {?} index
+         * @return {?}
+         */
+            function (index) {
+                if (isNaN(index)) {
+                    this.pause();
+                    return;
+                }
+                var /** @type {?} */ currentSlide = this._slides.get(this._currentActiveSlide);
+                if (currentSlide) {
+                    currentSlide.active = false;
+                }
+                var /** @type {?} */ nextSlide = this._slides.get(index);
+                if (nextSlide) {
+                    this._currentActiveSlide = index;
+                    nextSlide.active = true;
+                    this.activeSlide = index;
+                    this.activeSlideChange.emit(index);
+                }
+            };
+        /**
+         * Starts loop of auto changing of slides
+         * @return {?}
+         */
+        CarouselComponent.prototype.restartTimer = /**
+         * Starts loop of auto changing of slides
+         * @return {?}
+         */
+            function () {
+                var _this = this;
+                this.resetTimer();
+                var /** @type {?} */ interval = +this.interval;
+                if (!isNaN(interval) && interval > 0) {
+                    this.currentInterval = this.ngZone.runOutsideAngular(function () {
+                        return setInterval(function () {
+                            var /** @type {?} */ nInterval = +_this.interval;
+                            _this.ngZone.run(function () {
+                                if (_this.isPlaying &&
+                                    !isNaN(_this.interval) &&
+                                    nInterval > 0 &&
+                                    _this.slides.length) {
+                                    _this.nextSlide();
+                                }
+                                else {
+                                    _this.pause();
+                                }
+                            });
+                        }, interval);
+                    });
+                }
+            };
+        /**
+         * Stops loop of auto changing of slides
+         * @return {?}
+         */
+        CarouselComponent.prototype.resetTimer = /**
+         * Stops loop of auto changing of slides
+         * @return {?}
+         */
+            function () {
+                if (this.currentInterval) {
+                    clearInterval(this.currentInterval);
+                    this.currentInterval = void 0;
+                }
+            };
+        CarouselComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'carousel',
+                        template: "<div (mouseenter)=\"pause()\" (mouseleave)=\"play()\" (mouseup)=\"play()\" class=\"carousel slide\">\n  <ol class=\"carousel-indicators\" *ngIf=\"showIndicators && slides.length > 1\">\n    <li *ngFor=\"let slidez of slides; let i = index;\" [class.active]=\"slidez.active === true\" (click)=\"selectSlide(i)\"></li>\n  </ol>\n  <div class=\"carousel-inner\"><ng-content></ng-content></div>\n  <a class=\"left carousel-control carousel-control-prev\" [class.disabled]=\"activeSlide === 0 && noWrap\" (click)=\"previousSlide()\" *ngIf=\"slides.length > 1\">\n    <span class=\"icon-prev carousel-control-prev-icon\" aria-hidden=\"true\"></span>\n    <span *ngIf=\"isBs4\" class=\"sr-only\">Previous</span>\n  </a>\n  <a class=\"right carousel-control carousel-control-next\" (click)=\"nextSlide()\"  [class.disabled]=\"isLast(activeSlide) && noWrap\" *ngIf=\"slides.length > 1\">\n    <span class=\"icon-next carousel-control-next-icon\" aria-hidden=\"true\"></span>\n    <span class=\"sr-only\">Next</span>\n  </a>\n</div>\n"
+                    }] }
+        ];
+        /** @nocollapse */
+        CarouselComponent.ctorParameters = function () {
+            return [
+                { type: CarouselConfig, },
+                { type: core.NgZone, },
+            ];
+        };
+        CarouselComponent.propDecorators = {
+            "noWrap": [{ type: core.Input },],
+            "noPause": [{ type: core.Input },],
+            "showIndicators": [{ type: core.Input },],
+            "activeSlideChange": [{ type: core.Output },],
+            "activeSlide": [{ type: core.Input },],
+            "interval": [{ type: core.Input },],
+        };
+        return CarouselComponent;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var SlideComponent = (function () {
+        function SlideComponent(carousel) {
+            /**
+             * Wraps element by appropriate CSS classes
+             */
+            this.addClass = true;
+            this.carousel = carousel;
+        }
+        /** Fires changes in container collection after adding a new slide instance */
+        /**
+         * Fires changes in container collection after adding a new slide instance
+         * @return {?}
+         */
+        SlideComponent.prototype.ngOnInit = /**
+         * Fires changes in container collection after adding a new slide instance
+         * @return {?}
+         */
+            function () {
+                this.carousel.addSlide(this);
+            };
+        /** Fires changes in container collection after removing of this slide instance */
+        /**
+         * Fires changes in container collection after removing of this slide instance
+         * @return {?}
+         */
+        SlideComponent.prototype.ngOnDestroy = /**
+         * Fires changes in container collection after removing of this slide instance
+         * @return {?}
+         */
+            function () {
+                this.carousel.removeSlide(this);
+            };
+        SlideComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'slide',
+                        template: "\n    <div [class.active]=\"active\" class=\"item\">\n      <ng-content></ng-content>\n    </div>\n  ",
+                        host: {
+                            '[attr.aria-hidden]': '!active'
+                        }
+                    }] }
+        ];
+        /** @nocollapse */
+        SlideComponent.ctorParameters = function () {
+            return [
+                { type: CarouselComponent, },
+            ];
+        };
+        SlideComponent.propDecorators = {
+            "active": [{ type: core.HostBinding, args: ['class.active',] }, { type: core.Input },],
+            "addClass": [{ type: core.HostBinding, args: ['class.item',] }, { type: core.HostBinding, args: ['class.carousel-item',] },],
+        };
+        return SlideComponent;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var CarouselModule = (function () {
+        function CarouselModule() {
+        }
+        /**
+         * @return {?}
+         */
+        CarouselModule.forRoot = /**
+         * @return {?}
+         */
+            function () {
+                return { ngModule: CarouselModule, providers: [] };
+            };
+        CarouselModule.decorators = [
+            { type: core.NgModule, args: [{
+                        imports: [common.CommonModule],
+                        declarations: [SlideComponent, CarouselComponent],
+                        exports: [SlideComponent, CarouselComponent],
+                        providers: [CarouselConfig]
+                    },] }
+        ];
+        return CarouselModule;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+
+    exports.CarouselComponent = CarouselComponent;
+    exports.CarouselModule = CarouselModule;
+    exports.SlideComponent = SlideComponent;
+    exports.CarouselConfig = CarouselConfig;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-carousel.umd.js.map","sources":["ng://ngx-bootstrap/carousel/carousel.config.ts","ng://ngx-bootstrap/carousel/carousel.component.ts","ng://ngx-bootstrap/carousel/slide.component.ts","ng://ngx-bootstrap/carousel/carousel.module.ts"],"sourcesContent":["import { Injectable } from '@angular/core';\n\n@Injectable()\nexport class CarouselConfig {\n  /** Default interval of auto changing of slides */\n  interval = 5000;\n\n  /** Is loop of auto changing of slides can be paused */\n  noPause = false;\n\n  /** Is slides can wrap from the last to the first slide */\n  noWrap = false;\n\n  /** Show carousel-indicators */\n  showIndicators = true;\n}\n","// tslint:disable:max-file-line-count\n/***\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\n} from '@angular/core';\n\nimport { isBs3, LinkedList } from 'ngx-bootstrap/utils';\nimport { SlideComponent } from './slide.component';\nimport { CarouselConfig } from './carousel.config';\n\nexport enum Direction {\n  UNKNOWN,\n  NEXT,\n  PREV\n}\n\n/**\n * Base element to create carousel\n */\n@Component({\n  selector: 'carousel',\n  templateUrl: './carousel.component.html'\n})\nexport class CarouselComponent implements OnDestroy {\n  /** If `true` â carousel will not cycle continuously and will have hard stops (prevent looping) */\n  @Input() noWrap: boolean;\n  /**  If `true` â will disable pausing on carousel mouse hover */\n  @Input() noPause: boolean;\n  /**  If `true` â carousel-indicators are visible  */\n  @Input() showIndicators: boolean;\n\n  /** Will be emitted when active slide has been changed. Part of two-way-bindable [(activeSlide)] property */\n  @Output()\n  activeSlideChange: EventEmitter<number> = new EventEmitter<number>(false);\n\n  /** Index of currently displayed slide(started for 0) */\n  @Input()\n  set activeSlide(index: number) {\n    if (this._slides.length && index !== this._currentActiveSlide) {\n      this._select(index);\n    }\n  }\n\n  get activeSlide(): number {\n    return this._currentActiveSlide;\n  }\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  // tslint:disable-next-line:no-any\n  protected currentInterval: any;\n  protected _currentActiveSlide: number;\n  protected _interval: number;\n  protected _slides: LinkedList<SlideComponent> = new LinkedList<SlideComponent>();\n  protected isPlaying: boolean;\n  protected destroyed = false;\n\n  get isBs4(): boolean {\n    return !isBs3();\n  }\n\n  constructor(config: CarouselConfig, private ngZone: NgZone) {\n    Object.assign(this, config);\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    if (this._slides.length === 1) {\n      this._currentActiveSlide = void 0;\n      this.activeSlide = 0;\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 = void 0;\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  /**\n   * Rolling to next slide\n   * @param force: {boolean} if true - will ignore noWrap flag\n   */\n  nextSlide(force = false): void {\n    this.activeSlide = this.findNextSlideIndex(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    this.activeSlide = this.findNextSlideIndex(Direction.PREV, force);\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    this.activeSlide = index;\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((slide: SlideComponent) => slide.active);\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 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 {\n    let nextSlideIndex = 0;\n\n    if (\n      !force &&\n      (this.isLast(this.activeSlide) &&\n        direction !== Direction.PREV &&\n        this.noWrap)\n    ) {\n      return void 0;\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        nextSlideIndex = !this.isLast(this._currentActiveSlide)\n          ? this._currentActiveSlide + 1\n          : !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        nextSlideIndex =\n          this._currentActiveSlide > 0\n            ? this._currentActiveSlide - 1\n            : !force && this.noWrap\n            ? this._currentActiveSlide\n            : this._slides.length - 1;\n        break;\n      default:\n        throw new Error('Unknown direction');\n    }\n\n    return nextSlideIndex;\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    const currentSlide = this._slides.get(this._currentActiveSlide);\n    if (currentSlide) {\n      currentSlide.active = false;\n    }\n    const nextSlide = this._slides.get(index);\n    if (nextSlide) {\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(() => {\n        return 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.nextSlide();\n            } else {\n              this.pause();\n            }\n          });\n        }, interval);\n      });\n    }\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","import {\n  Component,\n  HostBinding,\n  OnDestroy,\n  Input,\n  OnInit\n} from '@angular/core';\n\nimport { CarouselComponent } from './carousel.component';\n\n@Component({\n  selector: 'slide',\n  template: `\n    <div [class.active]=\"active\" class=\"item\">\n      <ng-content></ng-content>\n    </div>\n  `,\n  host: {\n    '[attr.aria-hidden]': '!active'\n  }\n})\nexport class SlideComponent implements OnInit, OnDestroy {\n  /** Is current slide active */\n  @HostBinding('class.active')\n  @Input()\n  active: boolean;\n\n  /** Wraps element by appropriate CSS classes */\n  @HostBinding('class.item')\n  @HostBinding('class.carousel-item')\n  addClass = true;\n\n  /** Link to Parent(container-collection) component */\n  protected carousel: CarouselComponent;\n\n  constructor(carousel: CarouselComponent) {\n    this.carousel = carousel;\n  }\n\n  /** Fires changes in container collection after adding a new slide instance */\n  ngOnInit(): void {\n    this.carousel.addSlide(this);\n  }\n\n  /** Fires changes in container collection after removing of this slide instance */\n  ngOnDestroy(): void {\n    this.carousel.removeSlide(this);\n  }\n}\n","import { CommonModule } from '@angular/common';\nimport { NgModule, ModuleWithProviders } from '@angular/core';\n\nimport { CarouselComponent } from './carousel.component';\nimport { SlideComponent } from './slide.component';\nimport { CarouselConfig } from './carousel.config';\n\n@NgModule({\n  imports: [CommonModule],\n  declarations: [SlideComponent, CarouselComponent],\n  exports: [SlideComponent, CarouselComponent],\n  providers: [CarouselConfig]\n})\nexport class CarouselModule {\n  static forRoot(): ModuleWithProviders {\n    return { ngModule: CarouselModule, providers: [] };\n  }\n}\n"],"names":["Injectable","EventEmitter","LinkedList","isBs3","Component","NgZone","Input","Output","HostBinding","NgModule","CommonModule"],"mappings":"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"}

package/carousel/bundles/ngx-bootstrap-carousel.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngx-bootstrap-carousel.umd.js.map","sources":["ng://ngx-bootstrap/carousel/carousel.config.ts","ng://ngx-bootstrap/carousel/carousel.component.ts","ng://ngx-bootstrap/carousel/slide.component.ts","ng://ngx-bootstrap/carousel/carousel.module.ts"],"sourcesContent":["import { Injectable } from '@angular/core';\n\n@Injectable()\nexport class CarouselConfig {\n  /** Default interval of auto changing of slides */\n  interval = 5000;\n\n  /** Is loop of auto changing of slides can be paused */\n  noPause = false;\n\n  /** Is slides can wrap from the last to the first slide */\n  noWrap = false;\n\n  /** Show carousel-indicators */\n  showIndicators = true;\n}\n","// tslint:disable:max-file-line-count\n/***\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\n} from '@angular/core';\n\nimport { isBs3, LinkedList } from 'ngx-bootstrap/utils';\nimport { SlideComponent } from './slide.component';\nimport { CarouselConfig } from './carousel.config';\n\nexport enum Direction {\n  UNKNOWN,\n  NEXT,\n  PREV\n}\n\n/**\n * Base element to create carousel\n */\n@Component({\n  selector: 'carousel',\n  templateUrl: './carousel.component.html'\n})\nexport class CarouselComponent implements OnDestroy {\n  /** If `true` — carousel will not cycle continuously and will have hard stops (prevent looping) */\n  @Input() noWrap: boolean;\n  /**  If `true` — will disable pausing on carousel mouse hover */\n  @Input() noPause: boolean;\n  /**  If `true` — carousel-indicators are visible  */\n  @Input() showIndicators: boolean;\n\n  /** Will be emitted when active slide has been changed. Part of two-way-bindable [(activeSlide)] property */\n  @Output()\n  activeSlideChange: EventEmitter<number> = new EventEmitter<number>(false);\n\n  /** Index of currently displayed slide(started for 0) */\n  @Input()\n  set activeSlide(index: number) {\n    if (this._slides.length && index !== this._currentActiveSlide) {\n      this._select(index);\n    }\n  }\n\n  get activeSlide(): number {\n    return this._currentActiveSlide;\n  }\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  // tslint:disable-next-line:no-any\n  protected currentInterval: any;\n  protected _currentActiveSlide: number;\n  protected _interval: number;\n  protected _slides: LinkedList<SlideComponent> = new LinkedList<SlideComponent>();\n  protected isPlaying: boolean;\n  protected destroyed = false;\n\n  get isBs4(): boolean {\n    return !isBs3();\n  }\n\n  constructor(config: CarouselConfig, private ngZone: NgZone) {\n    Object.assign(this, config);\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    if (this._slides.length === 1) {\n      this._currentActiveSlide = void 0;\n      this.activeSlide = 0;\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 = void 0;\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  /**\n   * Rolling to next slide\n   * @param force: {boolean} if true - will ignore noWrap flag\n   */\n  nextSlide(force = false): void {\n    this.activeSlide = this.findNextSlideIndex(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    this.activeSlide = this.findNextSlideIndex(Direction.PREV, force);\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    this.activeSlide = index;\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((slide: SlideComponent) => slide.active);\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 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 {\n    let nextSlideIndex = 0;\n\n    if (\n      !force &&\n      (this.isLast(this.activeSlide) &&\n        direction !== Direction.PREV &&\n        this.noWrap)\n    ) {\n      return void 0;\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        nextSlideIndex = !this.isLast(this._currentActiveSlide)\n          ? this._currentActiveSlide + 1\n          : !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        nextSlideIndex =\n          this._currentActiveSlide > 0\n            ? this._currentActiveSlide - 1\n            : !force && this.noWrap\n            ? this._currentActiveSlide\n            : this._slides.length - 1;\n        break;\n      default:\n        throw new Error('Unknown direction');\n    }\n\n    return nextSlideIndex;\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    const currentSlide = this._slides.get(this._currentActiveSlide);\n    if (currentSlide) {\n      currentSlide.active = false;\n    }\n    const nextSlide = this._slides.get(index);\n    if (nextSlide) {\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(() => {\n        return 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.nextSlide();\n            } else {\n              this.pause();\n            }\n          });\n        }, interval);\n      });\n    }\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","import {\n  Component,\n  HostBinding,\n  OnDestroy,\n  Input,\n  OnInit\n} from '@angular/core';\n\nimport { CarouselComponent } from './carousel.component';\n\n@Component({\n  selector: 'slide',\n  template: `\n    <div [class.active]=\"active\" class=\"item\">\n      <ng-content></ng-content>\n    </div>\n  `,\n  host: {\n    '[attr.aria-hidden]': '!active'\n  }\n})\nexport class SlideComponent implements OnInit, OnDestroy {\n  /** Is current slide active */\n  @HostBinding('class.active')\n  @Input()\n  active: boolean;\n\n  /** Wraps element by appropriate CSS classes */\n  @HostBinding('class.item')\n  @HostBinding('class.carousel-item')\n  addClass = true;\n\n  /** Link to Parent(container-collection) component */\n  protected carousel: CarouselComponent;\n\n  constructor(carousel: CarouselComponent) {\n    this.carousel = carousel;\n  }\n\n  /** Fires changes in container collection after adding a new slide instance */\n  ngOnInit(): void {\n    this.carousel.addSlide(this);\n  }\n\n  /** Fires changes in container collection after removing of this slide instance */\n  ngOnDestroy(): void {\n    this.carousel.removeSlide(this);\n  }\n}\n","import { CommonModule } from '@angular/common';\nimport { NgModule, ModuleWithProviders } from '@angular/core';\n\nimport { CarouselComponent } from './carousel.component';\nimport { SlideComponent } from './slide.component';\nimport { CarouselConfig } from './carousel.config';\n\n@NgModule({\n  imports: [CommonModule],\n  declarations: [SlideComponent, CarouselComponent],\n  exports: [SlideComponent, CarouselComponent],\n  providers: [CarouselConfig]\n})\nexport class CarouselModule {\n  static forRoot(): ModuleWithProviders {\n    return { ngModule: CarouselModule, providers: [] };\n  }\n}\n"],"names":["Injectable","EventEmitter","LinkedList","isBs3","Component","NgZone","Input","Output","HostBinding","NgModule","CommonModule"],"mappings":"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"}