@smg-automotive/filters 2.1.0 → 2.1.1-fix-declarations.1

package/dist/cjs/index.js

@@ -216,131 +216,37 @@ exports.LicenseCategory = void 0;
     LicenseCategory["M"] = "m";
 })(exports.LicenseCategory || (exports.LicenseCategory = {}));
 
-var FilterContext = React.createContext(null);
-var useFilterContext = function () {
-    var context = React.useContext(FilterContext);
+const FilterContext = React.createContext(null);
+const useFilterContext = () => {
+    const context = React.useContext(FilterContext);
     if (!context) {
         throw new Error('useFilterContext must be used within a FilterProvider');
     }
     return context;
 };
-var FilterProvider = function (_a) {
-    var t = _a.t, histogramRanges = _a.histogramRanges, brand = _a.brand, referenceData = _a.referenceData, language = _a.language, children = _a.children;
-    var context = React.useMemo(function () { return ({
-        t: t,
-        brand: brand,
-        histogramRanges: histogramRanges,
-        referenceData: referenceData,
-        language: language,
-    }); }, [t, brand, histogramRanges, referenceData, language]);
+const FilterProvider = ({ t, histogramRanges, brand, referenceData, language, children, }) => {
+    const context = React.useMemo(() => ({
+        t,
+        brand,
+        histogramRanges,
+        referenceData,
+        language,
+    }), [t, brand, histogramRanges, referenceData, language]);
     return (React.createElement(FilterContext.Provider, { value: context }, children));
 };
 
-var resetAllFilters = function () {
+const resetAllFilters = () => {
     if (typeof window !== 'undefined') {
         window.dispatchEvent(new Event('reset-all-filters'));
     }
 };
-var useResetAllFilters = function (reset) {
-    React.useEffect(function () {
+const useResetAllFilters = (reset) => {
+    React.useEffect(() => {
         window.addEventListener('reset-all-filters', reset);
-        return function () { return window.removeEventListener('reset-all-filters', reset); };
+        return () => window.removeEventListener('reset-all-filters', reset);
     }, [reset]);
 };
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(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);
-};
-
-function __rest(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;
-}
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-function __spreadArray(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));
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 var Brand;
 (function (Brand) {
     Brand["AutoScout24"] = "autoscout24";
@@ -348,17 +254,16 @@ var Brand;
 })(Brand || (Brand = {}));
 
 /** @internal */
-var filtersClient = apiClientPkg.ApiClient({
-    baseUrl: "https://".concat(process.env.API_ROOT, "/").concat(process.env.API_VERSION),
+const filtersClient = apiClientPkg.ApiClient({
+    baseUrl: `https://${process.env.API_ROOT}/${process.env.API_VERSION}`,
 });
 
 function transformSearchConfigurationResponse(data) {
-    var result = {};
-    for (var _i = 0, _a = Object.keys(data); _i < _a.length; _i++) {
-        var key = _a[_i];
-        var arr = data[key];
+    const result = {};
+    for (const key of Object.keys(data)) {
+        const arr = data[key];
         if (Array.isArray(arr)) {
-            result[key] = arr.reduce(function (acc, value) {
+            result[key] = arr.reduce((acc, value) => {
                 acc[value] = 0;
                 return acc;
             }, {});
@@ -366,46 +271,28 @@ function transformSearchConfigurationResponse(data) {
     }
     return result;
 }
-var brands = [Brand.AutoScout24, Brand.MotoScout24];
-function fetchSearchConfiguration() {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, autoscout24Data, motoscout24Data;
-        var _b;
-        var _this = this;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, Promise.all(brands.map(function (brand) { return __awaiter(_this, void 0, void 0, function () {
-                        var response, body;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, filtersClient
-                                        .path('search-configuration')
-                                        .get({ searchParams: { brand: brand } })];
-                                case 1:
-                                    response = _a.sent();
-                                    if (!response.ok) {
-                                        throw new Error("Failed to fetch search configuration for ".concat(brand, ": ").concat(response.status));
-                                    }
-                                    body = response.body;
-                                    if (!body) {
-                                        throw new Error("Empty search configuration response for brand ".concat(brand));
-                                    }
-                                    return [2 /*return*/, transformSearchConfigurationResponse(body)];
-                            }
-                        });
-                    }); }))];
-                case 1:
-                    _a = _c.sent(), autoscout24Data = _a[0], motoscout24Data = _a[1];
-                    return [2 /*return*/, (_b = {},
-                            _b[Brand.AutoScout24] = autoscout24Data,
-                            _b[Brand.MotoScout24] = motoscout24Data,
-                            _b)];
-            }
-        });
-    });
+const brands = [Brand.AutoScout24, Brand.MotoScout24];
+async function fetchSearchConfiguration() {
+    const [autoscout24Data, motoscout24Data] = await Promise.all(brands.map(async (brand) => {
+        const response = await filtersClient
+            .path('search-configuration')
+            .get({ searchParams: { brand } });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch search configuration for ${brand}: ${response.status}`);
+        }
+        const body = response.body;
+        if (!body) {
+            throw new Error(`Empty search configuration response for brand ${brand}`);
+        }
+        return transformSearchConfigurationResponse(body);
+    }));
+    return {
+        [Brand.AutoScout24]: autoscout24Data,
+        [Brand.MotoScout24]: motoscout24Data,
+    };
 }
 
-var vehicleCategories = [
+const vehicleCategories = [
     exports.VehicleCategory.Car,
     exports.VehicleCategory.Utility,
     exports.VehicleCategory.Motorcycle,
@@ -413,46 +300,28 @@ var vehicleCategories = [
     exports.VehicleCategory.Trailer,
     exports.VehicleCategory.Camper,
 ];
-function fetchReferenceData() {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, car, utility, motorcycle, truck, trailer, camper;
-        var _b;
-        var _this = this;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, Promise.all(vehicleCategories.map(function (vehicleCategory) { return __awaiter(_this, void 0, void 0, function () {
-                        var response, body;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, filtersClient
-                                        .path('reference-data')
-                                        .get({ searchParams: { vehicleCategory: vehicleCategory } })];
-                                case 1:
-                                    response = _a.sent();
-                                    if (!response.ok) {
-                                        throw new Error("Failed to fetch reference data for ".concat(vehicleCategory, ": ").concat(response.status));
-                                    }
-                                    body = response.body;
-                                    if (!body) {
-                                        throw new Error("Empty reference data response for vehicle category ".concat(vehicleCategory));
-                                    }
-                                    return [2 /*return*/, body];
-                            }
-                        });
-                    }); }))];
-                case 1:
-                    _a = _c.sent(), car = _a[0], utility = _a[1], motorcycle = _a[2], truck = _a[3], trailer = _a[4], camper = _a[5];
-                    return [2 /*return*/, (_b = {},
-                            _b[exports.VehicleCategory.Car] = car,
-                            _b[exports.VehicleCategory.Utility] = utility,
-                            _b[exports.VehicleCategory.Motorcycle] = motorcycle,
-                            _b[exports.VehicleCategory.Truck] = truck,
-                            _b[exports.VehicleCategory.Trailer] = trailer,
-                            _b[exports.VehicleCategory.Camper] = camper,
-                            _b)];
-            }
-        });
-    });
+async function fetchReferenceData() {
+    const [car, utility, motorcycle, truck, trailer, camper] = await Promise.all(vehicleCategories.map(async (vehicleCategory) => {
+        const response = await filtersClient
+            .path('reference-data')
+            .get({ searchParams: { vehicleCategory } });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch reference data for ${vehicleCategory}: ${response.status}`);
+        }
+        const body = response.body;
+        if (!body) {
+            throw new Error(`Empty reference data response for vehicle category ${vehicleCategory}`);
+        }
+        return body;
+    }));
+    return {
+        [exports.VehicleCategory.Car]: car,
+        [exports.VehicleCategory.Utility]: utility,
+        [exports.VehicleCategory.Motorcycle]: motorcycle,
+        [exports.VehicleCategory.Truck]: truck,
+        [exports.VehicleCategory.Trailer]: trailer,
+        [exports.VehicleCategory.Camper]: camper,
+    };
 }
 
 var batteryHealthPercentage$3 = "Batteria (SoH)";
@@ -935,18 +804,18 @@ var de = {
 	"bodyType.wood-transporter": "Holz-Transporter"
 };
 
-var filterTranslationsDe = de;
-var filterTranslationsEn = en;
-var filterTranslationsFr = fr;
-var filterTranslationsIt = it;
-var filterTranslations = {
+const filterTranslationsDe = de;
+const filterTranslationsEn = en;
+const filterTranslationsFr = fr;
+const filterTranslationsIt = it;
+const filterTranslations = {
     de: filterTranslationsDe,
     en: filterTranslationsEn,
     fr: filterTranslationsFr,
     it: filterTranslationsIt,
 };
 
-var validQueryKeys = {
+const validQueryKeys = {
     ageFrom: true,
     availableForExchangeOnly: true,
     axisFrom: true,
@@ -1042,26 +911,23 @@ var validQueryKeys = {
     weightTotalFrom: true,
     weightTotalTo: true,
 };
-var cleanQuery = function (query) {
-    var _a;
-    var acc = {};
-    for (var _i = 0, _b = Object.keys(query); _i < _b.length; _i++) {
-        var key = _b[_i];
+const cleanQuery = (query) => {
+    const acc = {};
+    for (const key of Object.keys(query)) {
         if (key in validQueryKeys) {
-            Object.assign(acc, (_a = {}, _a[key] = query[key], _a));
+            Object.assign(acc, { [key]: query[key] });
         }
     }
     return acc;
 };
 
-var convertIntervalListToFacetRange = function (intervalList) {
-    var generatedFacetRanges = [];
-    intervalList.forEach(function (_a) {
-        var from = _a.from, to = _a.to, increment = _a.increment;
-        var currentRangeFrom = from;
+const convertIntervalListToFacetRange = (intervalList) => {
+    const generatedFacetRanges = [];
+    intervalList.forEach(({ from, to, increment }) => {
+        let currentRangeFrom = from;
         while (currentRangeFrom < to) {
-            var currentRangeTo = Math.min(currentRangeFrom + increment, to);
-            var rangeKey = "".concat(currentRangeFrom, "-").concat(currentRangeTo);
+            const currentRangeTo = Math.min(currentRangeFrom + increment, to);
+            const rangeKey = `${currentRangeFrom}-${currentRangeTo}`;
             generatedFacetRanges.push({
                 from: currentRangeFrom,
                 to: currentRangeTo,
@@ -1070,55 +936,52 @@ var convertIntervalListToFacetRange = function (intervalList) {
             currentRangeFrom = currentRangeTo;
         }
     });
-    var lastIntervalTo = intervalList[intervalList.length - 1].to;
+    const { to: lastIntervalTo } = intervalList[intervalList.length - 1];
     generatedFacetRanges.push({
         from: lastIntervalTo,
         to: undefined,
-        key: "".concat(lastIntervalTo, "-*"),
+        key: `${lastIntervalTo}-*`,
     });
     return generatedFacetRanges;
 };
-var convertIntervalListToRangeSliderScale = function (intervalList) { return convertIntervalListToFacetRange(intervalList).map(function (_a) {
-    var from = _a.from;
-    return from;
-}); };
-var batteryHealthPercentageScale = convertIntervalListToRangeSliderScale([{ from: 10, to: 100, increment: 5 }]);
+const convertIntervalListToRangeSliderScale = (intervalList) => convertIntervalListToFacetRange(intervalList).map(({ from }) => from);
+const batteryHealthPercentageScale = convertIntervalListToRangeSliderScale([{ from: 10, to: 100, increment: 5 }]);
 
-var Unit = {
+const Unit = {
     kilometers: 'km',
     swissFrancs: 'CHF',
     percentage: '%',
 };
-var formatNumber = function (value) {
+const formatNumber = (value) => {
     return (value || 0).toLocaleString('de-ch').replace(/’/g, "'");
 };
-var formatPriceWithCurrency = function (price, options) {
-    if (options === void 0) { options = { minimumFractionDigits: 2, maximumFractionDigits: 2 }; }
-    return typeof price === 'number' && !Number.isNaN(price)
-        ? price
-            .toLocaleString('de-ch', __assign(__assign({}, options), { currency: 'CHF', currencyDisplay: 'symbol', style: 'currency' }))
-            .replace('.00', '.–')
-            .replace(/’/g, "'")
-        : null;
-};
-var formatValueWithUnit = function (_a) {
-    var _b, _c;
-    var value = _a.value, unit = _a.unit, _d = _a.options, options = _d === void 0 ? { thousandSeparator: true } : _d;
-    var parsedValue = parseFloat(value);
+const formatPriceWithCurrency = (price, options = { minimumFractionDigits: 2, maximumFractionDigits: 2 }) => typeof price === 'number' && !Number.isNaN(price)
+    ? price
+        .toLocaleString('de-ch', {
+        ...options,
+        currency: 'CHF',
+        currencyDisplay: 'symbol',
+        style: 'currency',
+    })
+        .replace('.00', '.–')
+        .replace(/’/g, "'")
+    : null;
+const formatValueWithUnit = ({ value, unit, options = { thousandSeparator: true }, }) => {
+    const parsedValue = parseFloat(value);
     if (Number.isNaN(parsedValue)) {
         return null;
     }
     if (unit === Unit.swissFrancs) {
         return formatPriceWithCurrency(parsedValue, {
-            maximumFractionDigits: (_b = options === null || options === void 0 ? void 0 : options.fixedDecimalSpaces) !== null && _b !== void 0 ? _b : 0,
-            minimumFractionDigits: (_c = options === null || options === void 0 ? void 0 : options.fixedDecimalSpaces) !== null && _c !== void 0 ? _c : 0,
+            maximumFractionDigits: options?.fixedDecimalSpaces ?? 0,
+            minimumFractionDigits: options?.fixedDecimalSpaces ?? 0,
         });
     }
-    var formattedNumber = value;
-    if (options === null || options === void 0 ? void 0 : options.fixedDecimalSpaces) {
+    let formattedNumber = value;
+    if (options?.fixedDecimalSpaces) {
         formattedNumber = parsedValue.toFixed(options.fixedDecimalSpaces);
     }
-    if (options === null || options === void 0 ? void 0 : options.thousandSeparator) {
+    if (options?.thousandSeparator) {
         formattedNumber = parsedValue
             .toLocaleString('de-ch', {
             maximumFractionDigits: options.fixedDecimalSpaces,
@@ -1126,26 +989,24 @@ var formatValueWithUnit = function (_a) {
         })
             .replace(/’/g, "'");
     }
-    return "".concat(formattedNumber, " ").concat(unit);
+    return `${formattedNumber} ${unit}`;
 };
 
-var getRangeDisplayValue = function (_a) {
-    var from = _a.from, to = _a.to, unit = _a.unit, t = _a.t;
-    var formatter = unit
-        ? function (value) { return formatValueWithUnit({ value: value, unit: unit }); }
-        : function (value) { return value; };
+const getRangeDisplayValue = ({ from, to, unit, t, }) => {
+    const formatter = unit
+        ? (value) => formatValueWithUnit({ value, unit })
+        : (value) => value;
     if (from && to)
-        return "".concat(formatter(from), " - ").concat(formatter(to));
+        return `${formatter(from)} - ${formatter(to)}`;
     if (from)
-        return "".concat(t('filtersPkg.from'), " ").concat(formatter(from));
+        return `${t('filtersPkg.from')} ${formatter(from)}`;
     if (to)
-        return "".concat(t('filtersPkg.to'), " ").concat(formatter(to));
+        return `${t('filtersPkg.to')} ${formatter(to)}`;
     return null;
 };
-var inRange = function (_a) {
-    var value = _a.value, minValue = _a.minValue, maxValue = _a.maxValue;
-    var hasMaxValue = typeof maxValue === 'number';
-    var hasMinValue = typeof minValue === 'number';
+const inRange = ({ value, minValue, maxValue, }) => {
+    const hasMaxValue = typeof maxValue === 'number';
+    const hasMinValue = typeof minValue === 'number';
     if (hasMaxValue && hasMinValue) {
         return value >= minValue && value <= maxValue;
     }
@@ -1157,145 +1018,140 @@ var inRange = function (_a) {
     }
     return true;
 };
-var getMaxValueFromFacetRangeGroups = function (facets) {
+const getMaxValueFromFacetRangeGroups = (facets) => {
     if (!facets) {
         return '';
     }
-    var intervalList = Object.keys(facets).map(function (el) {
-        var _a = el.split('-'), to = _a[1];
-        var parsedStringToNumber = Number(to);
+    const intervalList = Object.keys(facets).map((el) => {
+        const [, to] = el.split('-');
+        const parsedStringToNumber = Number(to);
         return Number.isFinite(parsedStringToNumber) ? parsedStringToNumber : 0;
     });
-    if (!(intervalList === null || intervalList === void 0 ? void 0 : intervalList.length))
+    if (!intervalList?.length)
         return '';
-    var maxValue = Math.max.apply(Math, intervalList);
-    return "".concat(formatNumber(maxValue), "+");
+    const maxValue = Math.max(...intervalList);
+    return `${formatNumber(maxValue)}+`;
 };
-var getMaxValueFromRangeSliderScale = function (scale, limit) {
+const getMaxValueFromRangeSliderScale = (scale, limit) => {
     if (!scale.length) {
         return '';
     }
-    var maxValue = Math.max.apply(Math, scale);
-    var formattedMaxValue = formatNumber(maxValue);
+    const maxValue = Math.max(...scale);
+    const formattedMaxValue = formatNumber(maxValue);
     if (maxValue === limit) {
         return formattedMaxValue;
     }
-    return "".concat(formattedMaxValue, "+");
+    return `${formattedMaxValue}+`;
 };
-var convertFacetRangesToHistogramFacet = function (_a) {
-    var defaultFacets = _a.defaultFacets, facets = _a.facets;
+const convertFacetRangesToHistogramFacet = ({ defaultFacets, facets, }) => {
     if (!defaultFacets) {
         return [];
     }
-    return Object.entries(defaultFacets).map(function (_a) {
-        var key = _a[0], value = _a[1];
-        var _b = key.split('-'), from = _b[0], to = _b[1];
+    return Object.entries(defaultFacets).map(([key, value]) => {
+        const [from, to] = key.split('-');
         return {
             from: Number(from),
             to: Number.isFinite(Number(to)) ? Number(to) : undefined,
-            value: (facets === null || facets === void 0 ? void 0 : facets[key]) || value,
+            value: facets?.[key] || value,
         };
     });
 };
-var getRangeSliderScale = function (defaultFacets) {
+const getRangeSliderScale = (defaultFacets) => {
     return Object.keys(defaultFacets)
-        .map(function (key) {
-        var _a = key.split('-'); _a[0]; var to = _a[1];
+        .map((key) => {
+        const [_from, to] = key.split('-');
         return Number(to);
     })
         .filter(Boolean);
 };
-var getFacetConfig = function (_a) {
-    var brand = _a.brand, facets = _a.facets, loadHistogram = _a.loadHistogram, _b = _a.chartHeight, chartHeight = _b === void 0 ? '3xl' : _b, histogramRangesWithDefaultValue = _a.histogramRangesWithDefaultValue, name = _a.name;
-    var defaultFacets = (histogramRangesWithDefaultValue === null || histogramRangesWithDefaultValue === void 0 ? void 0 : histogramRangesWithDefaultValue[brand][name]) || {};
-    var histogramFacet = loadHistogram
+const getFacetConfig = ({ brand, facets, loadHistogram, chartHeight = '3xl', histogramRangesWithDefaultValue, name, }) => {
+    const defaultFacets = histogramRangesWithDefaultValue?.[brand][name] || {};
+    const histogramFacet = loadHistogram
         ? convertFacetRangesToHistogramFacet({
-            defaultFacets: defaultFacets,
-            facets: facets === null || facets === void 0 ? void 0 : facets[name],
+            defaultFacets,
+            facets: facets?.[name],
         })
         : null;
-    var scaleProps = loadHistogram && histogramFacet
-        ? { facets: histogramFacet, chartHeight: chartHeight }
+    const scaleProps = loadHistogram && histogramFacet
+        ? { facets: histogramFacet, chartHeight }
         : {
             rangeSliderScale: getRangeSliderScale(defaultFacets),
         };
     return {
-        defaultFacets: defaultFacets,
-        scaleProps: scaleProps,
+        defaultFacets,
+        scaleProps,
     };
 };
 
-var useRangeFilter = function (_a) {
-    var _b;
-    var from = _a.from, to = _a.to, minValue = _a.minValue, maxValue = _a.maxValue, filters = _a.filters, onAddFilter = _a.onAddFilter, onChange = _a.onChange, unit = _a.unit, toPlaceholder = _a.toPlaceholder, fromPlaceholder = _a.fromPlaceholder;
-    var t = useFilterContext().t;
-    var filterFromValue = filters[from];
-    var filterToValue = filters[to];
-    var _c = React.useState((_b = {},
-        _b[from] = filterFromValue,
-        _b[to] = filterToValue,
-        _b)), range = _c[0], setRange = _c[1];
-    React.useEffect(function () {
-        setRange(function (prevState) {
-            var _a;
+const useRangeFilter = ({ from, to, minValue, maxValue, filters, onAddFilter, onChange, unit, toPlaceholder, fromPlaceholder, }) => {
+    const { t } = useFilterContext();
+    const filterFromValue = filters[from];
+    const filterToValue = filters[to];
+    const [range, setRange] = React.useState({
+        [from]: filterFromValue,
+        [to]: filterToValue,
+    });
+    React.useEffect(() => {
+        setRange((prevState) => {
             if (prevState[from] === filterFromValue &&
                 prevState[to] === filterToValue)
                 return prevState;
-            return _a = {},
-                _a[from] = filterFromValue,
-                _a[to] = filterToValue,
-                _a;
+            return {
+                [from]: filterFromValue,
+                [to]: filterToValue,
+            };
         });
     }, [filterFromValue, filterToValue, from, to]);
-    var handleChange = function (_a) {
-        var _b;
-        var value = _a.value, name = _a.name, changeType = _a.changeType;
-        var isValid = function () {
+    const handleChange = ({ value, name, changeType, }) => {
+        const isValid = () => {
             if (!value)
                 return true;
-            return inRange({ value: value, minValue: minValue, maxValue: maxValue });
+            return inRange({ value, minValue, maxValue });
         };
         if (!isValid() || value === range[name])
             return;
-        var newState = __assign(__assign({}, range), (_b = {}, _b[name] = value !== null && value !== void 0 ? value : undefined, _b));
+        const newState = {
+            ...range,
+            [name]: value ?? undefined,
+        };
         setRange(newState);
-        onChange === null || onChange === void 0 ? void 0 : onChange(newState);
+        onChange?.(newState);
         if (value && onAddFilter) {
             onAddFilter({
                 appliedFilter: name,
-                value: value,
+                value,
                 formattedValue: unit
-                    ? formatValueWithUnit({ value: value, unit: unit })
+                    ? formatValueWithUnit({ value, unit })
                     : value.toString(),
-                changeType: changeType,
+                changeType,
             });
         }
     };
-    var reset = function () {
-        var _a;
-        var resetQuery = (_a = {},
-            _a[from] = undefined,
-            _a[to] = undefined,
-            _a);
+    const reset = () => {
+        const resetQuery = {
+            [from]: undefined,
+            [to]: undefined,
+        };
         setRange(resetQuery);
         return resetQuery;
     };
     useResetAllFilters(reset);
-    var valueFrom = range[from];
-    var valueTo = range[to];
-    var numberOfAppliedFilters = [valueFrom, valueTo].filter(Boolean).length;
-    var props = {
-        unit: unit,
+    const valueFrom = range[from];
+    const valueTo = range[to];
+    const numberOfAppliedFilters = [valueFrom, valueTo].filter(Boolean).length;
+    const props = {
+        unit,
         from: {
             name: from,
             value: valueFrom,
-            placeholder: fromPlaceholder !== null && fromPlaceholder !== void 0 ? fromPlaceholder : minValue === null || minValue === void 0 ? void 0 : minValue.toString(),
+            placeholder: fromPlaceholder ?? minValue?.toString(),
             ariaLabel: t('filtersPkg.from'),
         },
         to: {
             name: to,
             value: valueTo,
-            placeholder: toPlaceholder !== null && toPlaceholder !== void 0 ? toPlaceholder : (typeof maxValue === 'number' ? "".concat(maxValue, "+") : undefined),
+            placeholder: toPlaceholder ??
+                (typeof maxValue === 'number' ? `${maxValue}+` : undefined),
             ariaLabel: t('filtersPkg.to'),
         },
         onChange: handleChange,
@@ -1304,78 +1160,74 @@ var useRangeFilter = function (_a) {
         max: maxValue,
     };
     return {
-        numberOfAppliedFilters: numberOfAppliedFilters,
+        numberOfAppliedFilters,
         isApplied: !!numberOfAppliedFilters,
-        props: props,
+        props,
         state: range,
-        reset: reset,
+        reset,
     };
 };
 
-var unit$2 = Unit.percentage;
-var useBatteryHealthPercentageFilter = function (_a) {
-    var filters = _a.filters, onAddFilter = _a.onAddFilter, onChange = _a.onChange;
-    var t = useFilterContext().t;
-    var _b = useRangeFilter({
+const unit$2 = Unit.percentage;
+const useBatteryHealthPercentageFilter = ({ filters, onAddFilter, onChange }) => {
+    const { t } = useFilterContext();
+    const { props, ...rest } = useRangeFilter({
         unit: unit$2,
-        filters: filters,
+        filters,
         toPlaceholder: getMaxValueFromRangeSliderScale(batteryHealthPercentageScale, 100),
         from: 'batteryHealthPercentageFrom',
         to: 'batteryHealthPercentageTo',
         minValue: 10,
         maxValue: 100,
-        onAddFilter: onAddFilter,
-        onChange: onChange,
-    }), props = _b.props, rest = __rest(_b, ["props"]);
-    return __assign(__assign({ ui: (React.createElement(components.RangeFilterInputWithSlider, __assign({}, props, { rangeSliderScale: batteryHealthPercentageScale }))) }, rest), { label: t('filtersPkg.batteryHealthPercentage'), getDisplayValue: function (query) {
-            var _a = query || rest.state, batteryHealthPercentageFrom = _a.batteryHealthPercentageFrom, batteryHealthPercentageTo = _a.batteryHealthPercentageTo;
+        onAddFilter,
+        onChange,
+    });
+    return {
+        ui: (React.createElement(components.RangeFilterInputWithSlider, { ...props, rangeSliderScale: batteryHealthPercentageScale })),
+        ...rest,
+        label: t('filtersPkg.batteryHealthPercentage'),
+        getDisplayValue: (query) => {
+            const { batteryHealthPercentageFrom, batteryHealthPercentageTo } = query || rest.state;
             return (getRangeDisplayValue({
                 from: batteryHealthPercentageFrom,
                 to: batteryHealthPercentageTo,
                 unit: unit$2,
-                t: t,
+                t,
             }) || '');
-        } });
+        },
+    };
 };
 
-var getFacetForBooleanCheckboxFilter = function (facets, key) {
-    var _a, _b;
+const getFacetForBooleanCheckboxFilter = (facets, key) => {
     if (!facets)
         return null;
-    return (_b = (_a = facets === null || facets === void 0 ? void 0 : facets[key]) === null || _a === void 0 ? void 0 : _a['true']) !== null && _b !== void 0 ? _b : 0;
+    return facets?.[key]?.['true'] ?? 0;
 };
-var getBooleanDisplayValue = function (_a) {
-    var label = _a.label, filterKey = _a.filterKey, filters = _a.filters;
+const getBooleanDisplayValue = ({ label, filterKey, filters, }) => {
     return filters[filterKey] === true ? label : '';
 };
 
-var useBooleanFilter = function (_a) {
-    var filters = _a.filters, getFacet = _a.getFacet, options = _a.options, onChange = _a.onChange, onAddFilter = _a.onAddFilter;
-    var t = useFilterContext().t;
-    var generateState = React.useCallback(function () {
-        return Object.fromEntries(options.map(function (_a) {
-            var key = _a.key;
-            return [key, filters[key]];
-        }));
+const useBooleanFilter = ({ filters, getFacet, options, onChange, onAddFilter, }) => {
+    const { t } = useFilterContext();
+    const generateState = React.useCallback(() => {
+        return Object.fromEntries(options.map(({ key }) => [key, filters[key]]));
     }, [filters, options]);
-    var _b = React.useState(generateState()), state = _b[0], setState = _b[1];
-    React.useEffect(function () {
-        setState(function (prevState) {
-            var newState = generateState();
-            var hasChanged = Object.keys(newState).some(function (key) {
-                return prevState[key] !== newState[key];
-            });
+    const [state, setState] = React.useState(generateState());
+    React.useEffect(() => {
+        setState((prevState) => {
+            const newState = generateState();
+            const hasChanged = Object.keys(newState).some((key) => prevState[key] !== newState[key]);
             return hasChanged ? newState : prevState;
         });
     }, [generateState]);
-    var items = options.map(function (option) { return ({
+    const items = options.map((option) => ({
         key: option.key,
         label: t(option.translationKey),
         isChecked: !!state[option.key],
         facet: getFacet(option.key),
-    }); });
-    var reset = function () {
-        var newState = options.reduce(function (acc, option) {
+    }));
+    const reset = () => {
+        const newState = options.reduce((acc, option) => {
             acc[option.key] = undefined;
             return acc;
         }, {});
@@ -1383,11 +1235,13 @@ var useBooleanFilter = function (_a) {
         return newState;
     };
     useResetAllFilters(reset);
-    var onApply = function (updatedItem) {
-        var _a;
-        var newState = __assign(__assign({}, state), (_a = {}, _a[updatedItem.key] = updatedItem.isChecked || undefined, _a));
+    const onApply = (updatedItem) => {
+        const newState = {
+            ...state,
+            [updatedItem.key]: updatedItem.isChecked || undefined,
+        };
         setState(newState);
-        onChange === null || onChange === void 0 ? void 0 : onChange(newState);
+        onChange?.(newState);
         if (updatedItem.isChecked && onAddFilter) {
             onAddFilter({
                 appliedFilter: updatedItem.key,
@@ -1396,157 +1250,167 @@ var useBooleanFilter = function (_a) {
             });
         }
     };
-    var numberOfAppliedFilters = items.filter(function (item) { return item.isChecked; }).length;
-    var isApplied = !!numberOfAppliedFilters;
+    const numberOfAppliedFilters = items.filter((item) => item.isChecked).length;
+    const isApplied = !!numberOfAppliedFilters;
     return {
-        items: items,
-        reset: reset,
-        state: state,
-        isApplied: isApplied,
-        numberOfAppliedFilters: numberOfAppliedFilters,
-        onApply: onApply,
+        items,
+        reset,
+        state,
+        isApplied,
+        numberOfAppliedFilters,
+        onApply,
     };
 };
 
-var key = 'hasBatteryCertificateOnly';
-var option = {
-    key: key,
-    translationKey: "filtersPkg.".concat(key),
+const key = 'hasBatteryCertificateOnly';
+const option = {
+    key,
+    translationKey: `filtersPkg.${key}`,
 };
-var options = [option];
-var useHasBatteryCertificateKeyOnlyFilter = function (_a) {
-    var filters = _a.filters, onAddFilter = _a.onAddFilter, onChange = _a.onChange, facets = _a.facets;
-    var _b = useFilterContext(), t = _b.t, language = _b.language;
-    var label = t(option.translationKey);
-    var _c = useBooleanFilter({
-        filters: filters,
-        options: options,
-        getFacet: function (facetKey) {
-            return getFacetForBooleanCheckboxFilter(facets !== null && facets !== void 0 ? facets : null, facetKey);
-        },
-        onAddFilter: onAddFilter,
-        onChange: onChange,
-    }), items = _c.items, onApply = _c.onApply, rest = __rest(_c, ["items", "onApply"]);
-    return __assign({ ui: React.createElement(components.CheckboxFilter, { items: items, onApply: onApply, language: language }), label: label, getDisplayValue: function (query) {
-            return getBooleanDisplayValue({
-                label: label,
-                filterKey: key,
-                filters: query || rest.state,
-            });
-        } }, rest);
+const options = [option];
+const useHasBatteryCertificateKeyOnlyFilter = ({ filters, onAddFilter, onChange, facets }) => {
+    const { t, language } = useFilterContext();
+    const label = t(option.translationKey);
+    const { items, onApply, ...rest } = useBooleanFilter({
+        filters,
+        options,
+        getFacet: (facetKey) => getFacetForBooleanCheckboxFilter(facets ?? null, facetKey),
+        onAddFilter,
+        onChange,
+    });
+    return {
+        ui: React.createElement(components.CheckboxFilter, { items: items, onApply: onApply, language: language }),
+        label,
+        getDisplayValue: (query) => getBooleanDisplayValue({
+            label,
+            filterKey: key,
+            filters: query || rest.state,
+        }),
+        ...rest,
+    };
 };
 
-var minValue = 1900;
-var useFirstRegistrationYearFilter = function (_a) {
-    var filters = _a.filters, facets = _a.facets, onAddFilter = _a.onAddFilter, onChange = _a.onChange, loadHistogram = _a.loadHistogram, chartHeight = _a.chartHeight;
-    var _b = useFilterContext(), t = _b.t, brand = _b.brand, histogramRanges = _b.histogramRanges;
-    var maxValue = new Date().getFullYear();
-    var scaleProps = getFacetConfig({
-        brand: brand,
-        facets: facets,
-        loadHistogram: loadHistogram,
-        chartHeight: chartHeight,
+const minValue = 1900;
+const useFirstRegistrationYearFilter = ({ filters, facets, onAddFilter, onChange, loadHistogram, chartHeight, }) => {
+    const { t, brand, histogramRanges } = useFilterContext();
+    const maxValue = new Date().getFullYear();
+    const { scaleProps } = getFacetConfig({
+        brand,
+        facets,
+        loadHistogram,
+        chartHeight,
         histogramRangesWithDefaultValue: histogramRanges,
         name: 'firstRegistrationYearRanges',
-    }).scaleProps;
-    var _c = useRangeFilter({
-        filters: filters,
+    });
+    const { props, ...rest } = useRangeFilter({
+        filters,
         toPlaceholder: maxValue.toString(),
         from: 'firstRegistrationYearFrom',
         to: 'firstRegistrationYearTo',
-        minValue: minValue,
-        maxValue: maxValue,
-        onAddFilter: onAddFilter,
-        onChange: onChange,
-    }), props = _c.props, rest = __rest(_c, ["props"]);
-    return __assign(__assign({ ui: React.createElement(components.RangeFilterInputWithSlider, __assign({}, props, scaleProps)) }, rest), { label: t('filtersPkg.firstRegistrationYear'), getDisplayValue: function (query) {
-            var _a = query || rest.state, firstRegistrationYearFrom = _a.firstRegistrationYearFrom, firstRegistrationYearTo = _a.firstRegistrationYearTo;
+        minValue,
+        maxValue,
+        onAddFilter,
+        onChange,
+    });
+    return {
+        ui: React.createElement(components.RangeFilterInputWithSlider, { ...props, ...scaleProps }),
+        ...rest,
+        label: t('filtersPkg.firstRegistrationYear'),
+        getDisplayValue: (query) => {
+            const { firstRegistrationYearFrom, firstRegistrationYearTo } = query || rest.state;
             return (getRangeDisplayValue({
                 from: firstRegistrationYearFrom,
                 to: firstRegistrationYearTo,
-                t: t,
+                t,
             }) || '');
-        } });
+        },
+    };
 };
 
-var unit$1 = Unit.kilometers;
-var useMileageFilter = function (_a) {
-    var filters = _a.filters, facets = _a.facets, onAddFilter = _a.onAddFilter, onChange = _a.onChange, loadHistogram = _a.loadHistogram, chartHeight = _a.chartHeight;
-    var _b = useFilterContext(), t = _b.t, brand = _b.brand, histogramRanges = _b.histogramRanges;
-    var _c = getFacetConfig({
-        brand: brand,
-        facets: facets,
-        loadHistogram: loadHistogram,
-        chartHeight: chartHeight,
+const unit$1 = Unit.kilometers;
+const useMileageFilter = ({ filters, facets, onAddFilter, onChange, loadHistogram, chartHeight, }) => {
+    const { t, brand, histogramRanges } = useFilterContext();
+    const { defaultFacets, scaleProps } = getFacetConfig({
+        brand,
+        facets,
+        loadHistogram,
+        chartHeight,
         histogramRangesWithDefaultValue: histogramRanges,
         name: 'mileageRanges',
-    }), defaultFacets = _c.defaultFacets, scaleProps = _c.scaleProps;
-    var _d = useRangeFilter({
+    });
+    const { props, ...rest } = useRangeFilter({
         unit: unit$1,
-        filters: filters,
+        filters,
         toPlaceholder: getMaxValueFromFacetRangeGroups(defaultFacets),
         from: 'mileageFrom',
         to: 'mileageTo',
         minValue: 0,
         maxValue: 99999999,
-        onAddFilter: onAddFilter,
-        onChange: onChange,
-    }), props = _d.props, rest = __rest(_d, ["props"]);
-    return __assign(__assign({ ui: React.createElement(components.RangeFilterInputWithSlider, __assign({}, props, scaleProps)) }, rest), { label: t('filtersPkg.mileage'), getDisplayValue: function (query) {
-            var _a = query || rest.state, mileageFrom = _a.mileageFrom, mileageTo = _a.mileageTo;
+        onAddFilter,
+        onChange,
+    });
+    return {
+        ui: React.createElement(components.RangeFilterInputWithSlider, { ...props, ...scaleProps }),
+        ...rest,
+        label: t('filtersPkg.mileage'),
+        getDisplayValue: (query) => {
+            const { mileageFrom, mileageTo } = query || rest.state;
             return (getRangeDisplayValue({
                 from: mileageFrom,
                 to: mileageTo,
                 unit: unit$1,
-                t: t,
+                t,
             }) || '');
-        } });
+        },
+    };
 };
 
-var unit = Unit.swissFrancs;
-var usePriceFilter = function (_a) {
-    var filters = _a.filters, facets = _a.facets, onAddFilter = _a.onAddFilter, onChange = _a.onChange, loadHistogram = _a.loadHistogram, chartHeight = _a.chartHeight;
-    var _b = useFilterContext(), t = _b.t, brand = _b.brand, histogramRanges = _b.histogramRanges;
-    var _c = getFacetConfig({
-        brand: brand,
-        facets: facets,
-        loadHistogram: loadHistogram,
-        chartHeight: chartHeight,
+const unit = Unit.swissFrancs;
+const usePriceFilter = ({ filters, facets, onAddFilter, onChange, loadHistogram, chartHeight, }) => {
+    const { t, brand, histogramRanges } = useFilterContext();
+    const { defaultFacets, scaleProps } = getFacetConfig({
+        brand,
+        facets,
+        loadHistogram,
+        chartHeight,
         histogramRangesWithDefaultValue: histogramRanges,
         name: 'priceRanges',
-    }), defaultFacets = _c.defaultFacets, scaleProps = _c.scaleProps;
-    var _d = useRangeFilter({
-        unit: unit,
-        filters: filters,
+    });
+    const { props, ...rest } = useRangeFilter({
+        unit,
+        filters,
         toPlaceholder: getMaxValueFromFacetRangeGroups(defaultFacets),
         from: 'priceFrom',
         to: 'priceTo',
         minValue: 0,
         maxValue: 9999999,
-        onAddFilter: onAddFilter,
-        onChange: onChange,
-    }), props = _d.props, rest = __rest(_d, ["props"]);
-    return __assign(__assign({ ui: React.createElement(components.RangeFilterInputWithSlider, __assign({}, props, scaleProps)) }, rest), { label: t('filtersPkg.price'), getDisplayValue: function (query) {
-            var _a = query || rest.state, priceFrom = _a.priceFrom, priceTo = _a.priceTo;
+        onAddFilter,
+        onChange,
+    });
+    return {
+        ui: React.createElement(components.RangeFilterInputWithSlider, { ...props, ...scaleProps }),
+        ...rest,
+        label: t('filtersPkg.price'),
+        getDisplayValue: (query) => {
+            const { priceFrom, priceTo } = query || rest.state;
             return (getRangeDisplayValue({
                 from: priceFrom,
                 to: priceTo,
-                unit: unit,
-                t: t,
+                unit,
+                t,
             }) || '');
-        } });
+        },
+    };
 };
 
-var isInArray = function (item, array) { return array.includes(item); };
+const isInArray = (item, array) => array.includes(item);
 
-var sortCheckboxOptions = function (a, b, language, customOrder) {
-    if (language === void 0) { language = 'de'; }
-    if (customOrder === void 0) { customOrder = null; }
+const sortCheckboxOptions = (a, b, language = 'de', customOrder = null) => {
     if (!customOrder || !a.key || !b.key) {
         return a.label.localeCompare(b.label, language, { sensitivity: 'base' });
     }
-    var indexA = customOrder.indexOf(a.key);
-    var indexB = customOrder.indexOf(b.key);
+    const indexA = customOrder.indexOf(a.key);
+    const indexB = customOrder.indexOf(b.key);
     if (indexA === -1 && indexB === -1) {
         return a.label.localeCompare(b.label, language, { sensitivity: 'base' });
     }
@@ -1558,25 +1422,21 @@ var sortCheckboxOptions = function (a, b, language, customOrder) {
     }
     return indexA - indexB;
 };
-var getFacet = function (_a) {
-    var _b;
-    var key = _a.key, filterName = _a.filterName, facets = _a.facets;
+const getFacet = ({ key, filterName, facets, }) => {
     if (!facets)
         return null;
-    return (filterName && ((_b = facets[filterName]) === null || _b === void 0 ? void 0 : _b[key])) || 0;
+    return (filterName && facets[filterName]?.[key]) || 0;
 };
-var getCheckboxDisplayValue = function (options, filters) {
+const getCheckboxDisplayValue = (options, filters) => {
     return options
-        .reduce(function (acc, parent) {
-        var _a, _b, _c;
-        var filterName = (_a = parent.filterName) !== null && _a !== void 0 ? _a : '';
-        if (isInArray(parent.key, (_b = filters[filterName]) !== null && _b !== void 0 ? _b : [])) {
+        .reduce((acc, parent) => {
+        const filterName = parent.filterName ?? '';
+        if (isInArray(parent.key, filters[filterName] ?? [])) {
             acc.push(parent.label);
         }
-        (_c = parent.childCheckboxes) === null || _c === void 0 ? void 0 : _c.forEach(function (child) {
-            var _a, _b;
-            var childFilterName = (_a = child.filterName) !== null && _a !== void 0 ? _a : '';
-            if (isInArray(child.key, (_b = filters[childFilterName]) !== null && _b !== void 0 ? _b : [])) {
+        parent.childCheckboxes?.forEach((child) => {
+            const childFilterName = child.filterName ?? '';
+            if (isInArray(child.key, filters[childFilterName] ?? [])) {
                 acc.push(child.label);
             }
         });
@@ -1584,30 +1444,27 @@ var getCheckboxDisplayValue = function (options, filters) {
     }, [])
         .join(', ');
 };
-var mapCheckboxItem = function (_a) {
-    var item = _a.item, filterName = _a.filterName, translationKey = _a.translationKey, t = _a.t, getFacetFn = _a.getFacet;
+const mapCheckboxItem = ({ item, filterName, translationKey, t, getFacet: getFacetFn, }) => {
     return {
-        filterName: filterName,
+        filterName,
         key: item,
-        label: t(['filtersPkg', "".concat(translationKey, ".").concat(item)]),
+        label: t(['filtersPkg', `${translationKey}.${item}`]),
         facet: getFacetFn({
             key: item,
-            filterName: filterName,
+            filterName,
         }),
     };
 };
-var mapTypesToGroups = function (_a) {
-    var options = _a.options, groups = _a.groups, mapping = _a.mapping;
-    var result = {
-        groups: groups.reduce(function (acc, group) {
+const mapTypesToGroups = ({ options, groups, mapping, }) => {
+    const result = {
+        groups: groups.reduce((acc, group) => {
             acc[group] = [];
             return acc;
         }, {}),
         options: [],
     };
-    for (var _i = 0, options_1 = options; _i < options_1.length; _i++) {
-        var option = options_1[_i];
-        var group = mapping && mapping[option];
+    for (const option of options) {
+        const group = mapping && mapping[option];
         if (group) {
             result.groups[group].push(option);
         }
@@ -1617,68 +1474,80 @@ var mapTypesToGroups = function (_a) {
     }
     return result;
 };
-var generateCheckboxFilterItems = function (_a) {
-    var options = _a.options, groups = _a.groups, groupMapping = _a.groupMapping, getFacetFn = _a.getFacet, t = _a.t, language = _a.language, _b = _a.customOrder, customOrder = _b === void 0 ? null : _b;
-    var hasOptions = !!(options === null || options === void 0 ? void 0 : options.items.length);
-    var hasGroups = !!(groups === null || groups === void 0 ? void 0 : groups.items.length);
-    var getImage = options === null || options === void 0 ? void 0 : options.getImage;
+const generateCheckboxFilterItems = ({ options, groups, groupMapping, getFacet: getFacetFn, t, language, customOrder = null, }) => {
+    const hasOptions = !!options?.items.length;
+    const hasGroups = !!groups?.items.length;
+    const getImage = options?.getImage;
     if (!hasGroups && !hasOptions) {
         return [];
     }
-    var sortItems = function (a, b) {
+    const sortItems = (a, b) => {
         return sortCheckboxOptions(a, b, language, customOrder);
     };
     if (!hasGroups && hasOptions && options.key) {
         return options.items
-            .map(function (option) { return (__assign(__assign({}, mapCheckboxItem({
-            item: option,
-            filterName: options.key,
-            translationKey: options.translationKey,
-            t: t,
-            getFacet: getFacetFn,
-        })), { image: getImage === null || getImage === void 0 ? void 0 : getImage(option), childCheckboxes: [] })); })
+            .map((option) => ({
+            ...mapCheckboxItem({
+                item: option,
+                filterName: options.key,
+                translationKey: options.translationKey,
+                t,
+                getFacet: getFacetFn,
+            }),
+            image: getImage?.(option),
+            childCheckboxes: [],
+        }))
             .sort(sortItems);
     }
     if (hasGroups && groups.key && !hasOptions) {
         return groups.items
-            .map(function (group) { return (__assign(__assign({}, mapCheckboxItem({
-            item: group,
-            filterName: groups.key,
-            translationKey: groups.translationKey,
-            t: t,
-            getFacet: getFacetFn,
-        })), { childCheckboxes: [] })); })
+            .map((group) => ({
+            ...mapCheckboxItem({
+                item: group,
+                filterName: groups.key,
+                translationKey: groups.translationKey,
+                t,
+                getFacet: getFacetFn,
+            }),
+            childCheckboxes: [],
+        }))
             .sort(sortItems);
     }
-    var mappedOptions = mapTypesToGroups({
-        options: (options === null || options === void 0 ? void 0 : options.items) || [],
-        groups: (groups === null || groups === void 0 ? void 0 : groups.items) || [],
+    const mappedOptions = mapTypesToGroups({
+        options: options?.items || [],
+        groups: groups?.items || [],
         mapping: groupMapping,
     });
-    var groupEntries = Object.entries(mappedOptions.groups).map(function (_a) {
-        var group = _a[0], types = _a[1];
-        return (__assign(__assign({}, mapCheckboxItem({
+    const groupEntries = Object.entries(mappedOptions.groups).map(([group, types]) => ({
+        ...mapCheckboxItem({
             item: group,
-            filterName: groups === null || groups === void 0 ? void 0 : groups.key,
-            translationKey: (groups === null || groups === void 0 ? void 0 : groups.translationKey) || '',
-            t: t,
+            filterName: groups?.key,
+            translationKey: groups?.translationKey || '',
+            t,
             getFacet: getFacetFn,
-        })), { childCheckboxes: types.map(function (type) { return (__assign({}, mapCheckboxItem({
+        }),
+        childCheckboxes: types.map((type) => ({
+            ...mapCheckboxItem({
                 item: type,
-                filterName: options === null || options === void 0 ? void 0 : options.key,
-                translationKey: (options === null || options === void 0 ? void 0 : options.translationKey) || '',
-                t: t,
+                filterName: options?.key,
+                translationKey: options?.translationKey || '',
+                t,
                 getFacet: getFacetFn,
-            }))); }) }));
-    });
-    var ungroupedOptions = mappedOptions.options.map(function (option) { return (__assign(__assign({}, mapCheckboxItem({
-        item: option,
-        filterName: options === null || options === void 0 ? void 0 : options.key,
-        translationKey: (options === null || options === void 0 ? void 0 : options.translationKey) || '',
-        t: t,
-        getFacet: getFacetFn,
-    })), { image: getImage === null || getImage === void 0 ? void 0 : getImage(option), childCheckboxes: [] })); });
-    return __spreadArray(__spreadArray([], groupEntries, true), ungroupedOptions, true).sort(sortItems);
+            }),
+        })),
+    }));
+    const ungroupedOptions = mappedOptions.options.map((option) => ({
+        ...mapCheckboxItem({
+            item: option,
+            filterName: options?.key,
+            translationKey: options?.translationKey || '',
+            t,
+            getFacet: getFacetFn,
+        }),
+        image: getImage?.(option),
+        childCheckboxes: [],
+    }));
+    return [...groupEntries, ...ungroupedOptions].sort(sortItems);
 };
 
 var ActionType;
@@ -1691,31 +1560,51 @@ var ActionType;
     ActionType["SetFilter"] = "SET_FILTER";
     ActionType["Reset"] = "RESET";
 })(ActionType || (ActionType = {}));
-var reducer = function (state, action) {
-    var _a, _b;
+const reducer = (state, action) => {
     switch (action.type) {
         case ActionType.DeselectChildOption:
-            return __assign(__assign({}, state), { options: state.options.filter(function (option) { var _a; return option !== ((_a = action.payload) === null || _a === void 0 ? void 0 : _a.key); }) });
+            return {
+                ...state,
+                options: state.options.filter((option) => option !== action.payload?.key),
+            };
         case ActionType.SelectChildOption:
-            return __assign(__assign({}, state), { options: __spreadArray(__spreadArray([], state.options, true), [(_a = action.payload) === null || _a === void 0 ? void 0 : _a.key], false) });
+            return {
+                ...state,
+                options: [...state.options, action.payload?.key],
+            };
         case ActionType.DeselectGroup:
-            return __assign(__assign({}, state), { groups: state.groups.filter(function (group) { var _a; return group !== ((_a = action.payload) === null || _a === void 0 ? void 0 : _a.key); }) });
+            return {
+                ...state,
+                groups: state.groups.filter((group) => group !== action.payload?.key),
+            };
         case ActionType.SelectGroup:
-            return __assign(__assign({}, state), { options: state.options.filter(function (option) { return !action.payload.parentGroupChildItems.includes(option); }), groups: __spreadArray(__spreadArray([], state.groups, true), [(_b = action.payload) === null || _b === void 0 ? void 0 : _b.key], false) });
+            return {
+                ...state,
+                options: state.options.filter((option) => !action.payload.parentGroupChildItems.includes(option)),
+                groups: [...state.groups, action.payload?.key],
+            };
         case ActionType.DeselectChildAndGroupAndAddAllOtherChildOptions: {
-            var _c = action.payload, parentGroup_1 = _c.parentGroup, parentGroupChildItems = _c.parentGroupChildItems, key_1 = _c.key;
-            var updatedOptions = parentGroupChildItems === null || parentGroupChildItems === void 0 ? void 0 : parentGroupChildItems.filter(function (option) { return option !== key_1; });
-            var updatedGroups = state.groups.filter(function (group) { return group !== parentGroup_1; });
-            return __assign(__assign({}, state), { options: __spreadArray(__spreadArray([], state.options, true), (updatedOptions !== null && updatedOptions !== void 0 ? updatedOptions : []), true), groups: updatedGroups });
+            const { parentGroup, parentGroupChildItems, key } = action.payload;
+            const updatedOptions = parentGroupChildItems?.filter((option) => option !== key);
+            const updatedGroups = state.groups.filter((group) => group !== parentGroup);
+            return {
+                ...state,
+                options: [...state.options, ...(updatedOptions ?? [])],
+                groups: updatedGroups,
+            };
         }
         case ActionType.SetFilter: {
-            var isStateDifferent = function (arr1, arr2) {
+            const isStateDifferent = (arr1, arr2) => {
                 return (arr1.length !== arr2.length ||
-                    !arr1.every(function (option) { return arr2.includes(option); }));
+                    !arr1.every((option) => arr2.includes(option)));
             };
             if (isStateDifferent(action.payload.options, state.options) ||
                 isStateDifferent(action.payload.groups, state.groups)) {
-                return __assign(__assign({}, state), { options: action.payload.options, groups: action.payload.groups });
+                return {
+                    ...state,
+                    options: action.payload.options,
+                    groups: action.payload.groups,
+                };
             }
             return state;
         }
@@ -1728,49 +1617,38 @@ var reducer = function (state, action) {
             return state;
     }
 };
-var useCheckboxFilterReducer = function (_a) {
-    var initialState = _a.initialState, onChange = _a.onChange;
-    var _b = React.useReducer(reducer, initialState), state = _b[0], dispatchBase = _b[1];
-    var onChangeRef = React.useRef(onChange);
-    var lastActionType = React.useRef(null);
-    React.useEffect(function () {
+const useCheckboxFilterReducer = ({ initialState, onChange, }) => {
+    const [state, dispatchBase] = React.useReducer(reducer, initialState);
+    const onChangeRef = React.useRef(onChange);
+    const lastActionType = React.useRef(null);
+    React.useEffect(() => {
         onChangeRef.current = onChange;
     }, [onChange]);
-    React.useEffect(function () {
-        var _a;
+    React.useEffect(() => {
         if (![ActionType.Reset, ActionType.SetFilter].includes(lastActionType.current)) {
-            (_a = onChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(onChangeRef, state);
+            onChangeRef.current?.(state);
         }
     }, [state]);
-    var dispatch = React.useCallback(function (action) {
+    const dispatch = React.useCallback((action) => {
         lastActionType.current = action.type;
         dispatchBase(action);
     }, []);
-    return { state: state, dispatch: dispatch };
+    return { state, dispatch };
 };
 
-var getParentGroupWithChildItems = function (_a) {
-    var itemKey = _a.itemKey, mapping = _a.mapping;
+const getParentGroupWithChildItems = ({ itemKey, mapping, }) => {
     if (!mapping)
         return { parentGroup: null, parentGroupChildItems: [] };
-    var parentGroup = mapping[itemKey];
-    var parentGroupChildItems = Object.entries(mapping)
-        .filter(function (_a) {
-        var group = _a[1];
-        return group === parentGroup;
-    })
-        .map(function (_a) {
-        var key = _a[0];
-        return key;
-    });
-    return { parentGroup: parentGroup, parentGroupChildItems: parentGroupChildItems };
+    const parentGroup = mapping[itemKey];
+    const parentGroupChildItems = Object.entries(mapping)
+        .filter(([, group]) => group === parentGroup)
+        .map(([key]) => key);
+    return { parentGroup, parentGroupChildItems };
 };
-var mapToSearchableListItems = function (items, handleApply) {
-    return items.map(function (item) {
-        var _a, _b;
-        var isParentSelected = item.isChecked;
-        var children = (_a = item.childCheckboxes) === null || _a === void 0 ? void 0 : _a.map(function (child) {
-            var _a;
+const mapToSearchableListItems = (items, handleApply) => {
+    return items.map((item) => {
+        const isParentSelected = item.isChecked;
+        const children = item.childCheckboxes?.map((child) => {
             return {
                 key: child.key,
                 value: child.key,
@@ -1779,48 +1657,47 @@ var mapToSearchableListItems = function (items, handleApply) {
                 isSelected: isParentSelected || !!child.isChecked,
                 showChevron: false,
                 isCheckbox: true,
-                onClick: function () { return handleApply(child); },
-                facet: (_a = child.facet) === null || _a === void 0 ? void 0 : _a.toString(),
+                onClick: () => handleApply(child),
+                facet: child.facet?.toString(),
             };
         });
-        var isIndeterminate = !item.isChecked && (children === null || children === void 0 ? void 0 : children.some(function (child) { return child.isSelected; }));
+        const isIndeterminate = !item.isChecked && children?.some((child) => child.isSelected);
         return {
             key: item.key,
             label: item.label,
             value: item.key,
             filterName: item.filterName,
             isSelected: !!item.isChecked,
-            onClick: function () { return handleApply(item); },
+            onClick: () => handleApply(item),
             showChevron: false,
             isCheckbox: true,
             isIndeterminate: !!isIndeterminate,
-            facet: (_b = item.facet) === null || _b === void 0 ? void 0 : _b.toString(),
-            children: children,
+            facet: item.facet?.toString(),
+            children,
         };
     });
 };
-var useCheckboxFilter = function (_a) {
-    var _b, _c;
-    var _d, _e;
-    var filters = _a.filters, onAddFilter = _a.onAddFilter, onFilterChange = _a.onChange, generateCheckboxFilterItemsArgs = __rest(_a, ["filters", "onAddFilter", "onChange"]);
-    var language = useFilterContext().language;
-    var groupFilterName = (_d = generateCheckboxFilterItemsArgs.groups) === null || _d === void 0 ? void 0 : _d.key;
-    var optionFilterName = (_e = generateCheckboxFilterItemsArgs.options) === null || _e === void 0 ? void 0 : _e.key;
-    var initOptionParam = React.useMemo(function () { var _a; return (_a = (optionFilterName && filters[optionFilterName])) !== null && _a !== void 0 ? _a : []; }, [filters, optionFilterName]);
-    var initGroupParam = React.useMemo(function () { var _a; return (_a = (groupFilterName && filters[groupFilterName])) !== null && _a !== void 0 ? _a : []; }, [filters, groupFilterName]);
-    var _f = useCheckboxFilterReducer({
+const useCheckboxFilter = ({ filters, onAddFilter, onChange: onFilterChange, ...generateCheckboxFilterItemsArgs }) => {
+    const { language } = useFilterContext();
+    const groupFilterName = generateCheckboxFilterItemsArgs.groups?.key;
+    const optionFilterName = generateCheckboxFilterItemsArgs.options?.key;
+    const initOptionParam = React.useMemo(() => (optionFilterName && filters[optionFilterName]) ?? [], [filters, optionFilterName]);
+    const initGroupParam = React.useMemo(() => (groupFilterName && filters[groupFilterName]) ?? [], [filters, groupFilterName]);
+    const { state: { options, groups }, dispatch, } = useCheckboxFilterReducer({
         initialState: {
             groups: initGroupParam,
             options: initOptionParam,
         },
-        onChange: function (state) {
-            var _a, _b;
+        onChange: (state) => {
             if (!onFilterChange)
                 return;
-            onFilterChange(__assign(__assign({}, (groupFilterName ? (_a = {}, _a[groupFilterName] = state.groups, _a) : {})), (optionFilterName ? (_b = {}, _b[optionFilterName] = state.options, _b) : {})));
+            onFilterChange({
+                ...(groupFilterName ? { [groupFilterName]: state.groups } : {}),
+                ...(optionFilterName ? { [optionFilterName]: state.options } : {}),
+            });
         },
-    }), _g = _f.state, options = _g.options, groups = _g.groups, dispatch = _f.dispatch;
-    React.useEffect(function () {
+    });
+    React.useEffect(() => {
         dispatch({
             type: ActionType.SetFilter,
             payload: {
@@ -1829,19 +1706,16 @@ var useCheckboxFilter = function (_a) {
             },
         });
     }, [initOptionParam, initGroupParam, dispatch]);
-    var handleGroupApply = React.useCallback(function (updatedItem) {
-        var _a, _b;
-        var key = updatedItem.key;
+    const handleGroupApply = React.useCallback((updatedItem) => {
+        const { key } = updatedItem;
         if (isInArray(key, groups)) {
             return dispatch({
                 type: ActionType.DeselectGroup,
-                payload: { key: key },
+                payload: { key },
             });
         }
-        var selectedParentGroupChildItems = (_b = (_a = updatedItem.childCheckboxes) === null || _a === void 0 ? void 0 : _a.filter(function (child) {
-            return isInArray(child.key, options);
-        })) !== null && _b !== void 0 ? _b : [];
-        onAddFilter === null || onAddFilter === void 0 ? void 0 : onAddFilter({
+        const selectedParentGroupChildItems = updatedItem.childCheckboxes?.filter((child) => isInArray(child.key, options)) ?? [];
+        onAddFilter?.({
             appliedFilter: updatedItem.filterName,
             value: updatedItem.key,
             formattedValue: updatedItem.label,
@@ -1850,35 +1724,35 @@ var useCheckboxFilter = function (_a) {
         dispatch({
             type: ActionType.SelectGroup,
             payload: {
-                key: key,
-                parentGroupChildItems: selectedParentGroupChildItems.map(function (option) { return option.key; }),
+                key,
+                parentGroupChildItems: selectedParentGroupChildItems.map((option) => option.key),
             },
         });
     }, [groups, dispatch, onAddFilter, options]);
-    var handleOptionApply = React.useCallback(function (updatedItem) {
-        var key = updatedItem.key;
+    const handleOptionApply = React.useCallback((updatedItem) => {
+        const { key } = updatedItem;
         if (isInArray(key, options)) {
             return dispatch({
                 type: ActionType.DeselectChildOption,
-                payload: { key: key },
+                payload: { key },
             });
         }
-        var _a = getParentGroupWithChildItems({
+        const { parentGroup, parentGroupChildItems } = getParentGroupWithChildItems({
             itemKey: updatedItem.key,
             mapping: generateCheckboxFilterItemsArgs.groupMapping,
-        }), parentGroup = _a.parentGroup, parentGroupChildItems = _a.parentGroupChildItems;
+        });
         if (parentGroup && groups.includes(parentGroup)) {
             return dispatch({
                 type: ActionType.DeselectChildAndGroupAndAddAllOtherChildOptions,
-                payload: { key: key, parentGroup: parentGroup, parentGroupChildItems: parentGroupChildItems },
+                payload: { key, parentGroup, parentGroupChildItems },
             });
         }
-        var optionsFromParentGroupInCurrentState = options.filter(function (type) {
-            return parentGroupChildItems === null || parentGroupChildItems === void 0 ? void 0 : parentGroupChildItems.includes(type);
+        const optionsFromParentGroupInCurrentState = options.filter((type) => {
+            return parentGroupChildItems?.includes(type);
         });
-        var allParentGroupTypesSelected = optionsFromParentGroupInCurrentState.length + 1 ===
-            (parentGroupChildItems === null || parentGroupChildItems === void 0 ? void 0 : parentGroupChildItems.length);
-        onAddFilter === null || onAddFilter === void 0 ? void 0 : onAddFilter({
+        const allParentGroupTypesSelected = optionsFromParentGroupInCurrentState.length + 1 ===
+            parentGroupChildItems?.length;
+        onAddFilter?.({
             appliedFilter: updatedItem.filterName,
             value: updatedItem.key,
             formattedValue: updatedItem.label,
@@ -1887,12 +1761,12 @@ var useCheckboxFilter = function (_a) {
         if (allParentGroupTypesSelected && parentGroup) {
             return dispatch({
                 type: ActionType.SelectGroup,
-                payload: { key: parentGroup, parentGroupChildItems: parentGroupChildItems },
+                payload: { key: parentGroup, parentGroupChildItems },
             });
         }
         dispatch({
             type: ActionType.SelectChildOption,
-            payload: { key: key },
+            payload: { key },
         });
     }, [
         dispatch,
@@ -1901,7 +1775,7 @@ var useCheckboxFilter = function (_a) {
         onAddFilter,
         options,
     ]);
-    var handleApply = React.useCallback(function (updatedItem) {
+    const handleApply = React.useCallback((updatedItem) => {
         if (updatedItem.filterName === optionFilterName) {
             handleOptionApply(updatedItem);
         }
@@ -1909,14 +1783,15 @@ var useCheckboxFilter = function (_a) {
             handleGroupApply(updatedItem);
         }
     }, [groupFilterName, handleGroupApply, handleOptionApply, optionFilterName]);
-    var reset = function () {
-        var _a, _b;
+    const reset = () => {
         dispatch({ type: ActionType.Reset });
-        return __assign(__assign({}, (groupFilterName ? (_a = {}, _a[groupFilterName] = [], _a) : {})), (optionFilterName ? (_b = {}, _b[optionFilterName] = [], _b) : {}));
+        return {
+            ...(groupFilterName ? { [groupFilterName]: [] } : {}),
+            ...(optionFilterName ? { [optionFilterName]: [] } : {}),
+        };
     };
     useResetAllFilters(reset);
-    var isChecked = React.useCallback(function (_a) {
-        var filterName = _a.filterName, key = _a.key;
+    const isChecked = React.useCallback(({ filterName, key, }) => {
         if (filterName === optionFilterName) {
             return isInArray(key, options);
         }
@@ -1925,47 +1800,56 @@ var useCheckboxFilter = function (_a) {
         }
         return false;
     }, [groupFilterName, groups, optionFilterName, options]);
-    var items = generateCheckboxFilterItems(__assign(__assign({}, generateCheckboxFilterItemsArgs), { language: language }));
-    var itemsWithCheckedState = React.useMemo(function () {
-        return items.map(function (item) {
-            var _a;
-            return __assign(__assign({}, item), { isChecked: isChecked({
+    const items = generateCheckboxFilterItems({
+        ...generateCheckboxFilterItemsArgs,
+        language,
+    });
+    const itemsWithCheckedState = React.useMemo(() => {
+        return items.map((item) => {
+            return {
+                ...item,
+                isChecked: isChecked({
                     filterName: item.filterName,
                     key: item.key,
-                }), childCheckboxes: (_a = item.childCheckboxes) === null || _a === void 0 ? void 0 : _a.map(function (childItem) {
-                    return __assign(__assign({}, childItem), { isChecked: isChecked({
+                }),
+                childCheckboxes: item.childCheckboxes?.map((childItem) => {
+                    return {
+                        ...childItem,
+                        isChecked: isChecked({
                             filterName: childItem.filterName,
                             key: childItem.key,
-                        }) });
-                }) });
+                        }),
+                    };
+                }),
+            };
         });
     }, [items, isChecked]);
-    var checkboxItems = React.useMemo(function () {
-        return generateCheckboxFilterItemsArgs.isSearchable
-            ? mapToSearchableListItems(itemsWithCheckedState, handleApply)
-            : itemsWithCheckedState;
-    }, [
+    const checkboxItems = React.useMemo(() => generateCheckboxFilterItemsArgs.isSearchable
+        ? mapToSearchableListItems(itemsWithCheckedState, handleApply)
+        : itemsWithCheckedState, [
         itemsWithCheckedState,
         generateCheckboxFilterItemsArgs.isSearchable,
         handleApply,
     ]);
-    var numberOfAppliedFilters = groups.length + options.length;
+    const numberOfAppliedFilters = groups.length + options.length;
     return {
-        state: __assign(__assign({}, (groupFilterName ? (_b = {}, _b[groupFilterName] = groups, _b) : {})), (optionFilterName ? (_c = {}, _c[optionFilterName] = options, _c) : {})),
-        checkboxItems: checkboxItems,
+        state: {
+            ...(groupFilterName ? { [groupFilterName]: groups } : {}),
+            ...(optionFilterName ? { [optionFilterName]: options } : {}),
+        },
+        checkboxItems,
         onApply: handleApply,
-        numberOfAppliedFilters: numberOfAppliedFilters,
+        numberOfAppliedFilters,
         isApplied: !!numberOfAppliedFilters,
-        reset: reset,
+        reset,
     };
 };
 
-var useFuelTypeFilter = function (_a) {
-    var filters = _a.filters, vehicleCategory = _a.vehicleCategory, facets = _a.facets, onAddFilter = _a.onAddFilter, onChange = _a.onChange;
-    var _b = useFilterContext(), t = _b.t, referenceData = _b.referenceData, language = _b.language;
-    var categoryData = referenceData[vehicleCategory];
-    var _c = useCheckboxFilter({
-        filters: filters,
+const useFuelTypeFilter = ({ filters, vehicleCategory, facets, onAddFilter, onChange }) => {
+    const { t, referenceData, language } = useFilterContext();
+    const categoryData = referenceData[vehicleCategory];
+    const { checkboxItems, onApply, ...rest } = useCheckboxFilter({
+        filters,
         isSearchable: false,
         options: {
             items: categoryData.fuelTypes,
@@ -1978,7 +1862,7 @@ var useFuelTypeFilter = function (_a) {
             translationKey: 'fuelTypeGroup',
         },
         groupMapping: categoryData.fuelTypeGroupMapping,
-        getFacet: function (args) { return getFacet(__assign(__assign({}, args), { facets: facets })); },
+        getFacet: (args) => getFacet({ ...args, facets }),
         customOrder: [
             exports.FuelTypeGroup.Petrol,
             exports.FuelTypeGroup.Diesel,
@@ -1987,21 +1871,23 @@ var useFuelTypeFilter = function (_a) {
             exports.FuelTypeGroup.Gas,
             exports.FuelTypeGroup.Other,
         ],
-        t: t,
-        onAddFilter: onAddFilter,
-        onChange: onChange,
-    }), checkboxItems = _c.checkboxItems, onApply = _c.onApply, rest = __rest(_c, ["checkboxItems", "onApply"]);
-    return __assign({ ui: (React.createElement(components.CheckboxFilter, { items: checkboxItems, onApply: onApply, language: language })), label: t('filtersPkg.fuelType'), getDisplayValue: function (query) {
-            return getCheckboxDisplayValue(checkboxItems, query || rest.state);
-        } }, rest);
+        t,
+        onAddFilter,
+        onChange,
+    });
+    return {
+        ui: (React.createElement(components.CheckboxFilter, { items: checkboxItems, onApply: onApply, language: language })),
+        label: t('filtersPkg.fuelType'),
+        getDisplayValue: (query) => getCheckboxDisplayValue(checkboxItems, query || rest.state),
+        ...rest,
+    };
 };
 
-var useConditionTypeFilter = function (_a) {
-    var filters = _a.filters, vehicleCategory = _a.vehicleCategory, facets = _a.facets, onAddFilter = _a.onAddFilter, onChange = _a.onChange;
-    var _b = useFilterContext(), t = _b.t, referenceData = _b.referenceData, language = _b.language;
-    var categoryData = referenceData[vehicleCategory];
-    var _c = useCheckboxFilter({
-        filters: filters,
+const useConditionTypeFilter = ({ filters, vehicleCategory, facets, onAddFilter, onChange }) => {
+    const { t, referenceData, language } = useFilterContext();
+    const categoryData = referenceData[vehicleCategory];
+    const { checkboxItems, onApply, ...rest } = useCheckboxFilter({
+        filters,
         isSearchable: false,
         options: {
             items: categoryData.conditionTypes,
@@ -2014,30 +1900,32 @@ var useConditionTypeFilter = function (_a) {
             translationKey: 'conditionTypeGroup',
         },
         groupMapping: categoryData.conditionTypeGroupMapping,
-        getFacet: function (args) { return getFacet(__assign(__assign({}, args), { facets: facets })); },
-        t: t,
-        onAddFilter: onAddFilter,
-        onChange: onChange,
-    }), checkboxItems = _c.checkboxItems, onApply = _c.onApply, rest = __rest(_c, ["checkboxItems", "onApply"]);
-    return __assign({ ui: (React.createElement(components.CheckboxFilter, { items: checkboxItems, onApply: onApply, language: language })), label: t('filtersPkg.conditionType'), getDisplayValue: function (query) {
-            return getCheckboxDisplayValue(checkboxItems, query || rest.state);
-        } }, rest);
+        getFacet: (args) => getFacet({ ...args, facets }),
+        t,
+        onAddFilter,
+        onChange,
+    });
+    return {
+        ui: (React.createElement(components.CheckboxFilter, { items: checkboxItems, onApply: onApply, language: language })),
+        label: t('filtersPkg.conditionType'),
+        getDisplayValue: (query) => getCheckboxDisplayValue(checkboxItems, query || rest.state),
+        ...rest,
+    };
 };
 
-var _a, _b;
-var bodyTypeIconMap = (_a = {},
-    _a[exports.BodyType.Bus] = components.VanIcon,
-    _a[exports.BodyType.Cabriolet] = components.CabrioletIcon,
-    _a[exports.BodyType.Coupe] = components.CoupeIcon,
-    _a[exports.BodyType.Estate] = components.WagonIcon,
-    _a[exports.BodyType.Minivan] = components.MiniVanIcon,
-    _a[exports.BodyType.Pickup] = components.PickUpIcon,
-    _a[exports.BodyType.Saloon] = components.SedanIcon,
-    _a[exports.BodyType.Smallcar] = components.SmallCarIcon,
-    _a[exports.BodyType.SUV] = components.SuvIcon,
-    _a);
-var bodyTypeCustomOrder = (_b = {},
-    _b[exports.VehicleCategory.Car] = [
+const bodyTypeIconMap = {
+    [exports.BodyType.Bus]: components.VanIcon,
+    [exports.BodyType.Cabriolet]: components.CabrioletIcon,
+    [exports.BodyType.Coupe]: components.CoupeIcon,
+    [exports.BodyType.Estate]: components.WagonIcon,
+    [exports.BodyType.Minivan]: components.MiniVanIcon,
+    [exports.BodyType.Pickup]: components.PickUpIcon,
+    [exports.BodyType.Saloon]: components.SedanIcon,
+    [exports.BodyType.Smallcar]: components.SmallCarIcon,
+    [exports.BodyType.SUV]: components.SuvIcon,
+};
+const bodyTypeCustomOrder = {
+    [exports.VehicleCategory.Car]: [
         exports.BodyType.Estate,
         exports.BodyType.SUV,
         exports.BodyType.Saloon,
@@ -2048,66 +1936,69 @@ var bodyTypeCustomOrder = (_b = {},
         exports.BodyType.Minivan,
         exports.BodyType.Bus,
     ],
-    _b);
-var useBodyTypeFilter = function (_a) {
-    var filters = _a.filters, vehicleCategory = _a.vehicleCategory, facets = _a.facets, onAddFilter = _a.onAddFilter, onChange = _a.onChange, numberOfColumnsOnDesktop = _a.numberOfColumnsOnDesktop;
-    var _b = useFilterContext(), t = _b.t, referenceData = _b.referenceData, language = _b.language;
-    var categoryData = referenceData[vehicleCategory];
-    var _c = useCheckboxFilter({
-        filters: filters,
+};
+const useBodyTypeFilter = ({ filters, vehicleCategory, facets, onAddFilter, onChange, numberOfColumnsOnDesktop, }) => {
+    const { t, referenceData, language } = useFilterContext();
+    const categoryData = referenceData[vehicleCategory];
+    const { checkboxItems, onApply, ...rest } = useCheckboxFilter({
+        filters,
         isSearchable: false,
         options: {
             items: categoryData.bodyTypes,
             key: 'bodyTypes',
             translationKey: 'bodyType',
-            getImage: function (key) {
+            getImage: (key) => {
                 if (vehicleCategory !== exports.VehicleCategory.Car)
                     return null;
-                var Icon = bodyTypeIconMap[key];
+                const Icon = bodyTypeIconMap[key];
                 if (!Icon)
                     return null;
                 return React.createElement(Icon, { w: 75, h: 51 });
             },
         },
         customOrder: bodyTypeCustomOrder[vehicleCategory],
-        getFacet: function (args) { return getFacet(__assign(__assign({}, args), { facets: facets })); },
-        t: t,
-        onAddFilter: onAddFilter,
-        onChange: onChange,
-    }), checkboxItems = _c.checkboxItems, onApply = _c.onApply, rest = __rest(_c, ["checkboxItems", "onApply"]);
-    return __assign({ ui: (React.createElement(components.CheckboxFilter, { items: checkboxItems, onApply: onApply, language: language, numberOfColumnsOnDesktop: numberOfColumnsOnDesktop })), label: t('filtersPkg.bodyType'), getDisplayValue: function (query) {
-            return getCheckboxDisplayValue(checkboxItems, query || rest.state);
-        } }, rest);
+        getFacet: (args) => getFacet({ ...args, facets }),
+        t,
+        onAddFilter,
+        onChange,
+    });
+    return {
+        ui: (React.createElement(components.CheckboxFilter, { items: checkboxItems, onApply: onApply, language: language, numberOfColumnsOnDesktop: numberOfColumnsOnDesktop })),
+        label: t('filtersPkg.bodyType'),
+        getDisplayValue: (query) => getCheckboxDisplayValue(checkboxItems, query || rest.state),
+        ...rest,
+    };
 };
 
-var useDriveTypeFilter = function (_a) {
-    var filters = _a.filters, vehicleCategory = _a.vehicleCategory, facets = _a.facets, onAddFilter = _a.onAddFilter, onChange = _a.onChange;
-    var _b = useFilterContext(), t = _b.t, referenceData = _b.referenceData, language = _b.language;
-    var categoryData = referenceData[vehicleCategory];
-    var _c = useCheckboxFilter({
-        filters: filters,
+const useDriveTypeFilter = ({ filters, vehicleCategory, facets, onAddFilter, onChange }) => {
+    const { t, referenceData, language } = useFilterContext();
+    const categoryData = referenceData[vehicleCategory];
+    const { checkboxItems, onApply, ...rest } = useCheckboxFilter({
+        filters,
         isSearchable: false,
         options: {
             items: categoryData.driveTypes,
             key: 'driveTypes',
             translationKey: 'driveType',
         },
-        getFacet: function (args) { return getFacet(__assign(__assign({}, args), { facets: facets })); },
-        t: t,
-        onAddFilter: onAddFilter,
-        onChange: onChange,
-    }), checkboxItems = _c.checkboxItems, onApply = _c.onApply, rest = __rest(_c, ["checkboxItems", "onApply"]);
-    return __assign({ ui: (React.createElement(components.CheckboxFilter, { items: checkboxItems, onApply: onApply, language: language })), label: t('filtersPkg.driveType'), getDisplayValue: function (query) {
-            return getCheckboxDisplayValue(checkboxItems, query || rest.state);
-        } }, rest);
+        getFacet: (args) => getFacet({ ...args, facets }),
+        t,
+        onAddFilter,
+        onChange,
+    });
+    return {
+        ui: (React.createElement(components.CheckboxFilter, { items: checkboxItems, onApply: onApply, language: language })),
+        label: t('filtersPkg.driveType'),
+        getDisplayValue: (query) => getCheckboxDisplayValue(checkboxItems, query || rest.state),
+        ...rest,
+    };
 };
 
-var useTransmissionTypeFilter = function (_a) {
-    var filters = _a.filters, vehicleCategory = _a.vehicleCategory, facets = _a.facets, onAddFilter = _a.onAddFilter, onChange = _a.onChange;
-    var _b = useFilterContext(), t = _b.t, referenceData = _b.referenceData, language = _b.language;
-    var categoryData = referenceData[vehicleCategory];
-    var _c = useCheckboxFilter({
-        filters: filters,
+const useTransmissionTypeFilter = ({ filters, vehicleCategory, facets, onAddFilter, onChange }) => {
+    const { t, referenceData, language } = useFilterContext();
+    const categoryData = referenceData[vehicleCategory];
+    const { checkboxItems, onApply, ...rest } = useCheckboxFilter({
+        filters,
         isSearchable: false,
         options: {
             items: categoryData.transmissionTypes,
@@ -2120,14 +2011,17 @@ var useTransmissionTypeFilter = function (_a) {
             translationKey: 'transmissionTypeGroup',
         },
         groupMapping: categoryData.transmissionTypeGroupMapping,
-        getFacet: function (args) { return getFacet(__assign(__assign({}, args), { facets: facets })); },
-        t: t,
-        onAddFilter: onAddFilter,
-        onChange: onChange,
-    }), checkboxItems = _c.checkboxItems, onApply = _c.onApply, rest = __rest(_c, ["checkboxItems", "onApply"]);
-    return __assign({ ui: (React.createElement(components.CheckboxFilter, { items: checkboxItems, onApply: onApply, language: language })), label: t('filtersPkg.transmissionType'), getDisplayValue: function (query) {
-            return getCheckboxDisplayValue(checkboxItems, query || rest.state);
-        } }, rest);
+        getFacet: (args) => getFacet({ ...args, facets }),
+        t,
+        onAddFilter,
+        onChange,
+    });
+    return {
+        ui: (React.createElement(components.CheckboxFilter, { items: checkboxItems, onApply: onApply, language: language })),
+        label: t('filtersPkg.transmissionType'),
+        getDisplayValue: (query) => getCheckboxDisplayValue(checkboxItems, query || rest.state),
+        ...rest,
+    };
 };
 
 exports.FilterProvider = FilterProvider;