infinity-forge 2.4.0 → 2.4.1

package/dist/system/presentation/hooks/ui/use-table/components/table/index.js

@@ -38,16 +38,16 @@ exports.Table = void 0;
 var jsx_runtime_1 = require("react/jsx-runtime");
 var react_1 = require("react");
 var router_1 = require("next/router");
-var ui_1 = require("../../../../../../../ui");
-var export_1 = require("./export");
-var actions_1 = require("./actions");
-var filters_1 = require("./filters");
-var create_1 = require("./create");
-var thead_item_1 = require("./thead-item");
-var pagination_1 = require("./pagination");
-var skeleton_table_1 = require("./skeleton-table");
-var active_filters_1 = require("./active-filters");
-var S = __importStar(require("./styles"));
+var ui_1 = require("../../../../../../../ui/index.js");
+var export_1 = require("./export/index.js");
+var actions_1 = require("./actions/index.js");
+var filters_1 = require("./filters/index.js");
+var create_1 = require("./create/index.js");
+var thead_item_1 = require("./thead-item/index.js");
+var pagination_1 = require("./pagination/index.js");
+var skeleton_table_1 = require("./skeleton-table/index.js");
+var active_filters_1 = require("./active-filters/index.js");
+var S = __importStar(require("./styles.js"));
 function Table(props) {
     var _a, _b, _c, _d;
     var configs = props.configs, isFetching = props.isFetching, columnsConfiguration = props.columnsConfiguration, tableInformations = props.tableInformations;

package/dist/system/presentation/hooks/ui/use-table/components/table/interfaces.d.ts

@@ -1,5 +1,5 @@
-import { List, Pagination, TableConfiguration } from '../../../../../../../system';
-import { IUseTableProps } from '../../interfaces';
+import { List, Pagination, TableConfiguration } from '../../../../../../../system/index.js';
+import { IUseTableProps } from '../../interfaces.js';
 type colunm = keyof any;
 interface IShowHiden {
     text: string;

package/dist/system/presentation/hooks/ui/use-table/query/get-query-arguments-table.d.ts

@@ -0,0 +1,2 @@
+import { QueryTable } from '../interfaces.js';
+export declare function useGetQueryArgumentsTable(props: QueryTable): QueryTable;

package/dist/system/presentation/hooks/ui/use-table/query/hook.d.ts

@@ -0,0 +1,5 @@
+import { QueryTable } from '../interfaces.js';
+export declare function useQueryTable(props: QueryTable): {
+    data: any;
+    isLoading: boolean;
+};

package/dist/system/presentation/hooks/ui/use-table/query/hook.js

@@ -0,0 +1,52 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useQueryTable = void 0;
+var router_1 = require("next/router");
+var ui_1 = require("../../../../../../ui/index.js");
+function useQueryTable(props) {
+    var _a;
+    var _b = (0, router_1.useRouter)(), query = _b.query, isReady = _b.isReady;
+    var queryKEY = props.queryKey.customKey || props.queryKey.remoteName;
+    var enabled = props.requireUser ? props.user : true;
+    var REMOTE = props.container && ((_a = props.container) === null || _a === void 0 ? void 0 : _a.get(props.Types[queryKEY]));
+    var queryFiltersBase64 = (0, ui_1.fromBase64ToString)(query.filters);
+    var params = __assign(__assign({}, query), { orderColumn: undefined, asc: undefined, order: query.orderColumn && { column: query.orderColumn, asc: !!(query.asc === 'true') }, filters: queryFiltersBase64.filters });
+    var tableResponse = (0, ui_1.useQuery)(__assign(__assign({ queryKey: props.queryKeyParams || queryKEY, queryFn: function () { return props.customRemote ? props.customRemote(params) : REMOTE.loadAll(params); } }, props.options), { enabled: !!((REMOTE || queryKEY) && isReady) }));
+    var configurations = (0, ui_1.useQuery)({
+        queryFn: function () { return REMOTE.loadTable(); },
+        queryKey: "".concat(queryKEY, "/Table"),
+        enableCache: true,
+        enabled: !!(REMOTE && props.dynamicFiltersFromApi && isReady)
+    });
+    if (props.debugMode) {
+        console.log({
+            enabled: enabled,
+            REMOTE: REMOTE,
+            KEY_TABLE: queryKEY,
+            queryFiltersBase64: queryFiltersBase64,
+            params: params,
+            data: tableResponse.data,
+            isLoading: tableResponse.isLoading,
+            error: tableResponse.error,
+            loadAll: REMOTE.loadAll,
+            configurations: configurations,
+        });
+    }
+    return {
+        data: __assign(__assign({}, tableResponse.data), configurations === null || configurations === void 0 ? void 0 : configurations.data),
+        isLoading: (configurations === null || configurations === void 0 ? void 0 : configurations.isLoading) || tableResponse.isLoading || tableResponse.isFetching,
+    };
+}
+exports.useQueryTable = useQueryTable;
+//# sourceMappingURL=hook.js.map

package/dist/system/presentation/hooks/ui/use-table/query/index.d.ts

@@ -0,0 +1,2 @@
+export * from './hook.js';
+export * from './get-query-arguments-table.js';

package/dist/system/presentation/hooks/ui/use-table/query/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hook.js"), exports);
+__exportStar(require("./get-query-arguments-table.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/ui/components/carousel/carousel-lib/core/breakpoints/getBreakpoint.js

@@ -0,0 +1,35 @@
+"use strict";
+//@ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+var window_1 = require("../../ssr-window/window.js");
+function getBreakpoint(breakpoints, base, containerEl) {
+    if (base === void 0) { base = 'window'; }
+    if (!breakpoints || (base === 'container' && !containerEl))
+        return undefined;
+    var breakpoint = false;
+    var window = (0, window_1.getWindow)();
+    var currentHeight = base === 'window' ? window.innerHeight : containerEl.clientHeight;
+    var points = Object.keys(breakpoints).map(function (point) {
+        if (typeof point === 'string' && point.indexOf('@') === 0) {
+            var minRatio = parseFloat(point.substr(1));
+            var value = currentHeight * minRatio;
+            return { value: value, point: point };
+        }
+        return { value: point, point: point };
+    });
+    points.sort(function (a, b) { return parseInt(a.value, 10) - parseInt(b.value, 10); });
+    for (var i = 0; i < points.length; i += 1) {
+        var _a = points[i], point = _a.point, value = _a.value;
+        if (base === 'window') {
+            if (window.matchMedia("(min-width: ".concat(value, "px)")).matches) {
+                breakpoint = point;
+            }
+        }
+        else if (value <= containerEl.clientWidth) {
+            breakpoint = point;
+        }
+    }
+    return breakpoint || 'max';
+}
+exports.default = getBreakpoint;
+//# sourceMappingURL=getBreakpoint.js.map

package/dist/ui/components/carousel/carousel-lib/core/breakpoints/index.d.ts

@@ -0,0 +1,7 @@
+import setBreakpoint from './setBreakpoint.js';
+import getBreakpoint from './getBreakpoint.js';
+declare const _default: {
+    setBreakpoint: typeof setBreakpoint;
+    getBreakpoint: typeof getBreakpoint;
+};
+export default _default;

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

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var setBreakpoint_1 = __importDefault(require("./setBreakpoint.js"));
+var getBreakpoint_1 = __importDefault(require("./getBreakpoint.js"));
+exports.default = { setBreakpoint: setBreakpoint_1.default, getBreakpoint: getBreakpoint_1.default };
+//# sourceMappingURL=index.js.map

package/dist/ui/components/carousel/carousel-lib/core/breakpoints/setBreakpoint.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../shared/utils.js");
+var isGridEnabled = function (swiper, params) {
+    return swiper.grid && params.grid && params.grid.rows > 1;
+};
+function setBreakpoint() {
+    var swiper = this;
+    var realIndex = swiper.realIndex, initialized = swiper.initialized, params = swiper.params, el = swiper.el;
+    var breakpoints = params.breakpoints;
+    if (!breakpoints || (breakpoints && Object.keys(breakpoints).length === 0))
+        return;
+    // Get breakpoint for window width and update parameters
+    var breakpoint = swiper.getBreakpoint(breakpoints, swiper.params.breakpointsBase, swiper.el);
+    if (!breakpoint || swiper.currentBreakpoint === breakpoint)
+        return;
+    var breakpointOnlyParams = breakpoint in breakpoints ? breakpoints[breakpoint] : undefined;
+    var breakpointParams = breakpointOnlyParams || swiper.originalParams;
+    var wasMultiRow = isGridEnabled(swiper, params);
+    var isMultiRow = isGridEnabled(swiper, breakpointParams);
+    var wasGrabCursor = swiper.params.grabCursor;
+    var isGrabCursor = breakpointParams.grabCursor;
+    var wasEnabled = params.enabled;
+    if (wasMultiRow && !isMultiRow) {
+        el.classList.remove("".concat(params.containerModifierClass, "grid"), "".concat(params.containerModifierClass, "grid-column"));
+        swiper.emitContainerClasses();
+    }
+    else if (!wasMultiRow && isMultiRow) {
+        el.classList.add("".concat(params.containerModifierClass, "grid"));
+        if ((breakpointParams.grid.fill && breakpointParams.grid.fill === 'column') ||
+            (!breakpointParams.grid.fill && params.grid.fill === 'column')) {
+            el.classList.add("".concat(params.containerModifierClass, "grid-column"));
+        }
+        swiper.emitContainerClasses();
+    }
+    if (wasGrabCursor && !isGrabCursor) {
+        swiper.unsetGrabCursor();
+    }
+    else if (!wasGrabCursor && isGrabCursor) {
+        swiper.setGrabCursor();
+    }
+    // Toggle navigation, pagination, scrollbar
+    ['navigation', 'pagination', 'scrollbar'].forEach(function (prop) {
+        if (typeof breakpointParams[prop] === 'undefined')
+            return;
+        var wasModuleEnabled = params[prop] && params[prop].enabled;
+        var isModuleEnabled = breakpointParams[prop] && breakpointParams[prop].enabled;
+        if (wasModuleEnabled && !isModuleEnabled) {
+            swiper[prop].disable();
+        }
+        if (!wasModuleEnabled && isModuleEnabled) {
+            swiper[prop].enable();
+        }
+    });
+    var directionChanged = breakpointParams.direction && breakpointParams.direction !== params.direction;
+    var needsReLoop = params.loop && (breakpointParams.slidesPerView !== params.slidesPerView || directionChanged);
+    var wasLoop = params.loop;
+    if (directionChanged && initialized) {
+        swiper.changeDirection();
+    }
+    (0, utils_1.extend)(swiper.params, breakpointParams);
+    var isEnabled = swiper.params.enabled;
+    var hasLoop = swiper.params.loop;
+    Object.assign(swiper, {
+        allowTouchMove: swiper.params.allowTouchMove,
+        allowSlideNext: swiper.params.allowSlideNext,
+        allowSlidePrev: swiper.params.allowSlidePrev,
+    });
+    if (wasEnabled && !isEnabled) {
+        swiper.disable();
+    }
+    else if (!wasEnabled && isEnabled) {
+        swiper.enable();
+    }
+    swiper.currentBreakpoint = breakpoint;
+    swiper.emit('_beforeBreakpoint', breakpointParams);
+    if (initialized) {
+        if (needsReLoop) {
+            swiper.loopDestroy();
+            swiper.loopCreate(realIndex);
+            swiper.updateSlides();
+        }
+        else if (!wasLoop && hasLoop) {
+            swiper.loopCreate(realIndex);
+            swiper.updateSlides();
+        }
+        else if (wasLoop && !hasLoop) {
+            swiper.loopDestroy();
+        }
+    }
+    swiper.emit('breakpoint', breakpointParams);
+}
+exports.default = setBreakpoint;
+//# sourceMappingURL=setBreakpoint.js.map

package/dist/ui/components/carousel/carousel-lib/core/classes/index.d.ts

@@ -0,0 +1,7 @@
+import addClasses from './addClasses.js';
+import removeClasses from './removeClasses.js';
+declare const _default: {
+    addClasses: typeof addClasses;
+    removeClasses: typeof removeClasses;
+};
+export default _default;

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

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var addClasses_1 = __importDefault(require("./addClasses.js"));
+var removeClasses_1 = __importDefault(require("./removeClasses.js"));
+exports.default = { addClasses: addClasses_1.default, removeClasses: removeClasses_1.default };
+//# sourceMappingURL=index.js.map

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.js"));
+var onTouchMove_1 = __importDefault(require("./onTouchMove.js"));
+var onTouchEnd_1 = __importDefault(require("./onTouchEnd.js"));
+var onResize_1 = __importDefault(require("./onResize.js"));
+var onClick_1 = __importDefault(require("./onClick.js"));
+var onScroll_1 = __importDefault(require("./onScroll.js"));
+var onLoad_1 = __importDefault(require("./onLoad.js"));
+var onDocumentTouchStart_1 = __importDefault(require("./onDocumentTouchStart.js"));
+var document_1 = require("../../ssr-window/document.js");
+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.js");
+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.js");
+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