@sentecacommerce-theme/lib 0.13.5-alpha.5 → 0.13.5

package/dist/esm/basket/api/mutations/useChangeGiftVariant.js

@@ -0,0 +1,106 @@
+import regeneratorRuntime from "regenerator-runtime";
+import React from 'react';
+import { useMutation } from 'react-query';
+import { MyCartChangeSelectableGiftLineItemVariant } from '@sentecacommerce/sdk';
+import { useReplaceBasket } from '../../index';
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+export var useChangeGiftVariantMutation = function() {
+    var ref = _slicedToArray(useReplaceBasket(), 1), replaceBasket = ref[0];
+    return useMutation(function() {
+        var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(props) {
+            return regeneratorRuntime.wrap(function _callee$(_ctx) {
+                while(1)switch(_ctx.prev = _ctx.next){
+                    case 0:
+                        _ctx.next = 2;
+                        return MyCartChangeSelectableGiftLineItemVariant(props);
+                    case 2:
+                        return _ctx.abrupt("return", _ctx.sent);
+                    case 3:
+                    case "end":
+                        return _ctx.stop();
+                }
+            }, _callee);
+        }));
+        return function(props) {
+            return _ref.apply(this, arguments);
+        };
+    }(), {
+        onSuccess: function(data) {
+            return replaceBasket(data);
+        }
+    });
+};

package/dist/esm/basket/api/mutations/useReplaceBasketMutation.js

@@ -0,0 +1,52 @@
+import regeneratorRuntime from "regenerator-runtime";
+import { useMutation, useQueryCache } from 'react-query';
+import { myCartCacheKeys } from '../../../index';
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+export var useReplaceBasketMutation = function() {
+    var queryCache = useQueryCache();
+    return useMutation(function() {
+        var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(newBasket) {
+            return regeneratorRuntime.wrap(function _callee$(_ctx) {
+                while(1)switch(_ctx.prev = _ctx.next){
+                    case 0:
+                        queryCache.setQueryData(myCartCacheKeys.useGet, newBasket);
+                        queryCache.setQueryData(myCartCacheKeys.useGetCompact, newBasket.compact);
+                    case 2:
+                    case "end":
+                        return _ctx.stop();
+                }
+            }, _callee);
+        }));
+        return function(newBasket) {
+            return _ref.apply(this, arguments);
+        };
+    }());
+};

package/dist/esm/basket/hooks/index.js

@@ -0,0 +1,3 @@
+export * from './useReplaceBasket';
+export * from './useBasketCrossSaleItems';
+export * from './useChangeGiftVariant';

package/dist/esm/basket/hooks/useBasketCrossSaleItems.js

@@ -0,0 +1,67 @@
+import regeneratorRuntime from "regenerator-runtime";
+import React, { useMemo } from 'react';
+import { useQuery } from 'react-query';
+import { MyCartGetCrossSaleProducts } from '@sentecacommerce/sdk';
+import { getTranslatableField } from '../../index';
+import { myCartCacheKeys } from '../../index';
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+export var useBasketCrossSaleItems = function() {
+    var crossSaleProducts = useQuery(myCartCacheKeys.useGetCrossSaleItems, _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
+        return regeneratorRuntime.wrap(function _callee$(_ctx) {
+            while(1)switch(_ctx.prev = _ctx.next){
+                case 0:
+                    _ctx.next = 2;
+                    return MyCartGetCrossSaleProducts();
+                case 2:
+                    return _ctx.abrupt("return", _ctx.sent);
+                case 3:
+                case "end":
+                    return _ctx.stop();
+            }
+        }, _callee);
+    })));
+    return useMemo(function() {
+        var ref;
+        return crossSaleProducts === null || crossSaleProducts === void 0 ? void 0 : (ref = crossSaleProducts.data) === null || ref === void 0 ? void 0 : ref.map(function(product) {
+            return {
+                name: getTranslatableField(product.name),
+                description: getTranslatableField(product.description),
+                slug: getTranslatableField(product.slug),
+                attributeRules: product.attributeRules,
+                attributes: product.attributes,
+                _id: product._id,
+                variants: product.variants
+            };
+        });
+    }, [
+        crossSaleProducts === null || crossSaleProducts === void 0 ? void 0 : crossSaleProducts.data
+    ]);
+};

package/dist/esm/basket/hooks/useChangeGiftVariant.js

@@ -0,0 +1,3 @@
+import React from 'react';
+import { useChangeGiftVariantMutation } from '../api/mutations';
+export { useChangeGiftVariantMutation as useChangeGiftVariant };

package/dist/esm/basket/hooks/useReplaceBasket.js

@@ -0,0 +1,2 @@
+import { useReplaceBasketMutation } from '../api';
+export { useReplaceBasketMutation as useReplaceBasket };

package/dist/esm/basket/index.js

@@ -0,0 +1 @@
+export * from './hooks';

package/dist/esm/brands/api/queries/keys.js

@@ -1,6 +1,4 @@
-var BrandsQueryEnum1;
-export { BrandsQueryEnum1 as BrandsQueryEnum,  };
+export var BrandsQueryEnum;
 (function(BrandsQueryEnum) {
     BrandsQueryEnum["useAllBrandsQuery"] = 'brands-all';
-})(BrandsQueryEnum1 || (BrandsQueryEnum1 = {
-}));
+})(BrandsQueryEnum || (BrandsQueryEnum = {}));

package/dist/esm/brands/api/queries/useAllBrandsQuery.js

@@ -42,79 +42,94 @@ export var useAllBrandsQuery = function() {
         staleTime: 30000
     });
 };
-export var processBrandsQuery = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
-    var ref2, allBrands, publishedBrands, filteredBrands;
-    return regeneratorRuntime.wrap(function _callee$(_ctx) {
-        while(1)switch(_ctx.prev = _ctx.next){
-            case 0:
-                ;
-                _ctx.next = 3;
-                return BrandsFilter({
-                    filter: 'parent;exists;false'
-                });
-            case 3:
-                allBrands = _ctx.sent;
-                publishedBrands = allBrands === null || allBrands === void 0 ? void 0 : (ref2 = allBrands.results) === null || ref2 === void 0 ? void 0 : ref2.filter(function(brand) {
-                    var ref, ref1;
-                    return ((ref = brand.storeStatus) === null || ref === void 0 ? void 0 : (ref1 = ref[0]) === null || ref1 === void 0 ? void 0 : ref1.status) === StoreStatusDTOStatusEnum.Published;
-                });
-                _ctx.next = 7;
-                return filterBrands(publishedBrands);
-            case 7:
-                filteredBrands = _ctx.sent;
-                return _ctx.abrupt("return", filteredBrands);
-            case 9:
-            case "end":
-                return _ctx.stop();
-        }
-    }, _callee);
-}));
-var filterBrands = _asyncToGenerator(regeneratorRuntime.mark(function _callee1(brands) {
-    var result;
-    return regeneratorRuntime.wrap(function _callee$(_ctx1) {
-        while(1)switch(_ctx1.prev = _ctx1.next){
-            case 0:
-                ;
-                _ctx1.prev = 1;
-                _ctx1.next = 4;
-                return Promise.all(result = brands.filter(_asyncToGenerator(regeneratorRuntime.mark(function _callee(brand) {
-                    var data;
-                    return regeneratorRuntime.wrap(function _callee$(_ctx) {
-                        while(1)switch(_ctx.prev = _ctx.next){
-                            case 0:
-                                _ctx.next = 2;
-                                return CatalogFilter({
-                                    filter: "brand;eq;\"".concat(brand._id, "\""),
-                                    limit: 1
-                                }).catch(function() {
-                                    return null;
-                                });
-                            case 2:
-                                data = _ctx.sent;
-                                return _ctx.abrupt("return", !!(data === null || data === void 0 ? void 0 : data.results));
-                            case 4:
-                            case "end":
-                                return _ctx.stop();
-                        }
-                    }, _callee);
-                }))));
-            case 4:
-                _ctx1.next = 9;
-                break;
-            case 6:
-                _ctx1.prev = 6;
-                _ctx1.t0 = _ctx1["catch"](1);
-                throw new Error("Could not filter brands. ".concat(_ctx1.t0 === null || _ctx1.t0 === void 0 ? void 0 : _ctx1.t0.message, " "));
-            case 9:
-                return _ctx1.abrupt("return", result);
-            case 10:
-            case "end":
-                return _ctx1.stop();
-        }
-    }, _callee1, null, [
-        [
-            1,
-            6
-        ]
-    ]);
-}));
+export var processBrandsQuery = function() {
+    var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
+        var ref2, allBrands, publishedBrands, filteredBrands;
+        return regeneratorRuntime.wrap(function _callee$(_ctx) {
+            while(1)switch(_ctx.prev = _ctx.next){
+                case 0:
+                    ;
+                    _ctx.next = 3;
+                    return BrandsFilter({
+                        filter: 'parent;exists;false'
+                    });
+                case 3:
+                    allBrands = _ctx.sent;
+                    publishedBrands = allBrands === null || allBrands === void 0 ? void 0 : (ref2 = allBrands.results) === null || ref2 === void 0 ? void 0 : ref2.filter(function(brand) {
+                        var ref, ref1;
+                        return ((ref = brand.storeStatus) === null || ref === void 0 ? void 0 : (ref1 = ref[0]) === null || ref1 === void 0 ? void 0 : ref1.status) === StoreStatusDTOStatusEnum.Published;
+                    });
+                    _ctx.next = 7;
+                    return filterBrands(publishedBrands);
+                case 7:
+                    filteredBrands = _ctx.sent;
+                    return _ctx.abrupt("return", filteredBrands);
+                case 9:
+                case "end":
+                    return _ctx.stop();
+            }
+        }, _callee);
+    }));
+    return function processBrandsQuery() {
+        return _ref.apply(this, arguments);
+    };
+}();
+var filterBrands = function() {
+    var _ref1 = _asyncToGenerator(regeneratorRuntime.mark(function _callee1(brands) {
+        var result;
+        return regeneratorRuntime.wrap(function _callee$(_ctx1) {
+            while(1)switch(_ctx1.prev = _ctx1.next){
+                case 0:
+                    ;
+                    _ctx1.prev = 1;
+                    _ctx1.next = 4;
+                    return Promise.all(result = brands.filter(function() {
+                        var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(brand) {
+                            var data;
+                            return regeneratorRuntime.wrap(function _callee$(_ctx) {
+                                while(1)switch(_ctx.prev = _ctx.next){
+                                    case 0:
+                                        _ctx.next = 2;
+                                        return CatalogFilter({
+                                            filter: "brand;eq;\"".concat(brand._id, "\""),
+                                            limit: 1
+                                        }).catch(function() {
+                                            return null;
+                                        });
+                                    case 2:
+                                        data = _ctx.sent;
+                                        return _ctx.abrupt("return", !!(data === null || data === void 0 ? void 0 : data.results));
+                                    case 4:
+                                    case "end":
+                                        return _ctx.stop();
+                                }
+                            }, _callee);
+                        }));
+                        return function(brand) {
+                            return _ref.apply(this, arguments);
+                        };
+                    }()));
+                case 4:
+                    _ctx1.next = 9;
+                    break;
+                case 6:
+                    _ctx1.prev = 6;
+                    _ctx1.t0 = _ctx1["catch"](1);
+                    throw new Error("Could not filter brands. ".concat(_ctx1.t0 === null || _ctx1.t0 === void 0 ? void 0 : _ctx1.t0.message, " "));
+                case 9:
+                    return _ctx1.abrupt("return", result);
+                case 10:
+                case "end":
+                    return _ctx1.stop();
+            }
+        }, _callee1, null, [
+            [
+                1,
+                6
+            ]
+        ]);
+    }));
+    return function filterBrands(brands) {
+        return _ref1.apply(this, arguments);
+    };
+}();

package/dist/esm/build/api/query/fetchStore.js

@@ -29,23 +29,28 @@ function _asyncToGenerator(fn) {
         });
     };
 }
-export var fetchStore = _asyncToGenerator(regeneratorRuntime.mark(function _callee(storeKey) {
-    var storeAPI;
-    return regeneratorRuntime.wrap(function _callee$(_ctx) {
-        while(1)switch(_ctx.prev = _ctx.next){
-            case 0:
-                storeAPI = new StoresAPI(new Configuration({
-                    basePath: process.env.API_HOST,
-                    fetchApi: require('node-fetch'),
-                    token: process.env.API_KEY
-                }));
-                _ctx.next = 3;
-                return storeAPI.getByKey(storeKey);
-            case 3:
-                return _ctx.abrupt("return", _ctx.sent);
-            case 4:
-            case "end":
-                return _ctx.stop();
-        }
-    }, _callee);
-}));
+export var fetchStore = function() {
+    var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(storeKey) {
+        var storeAPI;
+        return regeneratorRuntime.wrap(function _callee$(_ctx) {
+            while(1)switch(_ctx.prev = _ctx.next){
+                case 0:
+                    storeAPI = new StoresAPI(new Configuration({
+                        basePath: process.env.API_HOST,
+                        fetchApi: require('node-fetch'),
+                        token: process.env.API_KEY
+                    }));
+                    _ctx.next = 3;
+                    return storeAPI.getByKey(storeKey);
+                case 3:
+                    return _ctx.abrupt("return", _ctx.sent);
+                case 4:
+                case "end":
+                    return _ctx.stop();
+            }
+        }, _callee);
+    }));
+    return function fetchStore(storeKey) {
+        return _ref.apply(this, arguments);
+    };
+}();

package/dist/esm/checkout/api/keys.js

@@ -1,7 +1,17 @@
 export var CheckoutQueryKeysEnum;
-(function(CheckoutQueryKeysEnum) {
-})(CheckoutQueryKeysEnum || (CheckoutQueryKeysEnum = {
-}));
+(function(CheckoutQueryKeysEnum) {})(CheckoutQueryKeysEnum || (CheckoutQueryKeysEnum = {}));
 export var getVerifyBoricaResponseKey = function(order) {
     return "Borica Response for Order: ".concat(order);
 };
+export var getBnpLoanCalculatorKey = function(preferredInstallmentCentAmount) {
+    return [
+        'bnp-loan-calculator',
+        preferredInstallmentCentAmount
+    ];
+};
+export var getUniCreditLoanCalculatorKey = function(downPaymentCentAmount) {
+    return [
+        'uni-credit-calculator',
+        downPaymentCentAmount
+    ];
+};

package/dist/esm/checkout/api/queries/index.js

@@ -1 +1,3 @@
 export * from './useVerifyBoricaResponseQuery';
+export * from './useBnpCalculateForCartQuery';
+export * from './useUniCreditCalculateForCartQuery';

package/dist/esm/checkout/api/queries/useBnpCalculateForCartQuery.js

@@ -0,0 +1,50 @@
+import regeneratorRuntime from "regenerator-runtime";
+import React from 'react';
+import { useQuery } from 'react-query';
+import { MyPaymentsBnpCalculateLoanOrder } from '@sentecacommerce/sdk';
+import { getBnpLoanCalculatorKey } from '../keys';
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+export var useBnpCalculateForCartQuery = function(props) {
+    return useQuery(getBnpLoanCalculatorKey(props.preferredInstallmentCentAmount), _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
+        return regeneratorRuntime.wrap(function _callee$(_ctx) {
+            while(1)switch(_ctx.prev = _ctx.next){
+                case 0:
+                    _ctx.next = 2;
+                    return MyPaymentsBnpCalculateLoanOrder(props);
+                case 2:
+                    return _ctx.abrupt("return", _ctx.sent);
+                case 3:
+                case "end":
+                    return _ctx.stop();
+            }
+        }, _callee);
+    })));
+};

package/dist/esm/checkout/api/queries/useUniCreditCalculateForCartQuery.js

@@ -0,0 +1,50 @@
+import regeneratorRuntime from "regenerator-runtime";
+import React from 'react';
+import { useQuery } from 'react-query';
+import { MyPaymentsUnicreditCalculateLoanOrder } from '@sentecacommerce/sdk';
+import { getUniCreditLoanCalculatorKey } from '../../..';
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+export var useUniCreditCalculateForCartQuery = function(props) {
+    return useQuery(getUniCreditLoanCalculatorKey(props.downPaymentCentAmount), _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
+        return regeneratorRuntime.wrap(function _callee$(_ctx) {
+            while(1)switch(_ctx.prev = _ctx.next){
+                case 0:
+                    _ctx.next = 2;
+                    return MyPaymentsUnicreditCalculateLoanOrder(props);
+                case 2:
+                    return _ctx.abrupt("return", _ctx.sent);
+                case 3:
+                case "end":
+                    return _ctx.stop();
+            }
+        }, _callee);
+    })));
+};

package/dist/esm/checkout/contexts/BoricaResponseContext.js

@@ -1,6 +1,5 @@
 import React, { createContext, useContext } from 'react';
-var BoricaResponseContext = /*#__PURE__*/ createContext({
-});
+var BoricaResponseContext = /*#__PURE__*/ createContext({});
 export var BoricaResponseProvider = function(param) {
     var children = param.children, response = param.response;
     return(/*#__PURE__*/ React.createElement(BoricaResponseContext.Provider, {

package/dist/esm/checkout/contexts/PaypalResponseContext.js

@@ -1,6 +1,5 @@
 import React, { createContext, useContext } from 'react';
-var PaypalResponseContext = /*#__PURE__*/ createContext({
-});
+var PaypalResponseContext = /*#__PURE__*/ createContext({});
 export var PaypalResponseProvider = function(param) {
     var children = param.children, response = param.response;
     return(/*#__PURE__*/ React.createElement(PaypalResponseContext.Provider, {

package/dist/esm/checkout/contexts/UniCreditResponseContext.js

@@ -0,0 +1,13 @@
+import React, { createContext, useContext } from 'react';
+var UniCreditResponseContext = /*#__PURE__*/ createContext({});
+export var UniCreditResponseProvider = function(param) {
+    var children = param.children, response = param.response;
+    return(/*#__PURE__*/ React.createElement(UniCreditResponseContext.Provider, {
+        value: response
+    }, children));
+};
+export var useUniCreditResponse = function() {
+    var context = useContext(UniCreditResponseContext);
+    if (!context) throw new Error('useUniCreditResponse hook must be within UniCreditResponseProvider');
+    return context;
+};

package/dist/esm/checkout/contexts/index.js

@@ -1,2 +1,3 @@
 export * from './BoricaResponseContext';
 export * from './PaypalResponseContext';
+export * from './UniCreditResponseContext';

package/dist/esm/checkout/hooks/index.js

@@ -1 +1,3 @@
 export * from './useVerifyBoricaResponse';
+export * from './useBnpCalculateForCart';
+export * from './useUniCreditCalculateForCart';