infinity-forge 2.4.2 → 2.4.3

package/dist/ui/components/carousel/carousel-lib/modules/virtual.js

@@ -0,0 +1,379 @@
+"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 });
+exports.Virtual = void 0;
+var utils_1 = require("../shared/utils.js");
+var document_1 = require("../ssr-window/document.js");
+function Virtual(_a) {
+    var swiper = _a.swiper, extendParams = _a.extendParams, on = _a.on, emit = _a.emit;
+    extendParams({
+        virtual: {
+            enabled: false,
+            slides: [],
+            cache: true,
+            renderSlide: null,
+            renderExternal: null,
+            renderExternalUpdate: true,
+            addSlidesBefore: 0,
+            addSlidesAfter: 0,
+        },
+    });
+    var cssModeTimeout;
+    var document = (0, document_1.getDocument)();
+    swiper.virtual = {
+        cache: {},
+        from: undefined,
+        to: undefined,
+        slides: [],
+        offset: 0,
+        slidesGrid: [],
+    };
+    var tempDOM = document.createElement('div');
+    function renderSlide(slide, index) {
+        var params = swiper.params.virtual;
+        if (params.cache && swiper.virtual.cache[index]) {
+            return swiper.virtual.cache[index];
+        }
+        // eslint-disable-next-line
+        var slideEl;
+        if (params.renderSlide) {
+            slideEl = params.renderSlide.call(swiper, slide, index);
+            if (typeof slideEl === 'string') {
+                tempDOM.innerHTML = slideEl;
+                slideEl = tempDOM.children[0];
+            }
+        }
+        else if (swiper.isElement) {
+            slideEl = (0, utils_1.createElement)('swiper-slide');
+        }
+        else {
+            slideEl = (0, utils_1.createElement)('div', swiper.params.slideClass);
+        }
+        slideEl.setAttribute('data-swiper-slide-index', index);
+        if (!params.renderSlide) {
+            slideEl.innerHTML = slide;
+        }
+        if (params.cache) {
+            swiper.virtual.cache[index] = slideEl;
+        }
+        return slideEl;
+    }
+    function update(force, beforeInit) {
+        var _a = swiper.params, slidesPerView = _a.slidesPerView, slidesPerGroup = _a.slidesPerGroup, centeredSlides = _a.centeredSlides, isLoop = _a.loop, initialSlide = _a.initialSlide;
+        if (beforeInit && !isLoop && initialSlide > 0) {
+            return;
+        }
+        var _b = swiper.params.virtual, addSlidesBefore = _b.addSlidesBefore, addSlidesAfter = _b.addSlidesAfter;
+        var _c = swiper.virtual, previousFrom = _c.from, previousTo = _c.to, slides = _c.slides, previousSlidesGrid = _c.slidesGrid, previousOffset = _c.offset;
+        if (!swiper.params.cssMode) {
+            swiper.updateActiveIndex();
+        }
+        var activeIndex = swiper.activeIndex || 0;
+        var offsetProp;
+        if (swiper.rtlTranslate)
+            offsetProp = 'right';
+        else
+            offsetProp = swiper.isHorizontal() ? 'left' : 'top';
+        var slidesAfter;
+        var slidesBefore;
+        if (centeredSlides) {
+            slidesAfter = Math.floor(slidesPerView / 2) + slidesPerGroup + addSlidesAfter;
+            slidesBefore = Math.floor(slidesPerView / 2) + slidesPerGroup + addSlidesBefore;
+        }
+        else {
+            slidesAfter = slidesPerView + (slidesPerGroup - 1) + addSlidesAfter;
+            slidesBefore = (isLoop ? slidesPerView : slidesPerGroup) + addSlidesBefore;
+        }
+        var from = activeIndex - slidesBefore;
+        var to = activeIndex + slidesAfter;
+        if (!isLoop) {
+            from = Math.max(from, 0);
+            to = Math.min(to, slides.length - 1);
+        }
+        var offset = (swiper.slidesGrid[from] || 0) - (swiper.slidesGrid[0] || 0);
+        if (isLoop && activeIndex >= slidesBefore) {
+            from -= slidesBefore;
+            if (!centeredSlides)
+                offset += swiper.slidesGrid[0];
+        }
+        else if (isLoop && activeIndex < slidesBefore) {
+            from = -slidesBefore;
+            if (centeredSlides)
+                offset += swiper.slidesGrid[0];
+        }
+        Object.assign(swiper.virtual, {
+            from: from,
+            to: to,
+            offset: offset,
+            slidesGrid: swiper.slidesGrid,
+            slidesBefore: slidesBefore,
+            slidesAfter: slidesAfter,
+        });
+        function onRendered() {
+            swiper.updateSlides();
+            swiper.updateProgress();
+            swiper.updateSlidesClasses();
+            emit('virtualUpdate');
+        }
+        if (previousFrom === from && previousTo === to && !force) {
+            if (swiper.slidesGrid !== previousSlidesGrid && offset !== previousOffset) {
+                swiper.slides.forEach(function (slideEl) {
+                    slideEl.style[offsetProp] = "".concat(offset - Math.abs(swiper.cssOverflowAdjustment()), "px");
+                });
+            }
+            swiper.updateProgress();
+            emit('virtualUpdate');
+            return;
+        }
+        if (swiper.params.virtual.renderExternal) {
+            swiper.params.virtual.renderExternal.call(swiper, {
+                offset: offset,
+                from: from,
+                to: to,
+                slides: (function getSlides() {
+                    var slidesToRender = [];
+                    for (var i = from; i <= to; i += 1) {
+                        slidesToRender.push(slides[i]);
+                    }
+                    return slidesToRender;
+                })(),
+            });
+            if (swiper.params.virtual.renderExternalUpdate) {
+                onRendered();
+            }
+            else {
+                emit('virtualUpdate');
+            }
+            return;
+        }
+        var prependIndexes = [];
+        var appendIndexes = [];
+        var getSlideIndex = function (index) {
+            var slideIndex = index;
+            if (index < 0) {
+                slideIndex = slides.length + index;
+            }
+            else if (slideIndex >= slides.length) {
+                // eslint-disable-next-line
+                slideIndex = slideIndex - slides.length;
+            }
+            return slideIndex;
+        };
+        if (force) {
+            swiper.slides
+                .filter(function (el) { return el.matches(".".concat(swiper.params.slideClass, ", swiper-slide")); })
+                .forEach(function (slideEl) {
+                slideEl.remove();
+            });
+        }
+        else {
+            var _loop_1 = function (i) {
+                if (i < from || i > to) {
+                    var slideIndex_1 = getSlideIndex(i);
+                    swiper.slides
+                        .filter(function (el) {
+                        return el.matches(".".concat(swiper.params.slideClass, "[data-swiper-slide-index=\"").concat(slideIndex_1, "\"], swiper-slide[data-swiper-slide-index=\"").concat(slideIndex_1, "\"]"));
+                    })
+                        .forEach(function (slideEl) {
+                        slideEl.remove();
+                    });
+                }
+            };
+            for (var i = previousFrom; i <= previousTo; i += 1) {
+                _loop_1(i);
+            }
+        }
+        var loopFrom = isLoop ? -slides.length : 0;
+        var loopTo = isLoop ? slides.length * 2 : slides.length;
+        for (var i = loopFrom; i < loopTo; i += 1) {
+            if (i >= from && i <= to) {
+                var slideIndex = getSlideIndex(i);
+                if (typeof previousTo === 'undefined' || force) {
+                    appendIndexes.push(slideIndex);
+                }
+                else {
+                    if (i > previousTo)
+                        appendIndexes.push(slideIndex);
+                    if (i < previousFrom)
+                        prependIndexes.push(slideIndex);
+                }
+            }
+        }
+        appendIndexes.forEach(function (index) {
+            swiper.slidesEl.append(renderSlide(slides[index], index));
+        });
+        if (isLoop) {
+            for (var i = prependIndexes.length - 1; i >= 0; i -= 1) {
+                var index = prependIndexes[i];
+                swiper.slidesEl.prepend(renderSlide(slides[index], index));
+            }
+        }
+        else {
+            prependIndexes.sort(function (a, b) { return b - a; });
+            prependIndexes.forEach(function (index) {
+                swiper.slidesEl.prepend(renderSlide(slides[index], index));
+            });
+        }
+        (0, utils_1.elementChildren)(swiper.slidesEl, '.swiper-slide, swiper-slide').forEach(function (slideEl) {
+            slideEl.style[offsetProp] = "".concat(offset - Math.abs(swiper.cssOverflowAdjustment()), "px");
+        });
+        onRendered();
+    }
+    function appendSlide(slides) {
+        if (typeof slides === 'object' && 'length' in slides) {
+            for (var i = 0; i < slides.length; i += 1) {
+                if (slides[i])
+                    swiper.virtual.slides.push(slides[i]);
+            }
+        }
+        else {
+            swiper.virtual.slides.push(slides);
+        }
+        update(true, undefined);
+    }
+    function prependSlide(slides) {
+        var activeIndex = swiper.activeIndex;
+        var newActiveIndex = activeIndex + 1;
+        var numberOfNewSlides = 1;
+        if (Array.isArray(slides)) {
+            for (var i = 0; i < slides.length; i += 1) {
+                if (slides[i])
+                    swiper.virtual.slides.unshift(slides[i]);
+            }
+            newActiveIndex = activeIndex + slides.length;
+            numberOfNewSlides = slides.length;
+        }
+        else {
+            swiper.virtual.slides.unshift(slides);
+        }
+        if (swiper.params.virtual.cache) {
+            var cache_1 = swiper.virtual.cache;
+            var newCache_1 = {};
+            Object.keys(cache_1).forEach(function (cachedIndex) {
+                var cachedEl = cache_1[cachedIndex];
+                var cachedElIndex = cachedEl.getAttribute('data-swiper-slide-index');
+                if (cachedElIndex) {
+                    cachedEl.setAttribute('data-swiper-slide-index', parseInt(cachedElIndex, 10) + numberOfNewSlides);
+                }
+                newCache_1[parseInt(cachedIndex, 10) + numberOfNewSlides] = cachedEl;
+            });
+            swiper.virtual.cache = newCache_1;
+        }
+        update(true, undefined);
+        swiper.slideTo(newActiveIndex, 0);
+    }
+    function removeSlide(slidesIndexes) {
+        if (typeof slidesIndexes === 'undefined' || slidesIndexes === null)
+            return;
+        var activeIndex = swiper.activeIndex;
+        if (Array.isArray(slidesIndexes)) {
+            for (var i = slidesIndexes.length - 1; i >= 0; i -= 1) {
+                if (swiper.params.virtual.cache) {
+                    delete swiper.virtual.cache[slidesIndexes[i]];
+                    // shift cache indexes
+                    Object.keys(swiper.virtual.cache).forEach(function (key) {
+                        if (key > slidesIndexes) {
+                            swiper.virtual.cache[key - 1] = swiper.virtual.cache[key];
+                            swiper.virtual.cache[key - 1].setAttribute('data-swiper-slide-index', key - 1);
+                            delete swiper.virtual.cache[key];
+                        }
+                    });
+                }
+                swiper.virtual.slides.splice(slidesIndexes[i], 1);
+                if (slidesIndexes[i] < activeIndex)
+                    activeIndex -= 1;
+                activeIndex = Math.max(activeIndex, 0);
+            }
+        }
+        else {
+            if (swiper.params.virtual.cache) {
+                delete swiper.virtual.cache[slidesIndexes];
+                // shift cache indexes
+                Object.keys(swiper.virtual.cache).forEach(function (key) {
+                    if (key > slidesIndexes) {
+                        swiper.virtual.cache[key - 1] = swiper.virtual.cache[key];
+                        swiper.virtual.cache[key - 1].setAttribute('data-swiper-slide-index', key - 1);
+                        delete swiper.virtual.cache[key];
+                    }
+                });
+            }
+            swiper.virtual.slides.splice(slidesIndexes, 1);
+            if (slidesIndexes < activeIndex)
+                activeIndex -= 1;
+            activeIndex = Math.max(activeIndex, 0);
+        }
+        update(true, undefined);
+        swiper.slideTo(activeIndex, 0);
+    }
+    function removeAllSlides() {
+        swiper.virtual.slides = [];
+        if (swiper.params.virtual.cache) {
+            swiper.virtual.cache = {};
+        }
+        update(true, undefined);
+        swiper.slideTo(0, 0);
+    }
+    on('beforeInit', function () {
+        if (!swiper.params.virtual.enabled)
+            return;
+        var domSlidesAssigned;
+        if (typeof swiper.passedParams.virtual.slides === 'undefined') {
+            var slides = __spreadArray([], swiper.slidesEl.children, true).filter(function (el) {
+                return el.matches(".".concat(swiper.params.slideClass, ", swiper-slide"));
+            });
+            if (slides && slides.length) {
+                swiper.virtual.slides = __spreadArray([], slides, true);
+                domSlidesAssigned = true;
+                slides.forEach(function (slideEl, slideIndex) {
+                    slideEl.setAttribute('data-swiper-slide-index', slideIndex);
+                    swiper.virtual.cache[slideIndex] = slideEl;
+                    slideEl.remove();
+                });
+            }
+        }
+        if (!domSlidesAssigned) {
+            swiper.virtual.slides = swiper.params.virtual.slides;
+        }
+        swiper.classNames.push("".concat(swiper.params.containerModifierClass, "virtual"));
+        swiper.params.watchSlidesProgress = true;
+        swiper.originalParams.watchSlidesProgress = true;
+        update(false, true);
+    });
+    on('setTranslate', function () {
+        if (!swiper.params.virtual.enabled)
+            return;
+        if (swiper.params.cssMode && !swiper._immediateVirtual) {
+            clearTimeout(cssModeTimeout);
+            cssModeTimeout = setTimeout(function () {
+                update(undefined, undefined);
+            }, 100);
+        }
+        else {
+            update(undefined, undefined);
+        }
+    });
+    on('init update resize', function () {
+        if (!swiper.params.virtual.enabled)
+            return;
+        if (swiper.params.cssMode) {
+            (0, utils_1.setCSSProperty)(swiper.wrapperEl, '--swiper-virtual-size', "".concat(swiper.virtualSize, "px"));
+        }
+    });
+    Object.assign(swiper.virtual, {
+        appendSlide: appendSlide,
+        prependSlide: prependSlide,
+        removeSlide: removeSlide,
+        removeAllSlides: removeAllSlides,
+        update: update,
+    });
+}
+exports.Virtual = Virtual;
+//# sourceMappingURL=virtual.js.map

package/dist/ui/components/carousel/carousel-lib/react/swiper-slide.js

@@ -0,0 +1,88 @@
+"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);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwiperSlide = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+// @ts-nocheck
+var react_1 = require("react");
+var utils_1 = require("../components-shared/utils.js");
+var use_isomorphic_layout_effect_1 = require("./use-isomorphic-layout-effect.js");
+var context_1 = require("./context.js");
+var SwiperSlide = (0, react_1.forwardRef)(function (_a, externalRef) {
+    if (_a === void 0) { _a = {}; }
+    var _b = _a.tag, Tag = _b === void 0 ? 'div' : _b, children = _a.children, _c = _a.className, className = _c === void 0 ? '' : _c, swiper = _a.swiper, zoom = _a.zoom, lazy = _a.lazy, virtualIndex = _a.virtualIndex, swiperSlideIndex = _a.swiperSlideIndex, rest = __rest(_a, ["tag", "children", "className", "swiper", "zoom", "lazy", "virtualIndex", "swiperSlideIndex"]);
+    var slideElRef = (0, react_1.useRef)(null);
+    var _d = (0, react_1.useState)('swiper-slide'), slideClasses = _d[0], setSlideClasses = _d[1];
+    var _e = (0, react_1.useState)(false), lazyLoaded = _e[0], setLazyLoaded = _e[1];
+    function updateClasses(_s, el, classNames) {
+        if (el === slideElRef.current) {
+            setSlideClasses(classNames);
+        }
+    }
+    (0, use_isomorphic_layout_effect_1.useIsomorphicLayoutEffect)(function () {
+        if (typeof swiperSlideIndex !== 'undefined') {
+            slideElRef.current.swiperSlideIndex = swiperSlideIndex;
+        }
+        if (externalRef) {
+            externalRef.current = slideElRef.current;
+        }
+        if (!slideElRef.current || !swiper) {
+            return;
+        }
+        if (swiper.destroyed) {
+            if (slideClasses !== 'swiper-slide') {
+                setSlideClasses('swiper-slide');
+            }
+            return;
+        }
+        swiper.on('_slideClass', updateClasses);
+        // eslint-disable-next-line
+        return function () {
+            if (!swiper)
+                return;
+            swiper.off('_slideClass', updateClasses);
+        };
+    });
+    (0, use_isomorphic_layout_effect_1.useIsomorphicLayoutEffect)(function () {
+        if (swiper && slideElRef.current && !swiper.destroyed) {
+            setSlideClasses(swiper.getSlideClasses(slideElRef.current));
+        }
+    }, [swiper]);
+    var slideData = {
+        isActive: slideClasses.indexOf('swiper-slide-active') >= 0,
+        isVisible: slideClasses.indexOf('swiper-slide-visible') >= 0,
+        isPrev: slideClasses.indexOf('swiper-slide-prev') >= 0,
+        isNext: slideClasses.indexOf('swiper-slide-next') >= 0,
+    };
+    var renderChildren = function () {
+        return typeof children === 'function' ? children(slideData) : children;
+    };
+    var onLoad = function () {
+        setLazyLoaded(true);
+    };
+    return ((0, jsx_runtime_1.jsxs)(Tag, __assign({ ref: slideElRef, className: (0, utils_1.uniqueClasses)("".concat(slideClasses).concat(className ? " ".concat(className) : '')), "data-swiper-slide-index": virtualIndex, onLoad: onLoad }, rest, { children: [zoom && ((0, jsx_runtime_1.jsx)(context_1.SwiperSlideContext.Provider, { value: slideData, children: (0, jsx_runtime_1.jsxs)("div", { className: "swiper-zoom-container", "data-swiper-zoom": typeof zoom === 'number' ? zoom : undefined, children: [renderChildren(), lazy && !lazyLoaded && (0, jsx_runtime_1.jsx)("div", { className: "swiper-lazy-preloader" })] }) })), !zoom && ((0, jsx_runtime_1.jsxs)(context_1.SwiperSlideContext.Provider, { value: slideData, children: [renderChildren(), lazy && !lazyLoaded && (0, jsx_runtime_1.jsx)("div", { className: "swiper-lazy-preloader" })] }))] })));
+});
+exports.SwiperSlide = SwiperSlide;
+SwiperSlide.displayName = 'SwiperSlide';
+//# sourceMappingURL=swiper-slide.js.map

package/dist/ui/components/carousel/carousel-lib/react/swiper.js

@@ -0,0 +1,210 @@
+"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);
+};
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Swiper = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+// @ts-nocheck
+var react_1 = __importStar(require("react"));
+var swiper_1 = __importDefault(require("../swiper.js"));
+var get_params_1 = require("../components-shared/get-params.js");
+var mount_swiper_1 = require("../components-shared/mount-swiper.js");
+var utils_1 = require("../components-shared/utils.js");
+var get_changed_params_1 = require("../components-shared/get-changed-params.js");
+var get_children_1 = require("./get-children.js");
+var update_swiper_1 = require("../components-shared/update-swiper.js");
+var virtual_1 = require("./virtual.js");
+var update_on_virtual_data_1 = require("../components-shared/update-on-virtual-data.js");
+var use_isomorphic_layout_effect_1 = require("./use-isomorphic-layout-effect.js");
+var context_1 = require("./context.js");
+var Swiper = (0, react_1.forwardRef)(function (_a, externalElRef) {
+    var className = _a.className, _b = _a.tag, Tag = _b === void 0 ? 'div' : _b, _c = _a.wrapperTag, WrapperTag = _c === void 0 ? 'div' : _c, children = _a.children, onSwiper = _a.onSwiper, rest = __rest(_a, ["className", "tag", "wrapperTag", "children", "onSwiper"]);
+    var eventsAssigned = false;
+    var _d = (0, react_1.useState)('swiper'), containerClasses = _d[0], setContainerClasses = _d[1];
+    var _e = (0, react_1.useState)(null), virtualData = _e[0], setVirtualData = _e[1];
+    var _f = (0, react_1.useState)(false), breakpointChanged = _f[0], setBreakpointChanged = _f[1];
+    var initializedRef = (0, react_1.useRef)(false);
+    var swiperElRef = (0, react_1.useRef)(null);
+    var swiperRef = (0, react_1.useRef)(null);
+    var oldPassedParamsRef = (0, react_1.useRef)(null);
+    var oldSlides = (0, react_1.useRef)(null);
+    var nextElRef = (0, react_1.useRef)(null);
+    var prevElRef = (0, react_1.useRef)(null);
+    var paginationElRef = (0, react_1.useRef)(null);
+    var scrollbarElRef = (0, react_1.useRef)(null);
+    var _g = (0, get_params_1.getParams)(rest), swiperParams = _g.params, passedParams = _g.passedParams, restProps = _g.rest, events = _g.events;
+    var _h = (0, get_children_1.getChildren)(children), slides = _h.slides, slots = _h.slots;
+    var onBeforeBreakpoint = function () {
+        setBreakpointChanged(!breakpointChanged);
+    };
+    Object.assign(swiperParams.on, {
+        _containerClasses: function (swiper, classes) {
+            setContainerClasses(classes);
+        },
+    });
+    var initSwiper = function () {
+        // init swiper
+        Object.assign(swiperParams.on, events);
+        eventsAssigned = true;
+        var passParams = __assign({}, swiperParams);
+        delete passParams.wrapperClass;
+        swiperRef.current = new swiper_1.default(passParams);
+        if (swiperRef.current.virtual && swiperRef.current.params.virtual.enabled) {
+            swiperRef.current.virtual.slides = slides;
+            var extendWith = {
+                cache: false,
+                slides: slides,
+                renderExternal: setVirtualData,
+                renderExternalUpdate: false,
+            };
+            (0, utils_1.extend)(swiperRef.current.params.virtual, extendWith);
+            (0, utils_1.extend)(swiperRef.current.originalParams.virtual, extendWith);
+        }
+    };
+    if (!swiperElRef.current) {
+        initSwiper();
+    }
+    // Listen for breakpoints change
+    if (swiperRef.current) {
+        swiperRef.current.on('_beforeBreakpoint', onBeforeBreakpoint);
+    }
+    var attachEvents = function () {
+        if (eventsAssigned || !events || !swiperRef.current)
+            return;
+        Object.keys(events).forEach(function (eventName) {
+            swiperRef.current.on(eventName, events[eventName]);
+        });
+    };
+    var detachEvents = function () {
+        if (!events || !swiperRef.current)
+            return;
+        Object.keys(events).forEach(function (eventName) {
+            swiperRef.current.off(eventName, events[eventName]);
+        });
+    };
+    (0, react_1.useEffect)(function () {
+        return function () {
+            if (swiperRef.current)
+                swiperRef.current.off('_beforeBreakpoint', onBeforeBreakpoint);
+        };
+    });
+    // set initialized flag
+    (0, react_1.useEffect)(function () {
+        if (!initializedRef.current && swiperRef.current) {
+            swiperRef.current.emitSlidesClasses();
+            initializedRef.current = true;
+        }
+    });
+    // mount swiper
+    (0, use_isomorphic_layout_effect_1.useIsomorphicLayoutEffect)(function () {
+        if (externalElRef) {
+            externalElRef.current = swiperElRef.current;
+        }
+        if (!swiperElRef.current)
+            return;
+        if (swiperRef.current.destroyed) {
+            initSwiper();
+        }
+        (0, mount_swiper_1.mountSwiper)({
+            el: swiperElRef.current,
+            nextEl: nextElRef.current,
+            prevEl: prevElRef.current,
+            paginationEl: paginationElRef.current,
+            scrollbarEl: scrollbarElRef.current,
+            swiper: swiperRef.current,
+        }, swiperParams);
+        if (onSwiper && !swiperRef.current.destroyed)
+            onSwiper(swiperRef.current);
+        // eslint-disable-next-line
+        return function () {
+            if (swiperRef.current && !swiperRef.current.destroyed) {
+                swiperRef.current.destroy(true, false);
+            }
+        };
+    }, []);
+    // watch for params change
+    (0, use_isomorphic_layout_effect_1.useIsomorphicLayoutEffect)(function () {
+        attachEvents();
+        var changedParams = (0, get_changed_params_1.getChangedParams)(passedParams, oldPassedParamsRef.current, slides, oldSlides.current, function (c) { return c.key; });
+        oldPassedParamsRef.current = passedParams;
+        oldSlides.current = slides;
+        if (changedParams.length && swiperRef.current && !swiperRef.current.destroyed) {
+            (0, update_swiper_1.updateSwiper)({
+                swiper: swiperRef.current,
+                slides: slides,
+                passedParams: passedParams,
+                changedParams: changedParams,
+                nextEl: nextElRef.current,
+                prevEl: prevElRef.current,
+                scrollbarEl: scrollbarElRef.current,
+                paginationEl: paginationElRef.current,
+            });
+        }
+        return function () {
+            detachEvents();
+        };
+    });
+    // update on virtual update
+    (0, use_isomorphic_layout_effect_1.useIsomorphicLayoutEffect)(function () {
+        (0, update_on_virtual_data_1.updateOnVirtualData)(swiperRef.current);
+    }, [virtualData]);
+    // bypass swiper instance to slides
+    function renderSlides() {
+        if (swiperParams.virtual) {
+            return (0, virtual_1.renderVirtual)(swiperRef.current, slides, virtualData);
+        }
+        return slides.map(function (child, index) {
+            return react_1.default.cloneElement(child, { swiper: swiperRef.current, swiperSlideIndex: index });
+        });
+    }
+    return ((0, jsx_runtime_1.jsx)(Tag, __assign({ ref: swiperElRef, className: (0, utils_1.uniqueClasses)("".concat(containerClasses).concat(className ? " ".concat(className) : '')) }, restProps, { children: (0, jsx_runtime_1.jsxs)(context_1.SwiperContext.Provider, { value: swiperRef.current, children: [slots['container-start'], (0, jsx_runtime_1.jsxs)(WrapperTag, { className: (0, utils_1.wrapperClass)(swiperParams.wrapperClass), children: [slots['wrapper-start'], renderSlides(), slots['wrapper-end']] }), (0, utils_1.needsNavigation)(swiperParams) && ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)("div", { ref: prevElRef, className: "swiper-button-prev" }), (0, jsx_runtime_1.jsx)("div", { ref: nextElRef, className: "swiper-button-next" })] })), (0, utils_1.needsScrollbar)(swiperParams) && ((0, jsx_runtime_1.jsx)("div", { ref: scrollbarElRef, className: "swiper-scrollbar" })), (0, utils_1.needsPagination)(swiperParams) && ((0, jsx_runtime_1.jsx)("div", { ref: paginationElRef, className: "swiper-pagination" })), slots['container-end']] }) })));
+});
+exports.Swiper = Swiper;
+Swiper.displayName = 'Swiper';
+//# sourceMappingURL=swiper.js.map