infinity-forge 2.4.2 → 2.4.4

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

@@ -1,4 +1,4 @@
-import { Column } from "../../../interfaces";
+import { Column } from "../../../interfaces.js";
 export interface ITHeadItemProps {
     index: number;
     colunm: Column;

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

@@ -0,0 +1,4 @@
+export * from './query/index.js';
+export * from './component.js';
+export * from './components/index.js';
+export * from './interfaces.js';

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

@@ -0,0 +1,21 @@
+"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("./query/index.js"), exports);
+__exportStar(require("./component.js"), exports);
+__exportStar(require("./components/index.js"), exports);
+__exportStar(require("./interfaces.js"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,92 @@
+/// <reference types="react" />
+import { Filter, PaginationModel } from '../../../../../system/index.js';
+import { IconsNames, DynamicFormHandlerProps, QueryOptions } from '../../../../../ui/index.js';
+interface Column<T = any> {
+    id: keyof T;
+    label: string;
+    width?: number;
+    hasAsc?: boolean;
+    enabled?: boolean;
+    Component?: {
+        Element: (props: {
+            [key in keyof T]?: any;
+        } & {
+            index: number;
+        }) => JSX.Element;
+        allProps?: boolean;
+        props: {
+            [key in keyof T]?: any;
+        };
+        defaultProps?: {
+            [key: string]: any;
+        };
+    };
+}
+interface IParamsTable {
+    page?: number;
+}
+interface IConfigurationsTable {
+    tableData?: any;
+    isLoading?: boolean;
+    errorMessage: string;
+    customFilters?: Filter[];
+    disableGetFilter?: boolean;
+    disablePagination?: boolean;
+    enableSearchInSelf?: boolean;
+    pagination?: PaginationModel;
+    disableOrdenationTable?: boolean;
+}
+type QueryTable<M = any> = {
+    user?: any;
+    container?: any;
+    Types?: any;
+    queryKey: {
+        remoteName?: M;
+        customKey?: string;
+    };
+    requireUser?: boolean;
+    queryKeyParams?: string;
+    dynamicFiltersFromApi?: boolean;
+    debugMode?: boolean;
+    options?: QueryOptions;
+    customRemote?: (params: any) => any;
+};
+type TableActionCreate<T = any> = {
+    link?: {
+        href: string;
+    };
+    text?: string;
+    icon?: IconsNames;
+} & DynamicFormHandlerProps<T>;
+type TableActionEdit<T = any> = {
+    link?: {
+        href: (table: {
+            [key in keyof T]: string;
+        }) => string;
+        text: string;
+        icon?: IconsNames;
+    };
+} & DynamicFormHandlerProps<T>;
+export type FNComponent = (props: any) => JSX.Element;
+type ActionsTable<T = any> = {
+    edit?: TableActionEdit<T>;
+    create?: TableActionCreate<T>;
+    custom?: FNComponent[];
+    modalStyles?: React.CSSProperties;
+    delete?: (table: {
+        [key in keyof T]: T[key];
+    }) => void;
+    detail?: (table: {
+        [key in keyof T]: string;
+    }) => string;
+};
+type ColumnsConfiguration<T = any> = {
+    columns: Column<T>[];
+    actions?: ActionsTable<T>;
+};
+interface IUseTableProps<T = any, M = any> {
+    query?: QueryTable<M>;
+    configs: IConfigurationsTable;
+    columnsConfiguration: ColumnsConfiguration<T>;
+}
+export type { Column, QueryTable, ActionsTable, IParamsTable, IUseTableProps, TableActionEdit, TableActionCreate, IConfigurationsTable, ColumnsConfiguration, };

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

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

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

@@ -1,4 +1,4 @@
-import { QueryTable } from '../interfaces';
+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

@@ -13,7 +13,7 @@ var __assign = (this && this.__assign) || function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useQueryTable = void 0;
 var router_1 = require("next/router");
-var ui_1 = require("../../../../../../ui");
+var ui_1 = require("../../../../../../ui/index.js");
 function useQueryTable(props) {
     var _a;
     var _b = (0, router_1.useRouter)(), query = _b.query, isReady = _b.isReady;

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

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

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

@@ -14,6 +14,6 @@ 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"), exports);
-__exportStar(require("./get-query-arguments-table"), exports);
+__exportStar(require("./hook.js"), exports);
+__exportStar(require("./get-query-arguments-table.js"), exports);
 //# sourceMappingURL=index.js.map

package/dist/ui/components/carousel/carousel-lib/components-shared/get-changed-params.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChangedParams = void 0;
+var params_list_1 = require("./params-list.js");
+var utils_1 = require("./utils.js");
+function getChangedParams(swiperParams, oldParams, children, oldChildren, getKey) {
+    var keys = [];
+    if (!oldParams)
+        return keys;
+    var addKey = function (key) {
+        if (keys.indexOf(key) < 0)
+            keys.push(key);
+    };
+    if (children && oldChildren) {
+        var oldChildrenKeys = oldChildren.map(getKey);
+        var childrenKeys = children.map(getKey);
+        if (oldChildrenKeys.join('') !== childrenKeys.join(''))
+            addKey('children');
+        if (oldChildren.length !== children.length)
+            addKey('children');
+    }
+    var watchParams = params_list_1.paramsList.filter(function (key) { return key[0] === '_'; }).map(function (key) { return key.replace(/_/, ''); });
+    watchParams.forEach(function (key) {
+        if (key in swiperParams && key in oldParams) {
+            if ((0, utils_1.isObject)(swiperParams[key]) && (0, utils_1.isObject)(oldParams[key])) {
+                var newKeys = Object.keys(swiperParams[key]);
+                var oldKeys = Object.keys(oldParams[key]);
+                if (newKeys.length !== oldKeys.length) {
+                    addKey(key);
+                }
+                else {
+                    newKeys.forEach(function (newKey) {
+                        if (swiperParams[key][newKey] !== oldParams[key][newKey]) {
+                            addKey(key);
+                        }
+                    });
+                    oldKeys.forEach(function (oldKey) {
+                        if (swiperParams[key][oldKey] !== oldParams[key][oldKey])
+                            addKey(key);
+                    });
+                }
+            }
+            else if (swiperParams[key] !== oldParams[key]) {
+                addKey(key);
+            }
+        }
+    });
+    return keys;
+}
+exports.getChangedParams = getChangedParams;
+//# sourceMappingURL=get-changed-params.js.map

package/dist/ui/components/carousel/carousel-lib/components-shared/get-element-params.js

@@ -0,0 +1,148 @@
+"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 __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));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParams = void 0;
+//@ts-nocheck
+var utils_1 = require("./utils.js");
+var params_list_1 = require("./params-list.js");
+var defaults_1 = __importDefault(require("../core/defaults.js"));
+var formatValue = function (val) {
+    if (parseFloat(val) === Number(val))
+        return Number(val);
+    if (val === 'true')
+        return true;
+    if (val === '')
+        return true;
+    if (val === 'false')
+        return false;
+    if (val === 'null')
+        return null;
+    if (val === 'undefined')
+        return undefined;
+    if (typeof val === 'string' && val.includes('{') && val.includes('}') && val.includes('"')) {
+        var v = void 0;
+        try {
+            v = JSON.parse(val);
+        }
+        catch (err) {
+            v = val;
+        }
+        return v;
+    }
+    return val;
+};
+var modulesParamsList = [
+    'a11y',
+    'autoplay',
+    'controller',
+    'cards-effect',
+    'coverflow-effect',
+    'creative-effect',
+    'cube-effect',
+    'fade-effect',
+    'flip-effect',
+    'free-mode',
+    'grid',
+    'hash-navigation',
+    'history',
+    'keyboard',
+    'mousewheel',
+    'navigation',
+    'pagination',
+    'parallax',
+    'scrollbar',
+    'thumbs',
+    'virtual',
+    'zoom',
+];
+function getParams(element, propName, propValue) {
+    var params = {};
+    var passedParams = {};
+    (0, utils_1.extend)(params, defaults_1.default);
+    var localParamsList = __spreadArray(__spreadArray([], params_list_1.paramsList, true), ['on'], false);
+    var allowedParams = localParamsList.map(function (key) { return key.replace(/_/, ''); });
+    // First check props
+    localParamsList.forEach(function (paramName) {
+        paramName = paramName.replace('_', '');
+        if (typeof element[paramName] !== 'undefined') {
+            passedParams[paramName] = element[paramName];
+        }
+    });
+    // Attributes
+    var attrsList = __spreadArray([], element.attributes, true);
+    if (typeof propName === 'string' && typeof propValue !== 'undefined') {
+        attrsList.push({ name: propName, value: (0, utils_1.isObject)(propValue) ? __assign({}, propValue) : propValue });
+    }
+    attrsList.forEach(function (attr) {
+        var moduleParam = modulesParamsList.filter(function (mParam) { return attr.name.indexOf("".concat(mParam, "-")) === 0; })[0];
+        if (moduleParam) {
+            var parentObjName = (0, utils_1.attrToProp)(moduleParam);
+            var subObjName = (0, utils_1.attrToProp)(attr.name.split("".concat(moduleParam, "-"))[1]);
+            if (typeof passedParams[parentObjName] === 'undefined')
+                passedParams[parentObjName] = {};
+            if (passedParams[parentObjName] === true) {
+                passedParams[parentObjName] = { enabled: true };
+            }
+            passedParams[parentObjName][subObjName] = formatValue(attr.value);
+        }
+        else {
+            var name_1 = (0, utils_1.attrToProp)(attr.name);
+            if (!allowedParams.includes(name_1))
+                return;
+            var value = formatValue(attr.value);
+            if (passedParams[name_1] && modulesParamsList.includes(attr.name) && !(0, utils_1.isObject)(value)) {
+                if (passedParams[name_1].constructor !== Object) {
+                    passedParams[name_1] = {};
+                }
+                passedParams[name_1].enabled = !!value;
+            }
+            else {
+                passedParams[name_1] = value;
+            }
+        }
+    });
+    (0, utils_1.extend)(params, passedParams);
+    if (params.navigation) {
+        params.navigation = __assign({ prevEl: '.swiper-button-prev', nextEl: '.swiper-button-next' }, (params.navigation !== true ? params.navigation : {}));
+    }
+    else if (params.navigation === false) {
+        delete params.navigation;
+    }
+    if (params.scrollbar) {
+        params.scrollbar = __assign({ el: '.swiper-scrollbar' }, (params.scrollbar !== true ? params.scrollbar : {}));
+    }
+    else if (params.scrollbar === false) {
+        delete params.scrollbar;
+    }
+    if (params.pagination) {
+        params.pagination = __assign({ el: '.swiper-pagination' }, (params.pagination !== true ? params.pagination : {}));
+    }
+    else if (params.pagination === false) {
+        delete params.pagination;
+    }
+    return { params: params, passedParams: passedParams };
+}
+exports.getParams = getParams;
+//# sourceMappingURL=get-element-params.js.map

package/dist/ui/components/carousel/carousel-lib/components-shared/get-params.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParams = void 0;
+//@ts-nocheck
+var utils_1 = require("./utils.js");
+var params_list_1 = require("./params-list.js");
+var defaults_1 = __importDefault(require("../core/defaults.js"));
+function getParams(obj, splitEvents) {
+    if (obj === void 0) { obj = {}; }
+    if (splitEvents === void 0) { splitEvents = true; }
+    var params = {
+        on: {},
+    };
+    var events = {};
+    var passedParams = {};
+    (0, utils_1.extend)(params, defaults_1.default);
+    params._emitClasses = true;
+    params.init = false;
+    var rest = {};
+    var allowedParams = params_list_1.paramsList.map(function (key) { return key.replace(/_/, ''); });
+    var plainObj = Object.assign({}, obj);
+    Object.keys(plainObj).forEach(function (key) {
+        if (typeof obj[key] === 'undefined')
+            return;
+        if (allowedParams.indexOf(key) >= 0) {
+            if ((0, utils_1.isObject)(obj[key])) {
+                params[key] = {};
+                passedParams[key] = {};
+                (0, utils_1.extend)(params[key], obj[key]);
+                (0, utils_1.extend)(passedParams[key], obj[key]);
+            }
+            else {
+                params[key] = obj[key];
+                passedParams[key] = obj[key];
+            }
+        }
+        else if (key.search(/on[A-Z]/) === 0 && typeof obj[key] === 'function') {
+            if (splitEvents) {
+                events["".concat(key[2].toLowerCase()).concat(key.substr(3))] = obj[key];
+            }
+            else {
+                params.on["".concat(key[2].toLowerCase()).concat(key.substr(3))] = obj[key];
+            }
+        }
+        else {
+            rest[key] = obj[key];
+        }
+    });
+    ['navigation', 'pagination', 'scrollbar'].forEach(function (key) {
+        if (params[key] === true)
+            params[key] = {};
+        if (params[key] === false)
+            delete params[key];
+    });
+    return { params: params, passedParams: passedParams, rest: rest, events: events };
+}
+exports.getParams = getParams;
+//# sourceMappingURL=get-params.js.map

package/dist/ui/components/carousel/carousel-lib/components-shared/mount-swiper.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountSwiper = void 0;
+var utils_1 = require("./utils.js");
+function mountSwiper(_a, swiperParams) {
+    var el = _a.el, nextEl = _a.nextEl, prevEl = _a.prevEl, paginationEl = _a.paginationEl, scrollbarEl = _a.scrollbarEl, swiper = _a.swiper;
+    if ((0, utils_1.needsNavigation)(swiperParams) && nextEl && prevEl) {
+        swiper.params.navigation.nextEl = nextEl;
+        swiper.originalParams.navigation.nextEl = nextEl;
+        swiper.params.navigation.prevEl = prevEl;
+        swiper.originalParams.navigation.prevEl = prevEl;
+    }
+    if ((0, utils_1.needsPagination)(swiperParams) && paginationEl) {
+        swiper.params.pagination.el = paginationEl;
+        swiper.originalParams.pagination.el = paginationEl;
+    }
+    if ((0, utils_1.needsScrollbar)(swiperParams) && scrollbarEl) {
+        swiper.params.scrollbar.el = scrollbarEl;
+        swiper.originalParams.scrollbar.el = scrollbarEl;
+    }
+    swiper.init(el);
+}
+exports.mountSwiper = mountSwiper;
+//# sourceMappingURL=mount-swiper.js.map

package/dist/ui/components/carousel/carousel-lib/components-shared/update-swiper.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSwiper = void 0;
+var utils_1 = require("./utils.js");
+function updateSwiper(_a) {
+    var swiper = _a.swiper, slides = _a.slides, passedParams = _a.passedParams, changedParams = _a.changedParams, nextEl = _a.nextEl, prevEl = _a.prevEl, scrollbarEl = _a.scrollbarEl, paginationEl = _a.paginationEl;
+    var updateParams = changedParams.filter(function (key) { return key !== 'children' && key !== 'direction' && key !== 'wrapperClass'; });
+    var currentParams = swiper.params, pagination = swiper.pagination, navigation = swiper.navigation, scrollbar = swiper.scrollbar, virtual = swiper.virtual, thumbs = swiper.thumbs;
+    var needThumbsInit;
+    var needControllerInit;
+    var needPaginationInit;
+    var needScrollbarInit;
+    var needNavigationInit;
+    var loopNeedDestroy;
+    var loopNeedEnable;
+    var loopNeedReloop;
+    if (changedParams.includes('thumbs') &&
+        passedParams.thumbs &&
+        passedParams.thumbs.swiper &&
+        currentParams.thumbs &&
+        !currentParams.thumbs.swiper) {
+        needThumbsInit = true;
+    }
+    if (changedParams.includes('controller') &&
+        passedParams.controller &&
+        passedParams.controller.control &&
+        currentParams.controller &&
+        !currentParams.controller.control) {
+        needControllerInit = true;
+    }
+    if (changedParams.includes('pagination') &&
+        passedParams.pagination &&
+        (passedParams.pagination.el || paginationEl) &&
+        (currentParams.pagination || currentParams.pagination === false) &&
+        pagination &&
+        !pagination.el) {
+        needPaginationInit = true;
+    }
+    if (changedParams.includes('scrollbar') &&
+        passedParams.scrollbar &&
+        (passedParams.scrollbar.el || scrollbarEl) &&
+        (currentParams.scrollbar || currentParams.scrollbar === false) &&
+        scrollbar &&
+        !scrollbar.el) {
+        needScrollbarInit = true;
+    }
+    if (changedParams.includes('navigation') &&
+        passedParams.navigation &&
+        (passedParams.navigation.prevEl || prevEl) &&
+        (passedParams.navigation.nextEl || nextEl) &&
+        (currentParams.navigation || currentParams.navigation === false) &&
+        navigation &&
+        !navigation.prevEl &&
+        !navigation.nextEl) {
+        needNavigationInit = true;
+    }
+    var destroyModule = function (mod) {
+        if (!swiper[mod])
+            return;
+        swiper[mod].destroy();
+        if (mod === 'navigation') {
+            if (swiper.isElement) {
+                swiper[mod].prevEl.remove();
+                swiper[mod].nextEl.remove();
+            }
+            currentParams[mod].prevEl = undefined;
+            currentParams[mod].nextEl = undefined;
+            swiper[mod].prevEl = undefined;
+            swiper[mod].nextEl = undefined;
+        }
+        else {
+            if (swiper.isElement) {
+                swiper[mod].el.remove();
+            }
+            currentParams[mod].el = undefined;
+            swiper[mod].el = undefined;
+        }
+    };
+    if (changedParams.includes('loop') && swiper.isElement) {
+        if (currentParams.loop && !passedParams.loop) {
+            loopNeedDestroy = true;
+        }
+        else if (!currentParams.loop && passedParams.loop) {
+            loopNeedEnable = true;
+        }
+        else {
+            loopNeedReloop = true;
+        }
+    }
+    updateParams.forEach(function (key) {
+        if ((0, utils_1.isObject)(currentParams[key]) && (0, utils_1.isObject)(passedParams[key])) {
+            Object.assign(currentParams[key], passedParams[key]);
+            if ((key === 'navigation' || key === 'pagination' || key === 'scrollbar') &&
+                'enabled' in passedParams[key] &&
+                !passedParams[key].enabled) {
+                destroyModule(key);
+            }
+        }
+        else {
+            var newValue = passedParams[key];
+            if ((newValue === true || newValue === false) &&
+                (key === 'navigation' || key === 'pagination' || key === 'scrollbar')) {
+                if (newValue === false) {
+                    destroyModule(key);
+                }
+            }
+            else {
+                currentParams[key] = passedParams[key];
+            }
+        }
+    });
+    if (updateParams.includes('controller') &&
+        !needControllerInit &&
+        swiper.controller &&
+        swiper.controller.control &&
+        currentParams.controller &&
+        currentParams.controller.control) {
+        swiper.controller.control = currentParams.controller.control;
+    }
+    if (changedParams.includes('children') && slides && virtual && currentParams.virtual.enabled) {
+        virtual.slides = slides;
+        virtual.update(true);
+    }
+    else if (changedParams.includes('virtual') && virtual && currentParams.virtual.enabled) {
+        if (slides)
+            virtual.slides = slides;
+        virtual.update(true);
+    }
+    if (changedParams.includes('children') && slides && currentParams.loop) {
+        loopNeedReloop = true;
+    }
+    if (needThumbsInit) {
+        var initialized = thumbs.init();
+        if (initialized)
+            thumbs.update(true);
+    }
+    if (needControllerInit) {
+        swiper.controller.control = currentParams.controller.control;
+    }
+    if (needPaginationInit) {
+        if (swiper.isElement && (!paginationEl || typeof paginationEl === 'string')) {
+            paginationEl = document.createElement('div');
+            paginationEl.classList.add('swiper-pagination');
+            paginationEl.part.add('pagination');
+            swiper.el.appendChild(paginationEl);
+        }
+        if (paginationEl)
+            currentParams.pagination.el = paginationEl;
+        pagination.init();
+        pagination.render();
+        pagination.update();
+    }
+    if (needScrollbarInit) {
+        if (swiper.isElement && (!scrollbarEl || typeof scrollbarEl === 'string')) {
+            scrollbarEl = document.createElement('div');
+            scrollbarEl.classList.add('swiper-scrollbar');
+            scrollbarEl.part.add('scrollbar');
+            swiper.el.appendChild(scrollbarEl);
+        }
+        if (scrollbarEl)
+            currentParams.scrollbar.el = scrollbarEl;
+        scrollbar.init();
+        scrollbar.updateSize();
+        scrollbar.setTranslate();
+    }
+    if (needNavigationInit) {
+        if (swiper.isElement) {
+            if (!nextEl || typeof nextEl === 'string') {
+                nextEl = document.createElement('div');
+                nextEl.classList.add('swiper-button-next');
+                nextEl.innerHTML = swiper.hostEl.constructor.nextButtonSvg;
+                nextEl.part.add('button-next');
+                swiper.el.appendChild(nextEl);
+            }
+            if (!prevEl || typeof prevEl === 'string') {
+                prevEl = document.createElement('div');
+                prevEl.classList.add('swiper-button-prev');
+                prevEl.innerHTML = swiper.hostEl.constructor.prevButtonSvg;
+                prevEl.part.add('button-prev');
+                swiper.el.appendChild(prevEl);
+            }
+        }
+        if (nextEl)
+            currentParams.navigation.nextEl = nextEl;
+        if (prevEl)
+            currentParams.navigation.prevEl = prevEl;
+        navigation.init();
+        navigation.update();
+    }
+    if (changedParams.includes('allowSlideNext')) {
+        swiper.allowSlideNext = passedParams.allowSlideNext;
+    }
+    if (changedParams.includes('allowSlidePrev')) {
+        swiper.allowSlidePrev = passedParams.allowSlidePrev;
+    }
+    if (changedParams.includes('direction')) {
+        swiper.changeDirection(passedParams.direction, false);
+    }
+    if (loopNeedDestroy || loopNeedReloop) {
+        swiper.loopDestroy();
+    }
+    if (loopNeedEnable || loopNeedReloop) {
+        swiper.loopCreate();
+    }
+    swiper.update();
+}
+exports.updateSwiper = updateSwiper;
+//# sourceMappingURL=update-swiper.js.map

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

@@ -1,7 +1,7 @@
 "use strict";
 //@ts-nocheck
 Object.defineProperty(exports, "__esModule", { value: true });
-var window_1 = require("../../ssr-window/window");
+var window_1 = require("../../ssr-window/window.js");
 function getBreakpoint(breakpoints, base, containerEl) {
     if (base === void 0) { base = 'window'; }
     if (!breakpoints || (base === 'container' && !containerEl))

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

@@ -1,5 +1,5 @@
-import setBreakpoint from './setBreakpoint';
-import getBreakpoint from './getBreakpoint';
+import setBreakpoint from './setBreakpoint.js';
+import getBreakpoint from './getBreakpoint.js';
 declare const _default: {
     setBreakpoint: typeof setBreakpoint;
     getBreakpoint: typeof getBreakpoint;