infinity-forge 2.4.0 → 2.4.2

package/dist/ui/components/carousel/carousel-lib/core/update/updateSlides.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../shared/utils");
+function updateSlides() {
+    var swiper = this;
+    function getDirectionPropertyValue(node, label) {
+        return parseFloat(node.getPropertyValue(swiper.getDirectionLabel(label)) || 0);
+    }
+    var params = swiper.params;
+    var wrapperEl = swiper.wrapperEl, slidesEl = swiper.slidesEl, swiperSize = swiper.size, rtl = swiper.rtlTranslate, wrongRTL = swiper.wrongRTL;
+    var isVirtual = swiper.virtual && params.virtual.enabled;
+    var previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
+    var slides = (0, utils_1.elementChildren)(slidesEl, ".".concat(swiper.params.slideClass, ", swiper-slide"));
+    var slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
+    var snapGrid = [];
+    var slidesGrid = [];
+    var slidesSizesGrid = [];
+    var offsetBefore = params.slidesOffsetBefore;
+    if (typeof offsetBefore === 'function') {
+        offsetBefore = params.slidesOffsetBefore.call(swiper);
+    }
+    var offsetAfter = params.slidesOffsetAfter;
+    if (typeof offsetAfter === 'function') {
+        offsetAfter = params.slidesOffsetAfter.call(swiper);
+    }
+    var previousSnapGridLength = swiper.snapGrid.length;
+    var previousSlidesGridLength = swiper.slidesGrid.length;
+    var spaceBetween = params.spaceBetween;
+    var slidePosition = -offsetBefore;
+    var prevSlideSize = 0;
+    var index = 0;
+    if (typeof swiperSize === 'undefined') {
+        return;
+    }
+    if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
+        spaceBetween = (parseFloat(spaceBetween.replace('%', '')) / 100) * swiperSize;
+    }
+    else if (typeof spaceBetween === 'string') {
+        spaceBetween = parseFloat(spaceBetween);
+    }
+    swiper.virtualSize = -spaceBetween;
+    // reset margins
+    slides.forEach(function (slideEl) {
+        if (rtl) {
+            slideEl.style.marginLeft = '';
+        }
+        else {
+            slideEl.style.marginRight = '';
+        }
+        slideEl.style.marginBottom = '';
+        slideEl.style.marginTop = '';
+    });
+    // reset cssMode offsets
+    if (params.centeredSlides && params.cssMode) {
+        (0, utils_1.setCSSProperty)(wrapperEl, '--swiper-centered-offset-before', '');
+        (0, utils_1.setCSSProperty)(wrapperEl, '--swiper-centered-offset-after', '');
+    }
+    var gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
+    if (gridEnabled) {
+        swiper.grid.initSlides(slides);
+    }
+    else if (swiper.grid) {
+        swiper.grid.unsetSlides();
+    }
+    // Calc slides
+    var slideSize;
+    var shouldResetSlideSize = params.slidesPerView === 'auto' &&
+        params.breakpoints &&
+        Object.keys(params.breakpoints).filter(function (key) {
+            return typeof params.breakpoints[key].slidesPerView !== 'undefined';
+        }).length > 0;
+    for (var i = 0; i < slidesLength; i += 1) {
+        slideSize = 0;
+        var slide = void 0;
+        if (slides[i])
+            slide = slides[i];
+        if (gridEnabled) {
+            swiper.grid.updateSlide(i, slide, slides);
+        }
+        if (slides[i] && (0, utils_1.elementStyle)(slide, 'display') === 'none')
+            continue; // eslint-disable-line
+        if (params.slidesPerView === 'auto') {
+            if (shouldResetSlideSize) {
+                slides[i].style[swiper.getDirectionLabel('width')] = "";
+            }
+            var slideStyles = getComputedStyle(slide);
+            var currentTransform = slide.style.transform;
+            var currentWebKitTransform = slide.style.webkitTransform;
+            if (currentTransform) {
+                slide.style.transform = 'none';
+            }
+            if (currentWebKitTransform) {
+                slide.style.webkitTransform = 'none';
+            }
+            if (params.roundLengths) {
+                slideSize = swiper.isHorizontal()
+                    ? (0, utils_1.elementOuterSize)(slide, 'width', true)
+                    : (0, utils_1.elementOuterSize)(slide, 'height', true);
+            }
+            else {
+                // eslint-disable-next-line
+                var width = getDirectionPropertyValue(slideStyles, 'width');
+                var paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
+                var paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
+                var marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
+                var marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
+                var boxSizing = slideStyles.getPropertyValue('box-sizing');
+                if (boxSizing && boxSizing === 'border-box') {
+                    slideSize = width + marginLeft + marginRight;
+                }
+                else {
+                    var clientWidth = slide.clientWidth, offsetWidth = slide.offsetWidth;
+                    slideSize =
+                        width +
+                            paddingLeft +
+                            paddingRight +
+                            marginLeft +
+                            marginRight +
+                            (offsetWidth - clientWidth);
+                }
+            }
+            if (currentTransform) {
+                slide.style.transform = currentTransform;
+            }
+            if (currentWebKitTransform) {
+                slide.style.webkitTransform = currentWebKitTransform;
+            }
+            if (params.roundLengths)
+                slideSize = Math.floor(slideSize);
+        }
+        else {
+            slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
+            if (params.roundLengths)
+                slideSize = Math.floor(slideSize);
+            if (slides[i]) {
+                slides[i].style[swiper.getDirectionLabel('width')] = "".concat(slideSize, "px");
+            }
+        }
+        if (slides[i]) {
+            slides[i].swiperSlideSize = slideSize;
+        }
+        slidesSizesGrid.push(slideSize);
+        if (params.centeredSlides) {
+            slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
+            if (prevSlideSize === 0 && i !== 0)
+                slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
+            if (i === 0)
+                slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
+            if (Math.abs(slidePosition) < 1 / 1000)
+                slidePosition = 0;
+            if (params.roundLengths)
+                slidePosition = Math.floor(slidePosition);
+            if (index % params.slidesPerGroup === 0)
+                snapGrid.push(slidePosition);
+            slidesGrid.push(slidePosition);
+        }
+        else {
+            if (params.roundLengths)
+                slidePosition = Math.floor(slidePosition);
+            if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) %
+                swiper.params.slidesPerGroup ===
+                0)
+                snapGrid.push(slidePosition);
+            slidesGrid.push(slidePosition);
+            slidePosition = slidePosition + slideSize + spaceBetween;
+        }
+        swiper.virtualSize += slideSize + spaceBetween;
+        prevSlideSize = slideSize;
+        index += 1;
+    }
+    swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
+    if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
+        wrapperEl.style.width = "".concat(swiper.virtualSize + spaceBetween, "px");
+    }
+    if (params.setWrapperSize) {
+        wrapperEl.style[swiper.getDirectionLabel('width')] = "".concat(swiper.virtualSize + spaceBetween, "px");
+    }
+    if (gridEnabled) {
+        swiper.grid.updateWrapperSize(slideSize, snapGrid);
+    }
+    // Remove last grid elements depending on width
+    if (!params.centeredSlides) {
+        var newSlidesGrid = [];
+        for (var i = 0; i < snapGrid.length; i += 1) {
+            var slidesGridItem = snapGrid[i];
+            if (params.roundLengths)
+                slidesGridItem = Math.floor(slidesGridItem);
+            if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
+                newSlidesGrid.push(slidesGridItem);
+            }
+        }
+        snapGrid = newSlidesGrid;
+        if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) >
+            1) {
+            snapGrid.push(swiper.virtualSize - swiperSize);
+        }
+    }
+    if (isVirtual && params.loop) {
+        var size = slidesSizesGrid[0] + spaceBetween;
+        if (params.slidesPerGroup > 1) {
+            var groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);
+            var groupSize = size * params.slidesPerGroup;
+            for (var i = 0; i < groups; i += 1) {
+                snapGrid.push(snapGrid[snapGrid.length - 1] + groupSize);
+            }
+        }
+        for (var i = 0; i < swiper.virtual.slidesBefore + swiper.virtual.slidesAfter; i += 1) {
+            if (params.slidesPerGroup === 1) {
+                snapGrid.push(snapGrid[snapGrid.length - 1] + size);
+            }
+            slidesGrid.push(slidesGrid[slidesGrid.length - 1] + size);
+            swiper.virtualSize += size;
+        }
+    }
+    if (snapGrid.length === 0)
+        snapGrid = [0];
+    if (spaceBetween !== 0) {
+        var key_1 = swiper.isHorizontal() && rtl ? 'marginLeft' : swiper.getDirectionLabel('marginRight');
+        slides
+            .filter(function (_, slideIndex) {
+            if (!params.cssMode || params.loop)
+                return true;
+            if (slideIndex === slides.length - 1) {
+                return false;
+            }
+            return true;
+        })
+            .forEach(function (slideEl) {
+            slideEl.style[key_1] = "".concat(spaceBetween, "px");
+        });
+    }
+    if (params.centeredSlides && params.centeredSlidesBounds) {
+        var allSlidesSize_1 = 0;
+        slidesSizesGrid.forEach(function (slideSizeValue) {
+            allSlidesSize_1 += slideSizeValue + (spaceBetween || 0);
+        });
+        allSlidesSize_1 -= spaceBetween;
+        var maxSnap_1 = allSlidesSize_1 - swiperSize;
+        snapGrid = snapGrid.map(function (snap) {
+            if (snap <= 0)
+                return -offsetBefore;
+            if (snap > maxSnap_1)
+                return maxSnap_1 + offsetAfter;
+            return snap;
+        });
+    }
+    if (params.centerInsufficientSlides) {
+        var allSlidesSize_2 = 0;
+        slidesSizesGrid.forEach(function (slideSizeValue) {
+            allSlidesSize_2 += slideSizeValue + (spaceBetween || 0);
+        });
+        allSlidesSize_2 -= spaceBetween;
+        var offsetSize = (params.slidesOffsetBefore || 0) + (params.slidesOffsetAfter || 0);
+        if (allSlidesSize_2 + offsetSize < swiperSize) {
+            var allSlidesOffset_1 = (swiperSize - allSlidesSize_2 - offsetSize) / 2;
+            snapGrid.forEach(function (snap, snapIndex) {
+                snapGrid[snapIndex] = snap - allSlidesOffset_1;
+            });
+            slidesGrid.forEach(function (snap, snapIndex) {
+                slidesGrid[snapIndex] = snap + allSlidesOffset_1;
+            });
+        }
+    }
+    Object.assign(swiper, {
+        slides: slides,
+        snapGrid: snapGrid,
+        slidesGrid: slidesGrid,
+        slidesSizesGrid: slidesSizesGrid,
+    });
+    if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
+        (0, utils_1.setCSSProperty)(wrapperEl, '--swiper-centered-offset-before', "".concat(-snapGrid[0], "px"));
+        (0, utils_1.setCSSProperty)(wrapperEl, '--swiper-centered-offset-after', "".concat(swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2, "px"));
+        var addToSnapGrid_1 = -swiper.snapGrid[0];
+        var addToSlidesGrid_1 = -swiper.slidesGrid[0];
+        swiper.snapGrid = swiper.snapGrid.map(function (v) { return v + addToSnapGrid_1; });
+        swiper.slidesGrid = swiper.slidesGrid.map(function (v) { return v + addToSlidesGrid_1; });
+    }
+    if (slidesLength !== previousSlidesLength) {
+        swiper.emit('slidesLengthChange');
+    }
+    if (snapGrid.length !== previousSnapGridLength) {
+        if (swiper.params.watchOverflow)
+            swiper.checkOverflow();
+        swiper.emit('snapGridLengthChange');
+    }
+    if (slidesGrid.length !== previousSlidesGridLength) {
+        swiper.emit('slidesGridLengthChange');
+    }
+    if (params.watchSlidesProgress) {
+        swiper.updateSlidesOffset();
+    }
+    swiper.emit('slidesUpdated');
+    if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
+        var backFaceHiddenClass = "".concat(params.containerModifierClass, "backface-hidden");
+        var hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
+        if (slidesLength <= params.maxBackfaceHiddenSlides) {
+            if (!hasClassBackfaceClassAdded)
+                swiper.el.classList.add(backFaceHiddenClass);
+        }
+        else if (hasClassBackfaceClassAdded) {
+            swiper.el.classList.remove(backFaceHiddenClass);
+        }
+    }
+}
+exports.default = updateSlides;
+//# sourceMappingURL=updateSlides.js.map

package/dist/ui/components/carousel/carousel-lib/core/update/updateSlidesClasses.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//@ts-nocheck
+var utils_1 = require("../../shared/utils");
+var toggleSlideClasses = function (slideEl, condition, className) {
+    if (condition && !slideEl.classList.contains(className)) {
+        slideEl.classList.add(className);
+    }
+    else if (!condition && slideEl.classList.contains(className)) {
+        slideEl.classList.remove(className);
+    }
+};
+function updateSlidesClasses() {
+    var swiper = this;
+    var slides = swiper.slides, params = swiper.params, slidesEl = swiper.slidesEl, activeIndex = swiper.activeIndex;
+    var isVirtual = swiper.virtual && params.virtual.enabled;
+    var gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
+    var getFilteredSlide = function (selector) {
+        return (0, utils_1.elementChildren)(slidesEl, ".".concat(params.slideClass).concat(selector, ", swiper-slide").concat(selector))[0];
+    };
+    var activeSlide;
+    var prevSlide;
+    var nextSlide;
+    if (isVirtual) {
+        if (params.loop) {
+            var slideIndex = activeIndex - swiper.virtual.slidesBefore;
+            if (slideIndex < 0)
+                slideIndex = swiper.virtual.slides.length + slideIndex;
+            if (slideIndex >= swiper.virtual.slides.length)
+                slideIndex -= swiper.virtual.slides.length;
+            activeSlide = getFilteredSlide("[data-swiper-slide-index=\"".concat(slideIndex, "\"]"));
+        }
+        else {
+            activeSlide = getFilteredSlide("[data-swiper-slide-index=\"".concat(activeIndex, "\"]"));
+        }
+    }
+    else {
+        if (gridEnabled) {
+            activeSlide = slides.filter(function (slideEl) { return slideEl.column === activeIndex; })[0];
+            nextSlide = slides.filter(function (slideEl) { return slideEl.column === activeIndex + 1; })[0];
+            prevSlide = slides.filter(function (slideEl) { return slideEl.column === activeIndex - 1; })[0];
+        }
+        else {
+            activeSlide = slides[activeIndex];
+        }
+    }
+    if (activeSlide) {
+        if (!gridEnabled) {
+            // Next Slide
+            nextSlide = (0, utils_1.elementNextAll)(activeSlide, ".".concat(params.slideClass, ", swiper-slide"))[0];
+            if (params.loop && !nextSlide) {
+                nextSlide = slides[0];
+            }
+            // Prev Slide
+            prevSlide = (0, utils_1.elementPrevAll)(activeSlide, ".".concat(params.slideClass, ", swiper-slide"))[0];
+            if (params.loop && !prevSlide === 0) {
+                prevSlide = slides[slides.length - 1];
+            }
+        }
+    }
+    slides.forEach(function (slideEl) {
+        toggleSlideClasses(slideEl, slideEl === activeSlide, params.slideActiveClass);
+        toggleSlideClasses(slideEl, slideEl === nextSlide, params.slideNextClass);
+        toggleSlideClasses(slideEl, slideEl === prevSlide, params.slidePrevClass);
+    });
+    swiper.emitSlidesClasses();
+}
+exports.default = updateSlidesClasses;
+//# sourceMappingURL=updateSlidesClasses.js.map