infinity-forge 2.4.0 → 2.4.2

package/dist/ui/components/carousel/carousel-lib/core/events/index.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var onTouchStart_1 = __importDefault(require("./onTouchStart"));
+var onTouchMove_1 = __importDefault(require("./onTouchMove"));
+var onTouchEnd_1 = __importDefault(require("./onTouchEnd"));
+var onResize_1 = __importDefault(require("./onResize"));
+var onClick_1 = __importDefault(require("./onClick"));
+var onScroll_1 = __importDefault(require("./onScroll"));
+var onLoad_1 = __importDefault(require("./onLoad"));
+var onDocumentTouchStart_1 = __importDefault(require("./onDocumentTouchStart"));
+var document_1 = require("../../ssr-window/document");
+var events = function (swiper, method) {
+    var document = (0, document_1.getDocument)();
+    var params = swiper.params, el = swiper.el, wrapperEl = swiper.wrapperEl, device = swiper.device;
+    var capture = !!params.nested;
+    var domMethod = method === 'on' ? 'addEventListener' : 'removeEventListener';
+    var swiperMethod = method;
+    if (!el || typeof el === 'string')
+        return;
+    // Touch Events
+    document[domMethod]('touchstart', swiper.onDocumentTouchStart, { passive: false, capture: capture });
+    el[domMethod]('touchstart', swiper.onTouchStart, { passive: false });
+    el[domMethod]('pointerdown', swiper.onTouchStart, { passive: false });
+    document[domMethod]('touchmove', swiper.onTouchMove, { passive: false, capture: capture });
+    document[domMethod]('pointermove', swiper.onTouchMove, { passive: false, capture: capture });
+    document[domMethod]('touchend', swiper.onTouchEnd, { passive: true });
+    document[domMethod]('pointerup', swiper.onTouchEnd, { passive: true });
+    document[domMethod]('pointercancel', swiper.onTouchEnd, { passive: true });
+    document[domMethod]('touchcancel', swiper.onTouchEnd, { passive: true });
+    document[domMethod]('pointerout', swiper.onTouchEnd, { passive: true });
+    document[domMethod]('pointerleave', swiper.onTouchEnd, { passive: true });
+    document[domMethod]('contextmenu', swiper.onTouchEnd, { passive: true });
+    // Prevent Links Clicks
+    if (params.preventClicks || params.preventClicksPropagation) {
+        el[domMethod]('click', swiper.onClick, true);
+    }
+    if (params.cssMode) {
+        wrapperEl[domMethod]('scroll', swiper.onScroll);
+    }
+    // Resize handler
+    if (params.updateOnWindowResize) {
+        swiper[swiperMethod](device.ios || device.android
+            ? 'resize orientationchange observerUpdate'
+            : 'resize observerUpdate', onResize_1.default, true);
+    }
+    else {
+        swiper[swiperMethod]('observerUpdate', onResize_1.default, true);
+    }
+    // Images loader
+    el[domMethod]('load', swiper.onLoad, { capture: true });
+};
+function attachEvents() {
+    var swiper = this;
+    var params = swiper.params;
+    swiper.onTouchStart = onTouchStart_1.default.bind(swiper);
+    swiper.onTouchMove = onTouchMove_1.default.bind(swiper);
+    swiper.onTouchEnd = onTouchEnd_1.default.bind(swiper);
+    swiper.onDocumentTouchStart = onDocumentTouchStart_1.default.bind(swiper);
+    if (params.cssMode) {
+        swiper.onScroll = onScroll_1.default.bind(swiper);
+    }
+    swiper.onClick = onClick_1.default.bind(swiper);
+    swiper.onLoad = onLoad_1.default.bind(swiper);
+    events(swiper, 'on');
+}
+function detachEvents() {
+    var swiper = this;
+    events(swiper, 'off');
+}
+exports.default = {
+    attachEvents: attachEvents,
+    detachEvents: detachEvents,
+};
+//# sourceMappingURL=index.js.map

package/dist/ui/components/carousel/carousel-lib/core/events/onLoad.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var process_lazy_preloader_1 = require("../../shared/process-lazy-preloader");
+function onLoad(e) {
+    var swiper = this;
+    (0, process_lazy_preloader_1.processLazyPreloader)(swiper, e.target);
+    if (swiper.params.cssMode ||
+        (swiper.params.slidesPerView !== 'auto' && !swiper.params.autoHeight)) {
+        return;
+    }
+    swiper.update();
+}
+exports.default = onLoad;
+//# sourceMappingURL=onLoad.js.map

package/dist/ui/components/carousel/carousel-lib/core/events/onTouchEnd.js

@@ -0,0 +1,194 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../shared/utils");
+function onTouchEnd(event) {
+    var swiper = this;
+    var data = swiper.touchEventsData;
+    var e = event;
+    if (e.originalEvent)
+        e = e.originalEvent;
+    var targetTouch;
+    var isTouchEvent = e.type === 'touchend' || e.type === 'touchcancel';
+    if (!isTouchEvent) {
+        if (data.touchId !== null)
+            return; // return from pointer if we use touch
+        if (e.pointerId !== data.pointerId)
+            return;
+        targetTouch = e;
+    }
+    else {
+        targetTouch = __spreadArray([], e.changedTouches, true).filter(function (t) { return t.identifier === data.touchId; })[0];
+        if (!targetTouch || targetTouch.identifier !== data.touchId)
+            return;
+    }
+    if (['pointercancel', 'pointerout', 'pointerleave', 'contextmenu'].includes(e.type)) {
+        var proceed = ['pointercancel', 'contextmenu'].includes(e.type) &&
+            (swiper.browser.isSafari || swiper.browser.isWebView);
+        if (!proceed) {
+            return;
+        }
+    }
+    data.pointerId = null;
+    data.touchId = null;
+    var params = swiper.params, touches = swiper.touches, rtl = swiper.rtlTranslate, slidesGrid = swiper.slidesGrid, enabled = swiper.enabled;
+    if (!enabled)
+        return;
+    if (!params.simulateTouch && e.pointerType === 'mouse')
+        return;
+    if (data.allowTouchCallbacks) {
+        swiper.emit('touchEnd', e);
+    }
+    data.allowTouchCallbacks = false;
+    if (!data.isTouched) {
+        if (data.isMoved && params.grabCursor) {
+            swiper.setGrabCursor(false);
+        }
+        data.isMoved = false;
+        data.startMoving = false;
+        return;
+    }
+    // Return Grab Cursor
+    if (params.grabCursor &&
+        data.isMoved &&
+        data.isTouched &&
+        (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
+        swiper.setGrabCursor(false);
+    }
+    // Time diff
+    var touchEndTime = (0, utils_1.now)();
+    var timeDiff = touchEndTime - data.touchStartTime;
+    // Tap, doubleTap, Click
+    if (swiper.allowClick) {
+        var pathTree = e.path || (e.composedPath && e.composedPath());
+        swiper.updateClickedSlide((pathTree && pathTree[0]) || e.target, pathTree);
+        swiper.emit('tap click', e);
+        if (timeDiff < 300 && touchEndTime - data.lastClickTime < 300) {
+            swiper.emit('doubleTap doubleClick', e);
+        }
+    }
+    data.lastClickTime = (0, utils_1.now)();
+    (0, utils_1.nextTick)(function () {
+        if (!swiper.destroyed)
+            swiper.allowClick = true;
+    });
+    if (!data.isTouched ||
+        !data.isMoved ||
+        !swiper.swipeDirection ||
+        (touches.diff === 0 && !data.loopSwapReset) ||
+        (data.currentTranslate === data.startTranslate && !data.loopSwapReset)) {
+        data.isTouched = false;
+        data.isMoved = false;
+        data.startMoving = false;
+        return;
+    }
+    data.isTouched = false;
+    data.isMoved = false;
+    data.startMoving = false;
+    var currentPos;
+    if (params.followFinger) {
+        currentPos = rtl ? swiper.translate : -swiper.translate;
+    }
+    else {
+        currentPos = -data.currentTranslate;
+    }
+    if (params.cssMode) {
+        return;
+    }
+    if (params.freeMode && params.freeMode.enabled) {
+        swiper.freeMode.onTouchEnd({ currentPos: currentPos });
+        return;
+    }
+    // Find current slide
+    var swipeToLast = currentPos >= -swiper.maxTranslate() && !swiper.params.loop;
+    var stopIndex = 0;
+    var groupSize = swiper.slidesSizesGrid[0];
+    for (var i = 0; i < slidesGrid.length; i += i < params.slidesPerGroupSkip ? 1 : params.slidesPerGroup) {
+        var increment_1 = i < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;
+        if (typeof slidesGrid[i + increment_1] !== 'undefined') {
+            if (swipeToLast || (currentPos >= slidesGrid[i] && currentPos < slidesGrid[i + increment_1])) {
+                stopIndex = i;
+                groupSize = slidesGrid[i + increment_1] - slidesGrid[i];
+            }
+        }
+        else if (swipeToLast || currentPos >= slidesGrid[i]) {
+            stopIndex = i;
+            groupSize = slidesGrid[slidesGrid.length - 1] - slidesGrid[slidesGrid.length - 2];
+        }
+    }
+    var rewindFirstIndex = null;
+    var rewindLastIndex = null;
+    if (params.rewind) {
+        if (swiper.isBeginning) {
+            rewindLastIndex =
+                params.virtual && params.virtual.enabled && swiper.virtual
+                    ? swiper.virtual.slides.length - 1
+                    : swiper.slides.length - 1;
+        }
+        else if (swiper.isEnd) {
+            rewindFirstIndex = 0;
+        }
+    }
+    // Find current slide size
+    var ratio = (currentPos - slidesGrid[stopIndex]) / groupSize;
+    var increment = stopIndex < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;
+    if (timeDiff > params.longSwipesMs) {
+        // Long touches
+        if (!params.longSwipes) {
+            swiper.slideTo(swiper.activeIndex);
+            return;
+        }
+        if (swiper.swipeDirection === 'next') {
+            if (ratio >= params.longSwipesRatio)
+                swiper.slideTo(params.rewind && swiper.isEnd ? rewindFirstIndex : stopIndex + increment);
+            else
+                swiper.slideTo(stopIndex);
+        }
+        if (swiper.swipeDirection === 'prev') {
+            if (ratio > 1 - params.longSwipesRatio) {
+                swiper.slideTo(stopIndex + increment);
+            }
+            else if (rewindLastIndex !== null &&
+                ratio < 0 &&
+                Math.abs(ratio) > params.longSwipesRatio) {
+                swiper.slideTo(rewindLastIndex);
+            }
+            else {
+                swiper.slideTo(stopIndex);
+            }
+        }
+    }
+    else {
+        // Short swipes
+        if (!params.shortSwipes) {
+            swiper.slideTo(swiper.activeIndex);
+            return;
+        }
+        var isNavButtonTarget = swiper.navigation &&
+            (e.target === swiper.navigation.nextEl || e.target === swiper.navigation.prevEl);
+        if (!isNavButtonTarget) {
+            if (swiper.swipeDirection === 'next') {
+                swiper.slideTo(rewindFirstIndex !== null ? rewindFirstIndex : stopIndex + increment);
+            }
+            if (swiper.swipeDirection === 'prev') {
+                swiper.slideTo(rewindLastIndex !== null ? rewindLastIndex : stopIndex);
+            }
+        }
+        else if (e.target === swiper.navigation.nextEl) {
+            swiper.slideTo(stopIndex + increment);
+        }
+        else {
+            swiper.slideTo(stopIndex);
+        }
+    }
+}
+exports.default = onTouchEnd;
+//# sourceMappingURL=onTouchEnd.js.map

package/dist/ui/components/carousel/carousel-lib/core/events/onTouchMove.js

@@ -0,0 +1,314 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+//@ts-nocheck
+var utils_1 = require("../../shared/utils");
+var document_1 = require("../../ssr-window/document");
+function onTouchMove(event) {
+    var document = (0, document_1.getDocument)();
+    var swiper = this;
+    var data = swiper.touchEventsData;
+    var params = swiper.params, touches = swiper.touches, rtl = swiper.rtlTranslate, enabled = swiper.enabled;
+    if (!enabled)
+        return;
+    if (!params.simulateTouch && event.pointerType === 'mouse')
+        return;
+    var e = event;
+    if (e.originalEvent)
+        e = e.originalEvent;
+    if (e.type === 'pointermove') {
+        if (data.touchId !== null)
+            return; // return from pointer if we use touch
+        var id = e.pointerId;
+        if (id !== data.pointerId)
+            return;
+    }
+    var targetTouch;
+    if (e.type === 'touchmove') {
+        targetTouch = __spreadArray([], e.changedTouches, true).filter(function (t) { return t.identifier === data.touchId; })[0];
+        if (!targetTouch || targetTouch.identifier !== data.touchId)
+            return;
+    }
+    else {
+        targetTouch = e;
+    }
+    if (!data.isTouched) {
+        if (data.startMoving && data.isScrolling) {
+            swiper.emit('touchMoveOpposite', e);
+        }
+        return;
+    }
+    var pageX = targetTouch.pageX;
+    var pageY = targetTouch.pageY;
+    if (e.preventedByNestedSwiper) {
+        touches.startX = pageX;
+        touches.startY = pageY;
+        return;
+    }
+    if (!swiper.allowTouchMove) {
+        if (!e.target.matches(data.focusableElements)) {
+            swiper.allowClick = false;
+        }
+        if (data.isTouched) {
+            Object.assign(touches, {
+                startX: pageX,
+                startY: pageY,
+                currentX: pageX,
+                currentY: pageY,
+            });
+            data.touchStartTime = (0, utils_1.now)();
+        }
+        return;
+    }
+    if (params.touchReleaseOnEdges && !params.loop) {
+        if (swiper.isVertical()) {
+            // Vertical
+            if ((pageY < touches.startY && swiper.translate <= swiper.maxTranslate()) ||
+                (pageY > touches.startY && swiper.translate >= swiper.minTranslate())) {
+                data.isTouched = false;
+                data.isMoved = false;
+                return;
+            }
+        }
+        else if ((pageX < touches.startX && swiper.translate <= swiper.maxTranslate()) ||
+            (pageX > touches.startX && swiper.translate >= swiper.minTranslate())) {
+            return;
+        }
+    }
+    if (document.activeElement) {
+        if (e.target === document.activeElement && e.target.matches(data.focusableElements)) {
+            data.isMoved = true;
+            swiper.allowClick = false;
+            return;
+        }
+    }
+    if (data.allowTouchCallbacks) {
+        swiper.emit('touchMove', e);
+    }
+    touches.previousX = touches.currentX;
+    touches.previousY = touches.currentY;
+    touches.currentX = pageX;
+    touches.currentY = pageY;
+    var diffX = touches.currentX - touches.startX;
+    var diffY = touches.currentY - touches.startY;
+    if (swiper.params.threshold && Math.sqrt(Math.pow(diffX, 2) + Math.pow(diffY, 2)) < swiper.params.threshold)
+        return;
+    if (typeof data.isScrolling === 'undefined') {
+        var touchAngle = void 0;
+        if ((swiper.isHorizontal() && touches.currentY === touches.startY) ||
+            (swiper.isVertical() && touches.currentX === touches.startX)) {
+            data.isScrolling = false;
+        }
+        else {
+            // eslint-disable-next-line
+            if (diffX * diffX + diffY * diffY >= 25) {
+                touchAngle = (Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180) / Math.PI;
+                data.isScrolling = swiper.isHorizontal()
+                    ? touchAngle > params.touchAngle
+                    : 90 - touchAngle > params.touchAngle;
+            }
+        }
+    }
+    if (data.isScrolling) {
+        swiper.emit('touchMoveOpposite', e);
+    }
+    if (typeof data.startMoving === 'undefined') {
+        if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {
+            data.startMoving = true;
+        }
+    }
+    if (data.isScrolling || (e.type === 'touchmove' && data.preventTouchMoveFromPointerMove)) {
+        data.isTouched = false;
+        return;
+    }
+    if (!data.startMoving) {
+        return;
+    }
+    swiper.allowClick = false;
+    if (!params.cssMode && e.cancelable) {
+        e.preventDefault();
+    }
+    if (params.touchMoveStopPropagation && !params.nested) {
+        e.stopPropagation();
+    }
+    var diff = swiper.isHorizontal() ? diffX : diffY;
+    var touchesDiff = swiper.isHorizontal()
+        ? touches.currentX - touches.previousX
+        : touches.currentY - touches.previousY;
+    if (params.oneWayMovement) {
+        diff = Math.abs(diff) * (rtl ? 1 : -1);
+        touchesDiff = Math.abs(touchesDiff) * (rtl ? 1 : -1);
+    }
+    touches.diff = diff;
+    diff *= params.touchRatio;
+    if (rtl) {
+        diff = -diff;
+        touchesDiff = -touchesDiff;
+    }
+    var prevTouchesDirection = swiper.touchesDirection;
+    swiper.swipeDirection = diff > 0 ? 'prev' : 'next';
+    swiper.touchesDirection = touchesDiff > 0 ? 'prev' : 'next';
+    var isLoop = swiper.params.loop && !params.cssMode;
+    var allowLoopFix = (swiper.touchesDirection === 'next' && swiper.allowSlideNext) ||
+        (swiper.touchesDirection === 'prev' && swiper.allowSlidePrev);
+    if (!data.isMoved) {
+        if (isLoop && allowLoopFix) {
+            swiper.loopFix({ direction: swiper.swipeDirection });
+        }
+        data.startTranslate = swiper.getTranslate();
+        swiper.setTransition(0);
+        if (swiper.animating) {
+            var evt = new window.CustomEvent('transitionend', {
+                bubbles: true,
+                cancelable: true,
+                detail: {
+                    bySwiperTouchMove: true,
+                },
+            });
+            swiper.wrapperEl.dispatchEvent(evt);
+        }
+        data.allowMomentumBounce = false;
+        // Grab Cursor
+        if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
+            swiper.setGrabCursor(true);
+        }
+        swiper.emit('sliderFirstMove', e);
+    }
+    var loopFixed;
+    var time = new Date().getTime();
+    if (data.isMoved &&
+        data.allowThresholdMove &&
+        prevTouchesDirection !== swiper.touchesDirection &&
+        isLoop &&
+        allowLoopFix &&
+        Math.abs(diff) >= 1) {
+        Object.assign(touches, {
+            startX: pageX,
+            startY: pageY,
+            currentX: pageX,
+            currentY: pageY,
+            startTranslate: data.currentTranslate,
+        });
+        data.loopSwapReset = true;
+        data.startTranslate = data.currentTranslate;
+        return;
+    }
+    swiper.emit('sliderMove', e);
+    data.isMoved = true;
+    data.currentTranslate = diff + data.startTranslate;
+    var disableParentSwiper = true;
+    var resistanceRatio = params.resistanceRatio;
+    if (params.touchReleaseOnEdges) {
+        resistanceRatio = 0;
+    }
+    if (diff > 0) {
+        if (isLoop &&
+            allowLoopFix &&
+            !loopFixed &&
+            data.allowThresholdMove &&
+            data.currentTranslate >
+                (params.centeredSlides
+                    ? swiper.minTranslate() - swiper.slidesSizesGrid[swiper.activeIndex + 1]
+                    : swiper.minTranslate())) {
+            swiper.loopFix({ direction: 'prev', setTranslate: true, activeSlideIndex: 0 });
+        }
+        if (data.currentTranslate > swiper.minTranslate()) {
+            disableParentSwiper = false;
+            if (params.resistance) {
+                data.currentTranslate =
+                    swiper.minTranslate() -
+                        1 +
+                        Math.pow((-swiper.minTranslate() + data.startTranslate + diff), resistanceRatio);
+            }
+        }
+    }
+    else if (diff < 0) {
+        if (isLoop &&
+            allowLoopFix &&
+            !loopFixed &&
+            data.allowThresholdMove &&
+            data.currentTranslate <
+                (params.centeredSlides
+                    ? swiper.maxTranslate() + swiper.slidesSizesGrid[swiper.slidesSizesGrid.length - 1]
+                    : swiper.maxTranslate())) {
+            swiper.loopFix({
+                direction: 'next',
+                setTranslate: true,
+                activeSlideIndex: swiper.slides.length -
+                    (params.slidesPerView === 'auto'
+                        ? swiper.slidesPerViewDynamic()
+                        : Math.ceil(parseFloat(params.slidesPerView, 10))),
+            });
+        }
+        if (data.currentTranslate < swiper.maxTranslate()) {
+            disableParentSwiper = false;
+            if (params.resistance) {
+                data.currentTranslate =
+                    swiper.maxTranslate() +
+                        1 -
+                        Math.pow((swiper.maxTranslate() - data.startTranslate - diff), resistanceRatio);
+            }
+        }
+    }
+    if (disableParentSwiper) {
+        e.preventedByNestedSwiper = true;
+    }
+    // Directions locks
+    if (!swiper.allowSlideNext &&
+        swiper.swipeDirection === 'next' &&
+        data.currentTranslate < data.startTranslate) {
+        data.currentTranslate = data.startTranslate;
+    }
+    if (!swiper.allowSlidePrev &&
+        swiper.swipeDirection === 'prev' &&
+        data.currentTranslate > data.startTranslate) {
+        data.currentTranslate = data.startTranslate;
+    }
+    if (!swiper.allowSlidePrev && !swiper.allowSlideNext) {
+        data.currentTranslate = data.startTranslate;
+    }
+    // Threshold
+    if (params.threshold > 0) {
+        if (Math.abs(diff) > params.threshold || data.allowThresholdMove) {
+            if (!data.allowThresholdMove) {
+                data.allowThresholdMove = true;
+                touches.startX = touches.currentX;
+                touches.startY = touches.currentY;
+                data.currentTranslate = data.startTranslate;
+                touches.diff = swiper.isHorizontal()
+                    ? touches.currentX - touches.startX
+                    : touches.currentY - touches.startY;
+                return;
+            }
+        }
+        else {
+            data.currentTranslate = data.startTranslate;
+            return;
+        }
+    }
+    if (!params.followFinger || params.cssMode)
+        return;
+    // Update active index in free mode
+    if ((params.freeMode && params.freeMode.enabled && swiper.freeMode) ||
+        params.watchSlidesProgress) {
+        swiper.updateActiveIndex();
+        swiper.updateSlidesClasses();
+    }
+    if (params.freeMode && params.freeMode.enabled && swiper.freeMode) {
+        swiper.freeMode.onTouchMove();
+    }
+    // Update progress
+    swiper.updateProgress(data.currentTranslate);
+    // Update translate
+    swiper.setTranslate(data.currentTranslate);
+}
+exports.default = onTouchMove;
+//# sourceMappingURL=onTouchMove.js.map