ngx-bootstrap
Version:
Native Angular Bootstrap Components
539 lines • 37 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
// tslint:disable:max-file-line-count
/***
* 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 } from 'ngx-bootstrap/utils';
import { CarouselConfig } from './carousel.config';
/** @enum {number} */
var Direction = {
UNKNOWN: 0,
NEXT: 1,
PREV: 2,
};
export { Direction };
Direction[Direction.UNKNOWN] = 'UNKNOWN';
Direction[Direction.NEXT] = 'NEXT';
Direction[Direction.PREV] = 'PREV';
/**
* Base element to create carousel
*/
var CarouselComponent = /** @class */ (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 EventEmitter(false);
this._slides = new LinkedList();
this.destroyed = false;
Object.assign(this, config);
}
Object.defineProperty(CarouselComponent.prototype, "activeSlide", {
get: /**
* @return {?}
*/
function () {
return this._currentActiveSlide;
},
/** Index of currently displayed slide(started for 0) */
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", {
/**
* Delay of item cycling in milliseconds. If false, carousel won't cycle
* automatically.
*/
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 !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;
/** @type {?} */
var remIndex = this._slides.indexOf(slide);
if (this._currentActiveSlide === remIndex) {
// removing of active slide
/** @type {?} */
var 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
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);
/** @type {?} */
var currentSlideIndex_1 = this.getCurrentSlideIndex();
setTimeout(function () {
// 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: Direction(UNKNOWN|PREV|NEXT)
* @param force: {boolean} if TRUE - will ignore noWrap flag, else will
* return undefined if next slide require wrapping
*/
/**
* Defines next slide index, depending of direction
* @private
* @param {?} direction
* @param {?} force
* @return {?}
*/
CarouselComponent.prototype.findNextSlideIndex = /**
* Defines next slide index, depending of direction
* @private
* @param {?} direction
* @param {?} force
* @return {?}
*/
function (direction, force) {
/** @type {?} */
var 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
*/
/**
* Sets a slide, which specified through index, as active
* @private
* @param {?} index
* @return {?}
*/
CarouselComponent.prototype._select = /**
* Sets a slide, which specified through index, as active
* @private
* @param {?} index
* @return {?}
*/
function (index) {
if (isNaN(index)) {
this.pause();
return;
}
/** @type {?} */
var currentSlide = this._slides.get(this._currentActiveSlide);
if (currentSlide) {
currentSlide.active = false;
}
/** @type {?} */
var 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
*/
/**
* Starts loop of auto changing of slides
* @private
* @return {?}
*/
CarouselComponent.prototype.restartTimer = /**
* Starts loop of auto changing of slides
* @private
* @return {?}
*/
function () {
var _this = this;
this.resetTimer();
/** @type {?} */
var interval = +this.interval;
if (!isNaN(interval) && interval > 0) {
this.currentInterval = this.ngZone.runOutsideAngular(function () {
return setInterval(function () {
/** @type {?} */
var 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
*/
/**
* Stops loop of auto changing of slides
* @private
* @return {?}
*/
CarouselComponent.prototype.resetTimer = /**
* Stops loop of auto changing of slides
* @private
* @return {?}
*/
function () {
if (this.currentInterval) {
clearInterval(this.currentInterval);
this.currentInterval = void 0;
}
};
CarouselComponent.decorators = [
{ type: 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: NgZone }
]; };
CarouselComponent.propDecorators = {
noWrap: [{ type: Input }],
noPause: [{ type: Input }],
showIndicators: [{ type: Input }],
activeSlideChange: [{ type: Output }],
activeSlide: [{ type: Input }],
interval: [{ type: Input }]
};
return CarouselComponent;
}());
export { CarouselComponent };
if (false) {
/**
* If `true` — carousel will not cycle continuously and will have hard stops (prevent looping)
* @type {?}
*/
CarouselComponent.prototype.noWrap;
/**
* If `true` — will disable pausing on carousel mouse hover
* @type {?}
*/
CarouselComponent.prototype.noPause;
/**
* If `true` — carousel-indicators are visible
* @type {?}
*/
CarouselComponent.prototype.showIndicators;
/**
* Will be emitted when active slide has been changed. Part of two-way-bindable [(activeSlide)] property
* @type {?}
*/
CarouselComponent.prototype.activeSlideChange;
/**
* @type {?}
* @protected
*/
CarouselComponent.prototype.currentInterval;
/**
* @type {?}
* @protected
*/
CarouselComponent.prototype._currentActiveSlide;
/**
* @type {?}
* @protected
*/
CarouselComponent.prototype._interval;
/**
* @type {?}
* @protected
*/
CarouselComponent.prototype._slides;
/**
* @type {?}
* @protected
*/
CarouselComponent.prototype.isPlaying;
/**
* @type {?}
* @protected
*/
CarouselComponent.prototype.destroyed;
/**
* @type {?}
* @private
*/
CarouselComponent.prototype.ngZone;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"carousel.component.js","sourceRoot":"ng://ngx-bootstrap/carousel/","sources":["carousel.component.ts"],"names":[],"mappings":"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","sourcesContent":["// 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"]}