tools/side_chain_tool/web/node_modules/bootstrap/js/dist/carousel.js

   1 (function (global, factory) {
   2   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('jquery'), require('./util.js')) :
   3   typeof define === 'function' && define.amd ? define(['jquery', './util.js'], factory) :
   4   (global.Carousel = factory(global.jQuery,global.Util));
   5 }(this, (function ($,Util) { 'use strict';
   6
   7   $ = $ && $.hasOwnProperty('default') ? $['default'] : $;
   8   Util = Util && Util.hasOwnProperty('default') ? Util['default'] : Util;
   9
  10   function _defineProperties(target, props) {
  11     for (var i = 0; i < props.length; i++) {
  12       var descriptor = props[i];
  13       descriptor.enumerable = descriptor.enumerable || false;
  14       descriptor.configurable = true;
  15       if ("value" in descriptor) descriptor.writable = true;
  16       Object.defineProperty(target, descriptor.key, descriptor);
  17     }
  18   }
  19
  20   function _createClass(Constructor, protoProps, staticProps) {
  21     if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  22     if (staticProps) _defineProperties(Constructor, staticProps);
  23     return Constructor;
  24   }
  25
  26   function _defineProperty(obj, key, value) {
  27     if (key in obj) {
  28       Object.defineProperty(obj, key, {
  29         value: value,
  30         enumerable: true,
  31         configurable: true,
  32         writable: true
  33       });
  34     } else {
  35       obj[key] = value;
  36     }
  37
  38     return obj;
  39   }
  40
  41   function _objectSpread(target) {
  42     for (var i = 1; i < arguments.length; i++) {
  43       var source = arguments[i] != null ? arguments[i] : {};
  44       var ownKeys = Object.keys(source);
  45
  46       if (typeof Object.getOwnPropertySymbols === 'function') {
  47         ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
  48           return Object.getOwnPropertyDescriptor(source, sym).enumerable;
  49         }));
  50       }
  51
  52       ownKeys.forEach(function (key) {
  53         _defineProperty(target, key, source[key]);
  54       });
  55     }
  56
  57     return target;
  58   }
  59
  60   /**
  61    * --------------------------------------------------------------------------
  62    * Bootstrap (v4.1.3): carousel.js
  63    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  64    * --------------------------------------------------------------------------
  65    */
  66
  67   var Carousel = function ($$$1) {
  68     /**
  69      * ------------------------------------------------------------------------
  70      * Constants
  71      * ------------------------------------------------------------------------
  72      */
  73     var NAME = 'carousel';
  74     var VERSION = '4.1.3';
  75     var DATA_KEY = 'bs.carousel';
  76     var EVENT_KEY = "." + DATA_KEY;
  77     var DATA_API_KEY = '.data-api';
  78     var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
  79     var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key
  80
  81     var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key
  82
  83     var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
  84
  85     var Default = {
  86       interval: 5000,
  87       keyboard: true,
  88       slide: false,
  89       pause: 'hover',
  90       wrap: true
  91     };
  92     var DefaultType = {
  93       interval: '(number|boolean)',
  94       keyboard: 'boolean',
  95       slide: '(boolean|string)',
  96       pause: '(string|boolean)',
  97       wrap: 'boolean'
  98     };
  99     var Direction = {
 100       NEXT: 'next',
 101       PREV: 'prev',
 102       LEFT: 'left',
 103       RIGHT: 'right'
 104     };
 105     var Event = {
 106       SLIDE: "slide" + EVENT_KEY,
 107       SLID: "slid" + EVENT_KEY,
 108       KEYDOWN: "keydown" + EVENT_KEY,
 109       MOUSEENTER: "mouseenter" + EVENT_KEY,
 110       MOUSELEAVE: "mouseleave" + EVENT_KEY,
 111       TOUCHEND: "touchend" + EVENT_KEY,
 112       LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY,
 113       CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
 114     };
 115     var ClassName = {
 116       CAROUSEL: 'carousel',
 117       ACTIVE: 'active',
 118       SLIDE: 'slide',
 119       RIGHT: 'carousel-item-right',
 120       LEFT: 'carousel-item-left',
 121       NEXT: 'carousel-item-next',
 122       PREV: 'carousel-item-prev',
 123       ITEM: 'carousel-item'
 124     };
 125     var Selector = {
 126       ACTIVE: '.active',
 127       ACTIVE_ITEM: '.active.carousel-item',
 128       ITEM: '.carousel-item',
 129       NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
 130       INDICATORS: '.carousel-indicators',
 131       DATA_SLIDE: '[data-slide], [data-slide-to]',
 132       DATA_RIDE: '[data-ride="carousel"]'
 133       /**
 134        * ------------------------------------------------------------------------
 135        * Class Definition
 136        * ------------------------------------------------------------------------
 137        */
 138
 139     };
 140
 141     var Carousel =
 142     /*#__PURE__*/
 143     function () {
 144       function Carousel(element, config) {
 145         this._items = null;
 146         this._interval = null;
 147         this._activeElement = null;
 148         this._isPaused = false;
 149         this._isSliding = false;
 150         this.touchTimeout = null;
 151         this._config = this._getConfig(config);
 152         this._element = $$$1(element)[0];
 153         this._indicatorsElement = this._element.querySelector(Selector.INDICATORS);
 154
 155         this._addEventListeners();
 156       } // Getters
 157
 158
 159       var _proto = Carousel.prototype;
 160
 161       // Public
 162       _proto.next = function next() {
 163         if (!this._isSliding) {
 164           this._slide(Direction.NEXT);
 165         }
 166       };
 167
 168       _proto.nextWhenVisible = function nextWhenVisible() {
 169         // Don't call next when the page isn't visible
 170         // or the carousel or its parent isn't visible
 171         if (!document.hidden && $$$1(this._element).is(':visible') && $$$1(this._element).css('visibility') !== 'hidden') {
 172           this.next();
 173         }
 174       };
 175
 176       _proto.prev = function prev() {
 177         if (!this._isSliding) {
 178           this._slide(Direction.PREV);
 179         }
 180       };
 181
 182       _proto.pause = function pause(event) {
 183         if (!event) {
 184           this._isPaused = true;
 185         }
 186
 187         if (this._element.querySelector(Selector.NEXT_PREV)) {
 188           Util.triggerTransitionEnd(this._element);
 189           this.cycle(true);
 190         }
 191
 192         clearInterval(this._interval);
 193         this._interval = null;
 194       };
 195
 196       _proto.cycle = function cycle(event) {
 197         if (!event) {
 198           this._isPaused = false;
 199         }
 200
 201         if (this._interval) {
 202           clearInterval(this._interval);
 203           this._interval = null;
 204         }
 205
 206         if (this._config.interval && !this._isPaused) {
 207           this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
 208         }
 209       };
 210
 211       _proto.to = function to(index) {
 212         var _this = this;
 213
 214         this._activeElement = this._element.querySelector(Selector.ACTIVE_ITEM);
 215
 216         var activeIndex = this._getItemIndex(this._activeElement);
 217
 218         if (index > this._items.length - 1 || index < 0) {
 219           return;
 220         }
 221
 222         if (this._isSliding) {
 223           $$$1(this._element).one(Event.SLID, function () {
 224             return _this.to(index);
 225           });
 226           return;
 227         }
 228
 229         if (activeIndex === index) {
 230           this.pause();
 231           this.cycle();
 232           return;
 233         }
 234
 235         var direction = index > activeIndex ? Direction.NEXT : Direction.PREV;
 236
 237         this._slide(direction, this._items[index]);
 238       };
 239
 240       _proto.dispose = function dispose() {
 241         $$$1(this._element).off(EVENT_KEY);
 242         $$$1.removeData(this._element, DATA_KEY);
 243         this._items = null;
 244         this._config = null;
 245         this._element = null;
 246         this._interval = null;
 247         this._isPaused = null;
 248         this._isSliding = null;
 249         this._activeElement = null;
 250         this._indicatorsElement = null;
 251       }; // Private
 252
 253
 254       _proto._getConfig = function _getConfig(config) {
 255         config = _objectSpread({}, Default, config);
 256         Util.typeCheckConfig(NAME, config, DefaultType);
 257         return config;
 258       };
 259
 260       _proto._addEventListeners = function _addEventListeners() {
 261         var _this2 = this;
 262
 263         if (this._config.keyboard) {
 264           $$$1(this._element).on(Event.KEYDOWN, function (event) {
 265             return _this2._keydown(event);
 266           });
 267         }
 268
 269         if (this._config.pause === 'hover') {
 270           $$$1(this._element).on(Event.MOUSEENTER, function (event) {
 271             return _this2.pause(event);
 272           }).on(Event.MOUSELEAVE, function (event) {
 273             return _this2.cycle(event);
 274           });
 275
 276           if ('ontouchstart' in document.documentElement) {
 277             // If it's a touch-enabled device, mouseenter/leave are fired as
 278             // part of the mouse compatibility events on first tap - the carousel
 279             // would stop cycling until user tapped out of it;
 280             // here, we listen for touchend, explicitly pause the carousel
 281             // (as if it's the second time we tap on it, mouseenter compat event
 282             // is NOT fired) and after a timeout (to allow for mouse compatibility
 283             // events to fire) we explicitly restart cycling
 284             $$$1(this._element).on(Event.TOUCHEND, function () {
 285               _this2.pause();
 286
 287               if (_this2.touchTimeout) {
 288                 clearTimeout(_this2.touchTimeout);
 289               }
 290
 291               _this2.touchTimeout = setTimeout(function (event) {
 292                 return _this2.cycle(event);
 293               }, TOUCHEVENT_COMPAT_WAIT + _this2._config.interval);
 294             });
 295           }
 296         }
 297       };
 298
 299       _proto._keydown = function _keydown(event) {
 300         if (/input|textarea/i.test(event.target.tagName)) {
 301           return;
 302         }
 303
 304         switch (event.which) {
 305           case ARROW_LEFT_KEYCODE:
 306             event.preventDefault();
 307             this.prev();
 308             break;
 309
 310           case ARROW_RIGHT_KEYCODE:
 311             event.preventDefault();
 312             this.next();
 313             break;
 314
 315           default:
 316         }
 317       };
 318
 319       _proto._getItemIndex = function _getItemIndex(element) {
 320         this._items = element && element.parentNode ? [].slice.call(element.parentNode.querySelectorAll(Selector.ITEM)) : [];
 321         return this._items.indexOf(element);
 322       };
 323
 324       _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) {
 325         var isNextDirection = direction === Direction.NEXT;
 326         var isPrevDirection = direction === Direction.PREV;
 327
 328         var activeIndex = this._getItemIndex(activeElement);
 329
 330         var lastItemIndex = this._items.length - 1;
 331         var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex;
 332
 333         if (isGoingToWrap && !this._config.wrap) {
 334           return activeElement;
 335         }
 336
 337         var delta = direction === Direction.PREV ? -1 : 1;
 338         var itemIndex = (activeIndex + delta) % this._items.length;
 339         return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex];
 340       };
 341
 342       _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) {
 343         var targetIndex = this._getItemIndex(relatedTarget);
 344
 345         var fromIndex = this._getItemIndex(this._element.querySelector(Selector.ACTIVE_ITEM));
 346
 347         var slideEvent = $$$1.Event(Event.SLIDE, {
 348           relatedTarget: relatedTarget,
 349           direction: eventDirectionName,
 350           from: fromIndex,
 351           to: targetIndex
 352         });
 353         $$$1(this._element).trigger(slideEvent);
 354         return slideEvent;
 355       };
 356
 357       _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) {
 358         if (this._indicatorsElement) {
 359           var indicators = [].slice.call(this._indicatorsElement.querySelectorAll(Selector.ACTIVE));
 360           $$$1(indicators).removeClass(ClassName.ACTIVE);
 361
 362           var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)];
 363
 364           if (nextIndicator) {
 365             $$$1(nextIndicator).addClass(ClassName.ACTIVE);
 366           }
 367         }
 368       };
 369
 370       _proto._slide = function _slide(direction, element) {
 371         var _this3 = this;
 372
 373         var activeElement = this._element.querySelector(Selector.ACTIVE_ITEM);
 374
 375         var activeElementIndex = this._getItemIndex(activeElement);
 376
 377         var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement);
 378
 379         var nextElementIndex = this._getItemIndex(nextElement);
 380
 381         var isCycling = Boolean(this._interval);
 382         var directionalClassName;
 383         var orderClassName;
 384         var eventDirectionName;
 385
 386         if (direction === Direction.NEXT) {
 387           directionalClassName = ClassName.LEFT;
 388           orderClassName = ClassName.NEXT;
 389           eventDirectionName = Direction.LEFT;
 390         } else {
 391           directionalClassName = ClassName.RIGHT;
 392           orderClassName = ClassName.PREV;
 393           eventDirectionName = Direction.RIGHT;
 394         }
 395
 396         if (nextElement && $$$1(nextElement).hasClass(ClassName.ACTIVE)) {
 397           this._isSliding = false;
 398           return;
 399         }
 400
 401         var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
 402
 403         if (slideEvent.isDefaultPrevented()) {
 404           return;
 405         }
 406
 407         if (!activeElement || !nextElement) {
 408           // Some weirdness is happening, so we bail
 409           return;
 410         }
 411
 412         this._isSliding = true;
 413
 414         if (isCycling) {
 415           this.pause();
 416         }
 417
 418         this._setActiveIndicatorElement(nextElement);
 419
 420         var slidEvent = $$$1.Event(Event.SLID, {
 421           relatedTarget: nextElement,
 422           direction: eventDirectionName,
 423           from: activeElementIndex,
 424           to: nextElementIndex
 425         });
 426
 427         if ($$$1(this._element).hasClass(ClassName.SLIDE)) {
 428           $$$1(nextElement).addClass(orderClassName);
 429           Util.reflow(nextElement);
 430           $$$1(activeElement).addClass(directionalClassName);
 431           $$$1(nextElement).addClass(directionalClassName);
 432           var transitionDuration = Util.getTransitionDurationFromElement(activeElement);
 433           $$$1(activeElement).one(Util.TRANSITION_END, function () {
 434             $$$1(nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(ClassName.ACTIVE);
 435             $$$1(activeElement).removeClass(ClassName.ACTIVE + " " + orderClassName + " " + directionalClassName);
 436             _this3._isSliding = false;
 437             setTimeout(function () {
 438               return $$$1(_this3._element).trigger(slidEvent);
 439             }, 0);
 440           }).emulateTransitionEnd(transitionDuration);
 441         } else {
 442           $$$1(activeElement).removeClass(ClassName.ACTIVE);
 443           $$$1(nextElement).addClass(ClassName.ACTIVE);
 444           this._isSliding = false;
 445           $$$1(this._element).trigger(slidEvent);
 446         }
 447
 448         if (isCycling) {
 449           this.cycle();
 450         }
 451       }; // Static
 452
 453
 454       Carousel._jQueryInterface = function _jQueryInterface(config) {
 455         return this.each(function () {
 456           var data = $$$1(this).data(DATA_KEY);
 457
 458           var _config = _objectSpread({}, Default, $$$1(this).data());
 459
 460           if (typeof config === 'object') {
 461             _config = _objectSpread({}, _config, config);
 462           }
 463
 464           var action = typeof config === 'string' ? config : _config.slide;
 465
 466           if (!data) {
 467             data = new Carousel(this, _config);
 468             $$$1(this).data(DATA_KEY, data);
 469           }
 470
 471           if (typeof config === 'number') {
 472             data.to(config);
 473           } else if (typeof action === 'string') {
 474             if (typeof data[action] === 'undefined') {
 475               throw new TypeError("No method named \"" + action + "\"");
 476             }
 477
 478             data[action]();
 479           } else if (_config.interval) {
 480             data.pause();
 481             data.cycle();
 482           }
 483         });
 484       };
 485
 486       Carousel._dataApiClickHandler = function _dataApiClickHandler(event) {
 487         var selector = Util.getSelectorFromElement(this);
 488
 489         if (!selector) {
 490           return;
 491         }
 492
 493         var target = $$$1(selector)[0];
 494
 495         if (!target || !$$$1(target).hasClass(ClassName.CAROUSEL)) {
 496           return;
 497         }
 498
 499         var config = _objectSpread({}, $$$1(target).data(), $$$1(this).data());
 500
 501         var slideIndex = this.getAttribute('data-slide-to');
 502
 503         if (slideIndex) {
 504           config.interval = false;
 505         }
 506
 507         Carousel._jQueryInterface.call($$$1(target), config);
 508
 509         if (slideIndex) {
 510           $$$1(target).data(DATA_KEY).to(slideIndex);
 511         }
 512
 513         event.preventDefault();
 514       };
 515
 516       _createClass(Carousel, null, [{
 517         key: "VERSION",
 518         get: function get() {
 519           return VERSION;
 520         }
 521       }, {
 522         key: "Default",
 523         get: function get() {
 524           return Default;
 525         }
 526       }]);
 527
 528       return Carousel;
 529     }();
 530     /**
 531      * ------------------------------------------------------------------------
 532      * Data Api implementation
 533      * ------------------------------------------------------------------------
 534      */
 535
 536
 537     $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_SLIDE, Carousel._dataApiClickHandler);
 538     $$$1(window).on(Event.LOAD_DATA_API, function () {
 539       var carousels = [].slice.call(document.querySelectorAll(Selector.DATA_RIDE));
 540
 541       for (var i = 0, len = carousels.length; i < len; i++) {
 542         var $carousel = $$$1(carousels[i]);
 543
 544         Carousel._jQueryInterface.call($carousel, $carousel.data());
 545       }
 546     });
 547     /**
 548      * ------------------------------------------------------------------------
 549      * jQuery
 550      * ------------------------------------------------------------------------
 551      */
 552
 553     $$$1.fn[NAME] = Carousel._jQueryInterface;
 554     $$$1.fn[NAME].Constructor = Carousel;
 555
 556     $$$1.fn[NAME].noConflict = function () {
 557       $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
 558       return Carousel._jQueryInterface;
 559     };
 560
 561     return Carousel;
 562   }($);
 563
 564   return Carousel;
 565
 566 })));
 567 //# sourceMappingURL=carousel.js.map