@servicetitan/titan-chatbot-api 7.1.1 → 8.0.0

package/dist/stores/filter.store.js

@@ -1,443 +1,363 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
+}
+function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
+}
 import cloneDeep from 'lodash/cloneDeep';
 import { action, makeObservable, observable } from 'mobx';
 import { nanoid } from 'nanoid';
 import { Models, ModelsUtils } from '../api-client';
+import { FilterDefaultSelectionFn } from '../models/chatbot-customizations';
 export class FilterStore {
-    constructor() {
+    initFilters(model, options) {
+        var _ref;
+        var _model_options_subOptions;
+        this.originalFilters = cloneDeep((_ref = model === null || model === void 0 ? void 0 : (_model_options_subOptions = model.options.subOptions) === null || _model_options_subOptions === void 0 ? void 0 : _model_options_subOptions.filter((x)=>x.type === Models.OptionType.Group)) !== null && _ref !== void 0 ? _ref : []);
+        this.initLocalFilters(this.originalFilters);
+        this.applyDefaultSelections(options === null || options === void 0 ? void 0 : options.isDefaultSelected);
+    }
+    export() {
+        return ModelsUtils.createSelectionsModel(this.originalFilters, this.selected);
+    }
+    /**
+     * Applies default selections based on the provided customization function.
+     * Iterates through all filters and their options, selecting those where
+     * isDefaultSelected returns true.
+     */ applyDefaultSelections(isDefaultSelected) {
+        if (!isDefaultSelected) {
+            return;
+        }
+        for (const filter of this.filters){
+            const filterOptions = this.getFilterOptions(filter.key);
+            for (const option of filterOptions){
+                if (isDefaultSelected(filter.key, option.key)) {
+                    this.selectOption(filter.key, option.key);
+                }
+            }
+        }
+    }
+    constructor(){
         /**
-         * Selected items map: filter key -> selectable keys
-         */
-        Object.defineProperty(this, "selected", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
+     * Selected items map: filter key -> selectable keys
+     */ _define_property(this, "selected", new Map());
         /**
-         * Available filters with their selectable options (flattened and merged)
-         */
-        Object.defineProperty(this, "filters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "localFilters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "originalFilters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "mapUidToOption", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        Object.defineProperty(this, "mapUidToParentUid", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        Object.defineProperty(this, "isOptionChecked", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (filterKey, optionKey) => {
-                const selectedOptions = this.selected.get(filterKey);
-                if (!selectedOptions) {
-                    return false;
-                }
-                return selectedOptions.includes(optionKey);
+     * Available filters with their selectable options (flattened and merged)
+     */ _define_property(this, "filters", []);
+        _define_property(this, "localFilters", []);
+        _define_property(this, "originalFilters", []);
+        _define_property(this, "mapUidToOption", new Map());
+        _define_property(this, "mapUidToParentUid", new Map());
+        _define_property(this, "isOptionChecked", (filterKey, optionKey)=>{
+            const selectedOptions = this.selected.get(filterKey);
+            if (!selectedOptions) {
+                return false;
             }
+            return selectedOptions.includes(optionKey);
         });
-        Object.defineProperty(this, "isOptionDisabled", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (filterKey, optionKey) => {
-                var _a, _b;
-                const filter = this.getFilterByKey(filterKey);
-                const option = (_a = filter === null || filter === void 0 ? void 0 : filter.subOptions) === null || _a === void 0 ? void 0 : _a.find(o => o.key === optionKey);
-                if (!option) {
+        _define_property(this, "isOptionDisabled", (filterKey, optionKey)=>{
+            var _filter_subOptions;
+            const filter = this.getFilterByKey(filterKey);
+            const option = filter === null || filter === void 0 ? void 0 : (_filter_subOptions = filter.subOptions) === null || _filter_subOptions === void 0 ? void 0 : _filter_subOptions.find((o)=>o.key === optionKey);
+            if (!option) {
+                return false;
+            }
+            // check any parent selectable is selected
+            for (const optionFilter of option.parentUids.map((uid)=>this.mapUidToOption.get(uid)).filter(Boolean)){
+                var _optionFilter_parentUids;
+                if (!(optionFilter === null || optionFilter === void 0 ? void 0 : (_optionFilter_parentUids = optionFilter.parentUids) === null || _optionFilter_parentUids === void 0 ? void 0 : _optionFilter_parentUids.length)) {
+                    // no parent -> root filter -> so not disabled
                     return false;
                 }
-                // check any parent selectable is selected
-                for (const optionFilter of option.parentUids
-                    .map(uid => this.mapUidToOption.get(uid))
-                    .filter(Boolean)) {
-                    if (!((_b = optionFilter === null || optionFilter === void 0 ? void 0 : optionFilter.parentUids) === null || _b === void 0 ? void 0 : _b.length)) {
-                        // no parent -> root filter -> so not disabled
-                        return false;
+                // Check all parent filters
+                for (const parentUid of optionFilter.parentUids){
+                    const parentOption = this.mapUidToOption.get(parentUid);
+                    if (!parentOption) {
+                        continue;
                     }
-                    // Check all parent filters
-                    for (const parentUid of optionFilter.parentUids) {
-                        const parentOption = this.mapUidToOption.get(parentUid);
-                        if (!parentOption) {
-                            continue;
-                        }
-                        const parentFilter = this.getOptionFilter(parentOption);
-                        if (!parentFilter) {
-                            continue;
-                        }
-                        const isParentSelected = this.isOptionChecked(parentFilter.key, parentOption.key);
-                        if (isParentSelected) {
-                            return false;
-                        }
+                    const parentFilter = this.getOptionFilter(parentOption);
+                    if (!parentFilter) {
+                        continue;
+                    }
+                    const isParentSelected = this.isOptionChecked(parentFilter.key, parentOption.key);
+                    if (isParentSelected) {
+                        return false;
                     }
                 }
-                return true;
             }
+            return true;
         });
-        Object.defineProperty(this, "getFilterOptions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (filterKey) => {
-                const filter = this.getFilterByKey(filterKey);
-                if (!(filter === null || filter === void 0 ? void 0 : filter.subOptions)) {
-                    return [];
-                }
-                return filter.subOptions.filter(x => x.type === Models.OptionType.Selectable);
+        _define_property(this, "getFilterOptions", (filterKey)=>{
+            const filter = this.getFilterByKey(filterKey);
+            if (!(filter === null || filter === void 0 ? void 0 : filter.subOptions)) {
+                return [];
             }
+            return filter.subOptions.filter((x)=>x.type === Models.OptionType.Selectable);
         });
-        Object.defineProperty(this, "selectOption", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (filterKey, optionKey) => {
-                this.assertFilterKeyExists(filterKey);
-                this.assertOptionKeyExists(filterKey, optionKey);
-                if (!this.selected.has(filterKey)) {
-                    this.selected.set(filterKey, []);
-                }
-                const selectedOptions = this.selected.get(filterKey);
-                if (selectedOptions.includes(optionKey)) {
-                    return;
-                }
-                this.selected.set(filterKey, [...selectedOptions, optionKey]);
+        _define_property(this, "selectOption", (filterKey, optionKey)=>{
+            this.assertFilterKeyExists(filterKey);
+            this.assertOptionKeyExists(filterKey, optionKey);
+            if (!this.selected.has(filterKey)) {
+                this.selected.set(filterKey, []);
             }
-        });
-        Object.defineProperty(this, "selectAll", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (filterKey) => {
-                this.assertFilterKeyExists(filterKey);
-                const filter = this.getFilterByKey(filterKey);
-                if (!(filter === null || filter === void 0 ? void 0 : filter.subOptions)) {
-                    return;
-                }
-                const selectableOptions = filter.subOptions.filter(x => x.type === Models.OptionType.Selectable);
-                this.selected.set(filterKey, selectableOptions.map(o => o.key));
+            const selectedOptions = this.selected.get(filterKey);
+            if (selectedOptions.includes(optionKey)) {
+                return;
             }
+            this.selected.set(filterKey, [
+                ...selectedOptions,
+                optionKey
+            ]);
         });
-        Object.defineProperty(this, "deselectOption", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (filterKey, optionKey) => {
-                var _a;
-                this.assertFilterKeyExists(filterKey);
-                this.assertOptionKeyExists(filterKey, optionKey);
-                const selectedOptions = (_a = this.selected.get(filterKey)) !== null && _a !== void 0 ? _a : [];
-                this.selected.set(filterKey, selectedOptions.filter(o => o !== optionKey));
-                this.uncheckDisabledOptions();
+        _define_property(this, "selectAll", (filterKey)=>{
+            this.assertFilterKeyExists(filterKey);
+            const filter = this.getFilterByKey(filterKey);
+            if (!(filter === null || filter === void 0 ? void 0 : filter.subOptions)) {
+                return;
             }
+            const selectableOptions = filter.subOptions.filter((x)=>x.type === Models.OptionType.Selectable);
+            this.selected.set(filterKey, selectableOptions.map((o)=>o.key));
         });
-        Object.defineProperty(this, "deselectAll", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (filterKey) => {
-                this.assertFilterKeyExists(filterKey);
-                this.selected.set(filterKey, []);
-                this.uncheckDisabledOptions();
-            }
+        _define_property(this, "deselectOption", (filterKey, optionKey)=>{
+            var _this_selected_get;
+            this.assertFilterKeyExists(filterKey);
+            this.assertOptionKeyExists(filterKey, optionKey);
+            const selectedOptions = (_this_selected_get = this.selected.get(filterKey)) !== null && _this_selected_get !== void 0 ? _this_selected_get : [];
+            this.selected.set(filterKey, selectedOptions.filter((o)=>o !== optionKey));
+            this.uncheckDisabledOptions();
         });
-        Object.defineProperty(this, "getFilterLabel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (key) => {
-                // transform camel case key to human-readable label
-                const normalizedKey = key.trim().replace(/\s+/g, ' ');
-                // Now transform camel case to human-readable label
-                return normalizedKey.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/^./, function (str) {
-                    return str.toUpperCase();
-                });
-            }
+        _define_property(this, "deselectAll", (filterKey)=>{
+            this.assertFilterKeyExists(filterKey);
+            this.selected.set(filterKey, []);
+            this.uncheckDisabledOptions();
         });
-        Object.defineProperty(this, "assertFilterKeyExists", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (filterKey) => {
-                const filter = this.getFilterByKey(filterKey);
-                if (!filter) {
-                    throw new Error(`Filter with key "${filterKey}" does not exist.`);
-                }
-            }
+        _define_property(this, "getFilterLabel", (key)=>{
+            // transform camel case key to human-readable label
+            const normalizedKey = key.trim().replace(/\s+/g, ' ');
+            // Now transform camel case to human-readable label
+            return normalizedKey.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/^./, function(str) {
+                return str.toUpperCase();
+            });
         });
-        Object.defineProperty(this, "assertOptionKeyExists", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (filterKey, optionKey) => {
-                var _a;
-                this.assertFilterKeyExists(filterKey);
-                const filter = this.getFilterByKey(filterKey);
-                const option = (_a = filter.subOptions) === null || _a === void 0 ? void 0 : _a.find(o => o.key === optionKey);
-                if (!option) {
-                    throw new Error(`Option with key "${optionKey}" does not exist in filter "${filterKey}".`);
-                }
+        _define_property(this, "assertFilterKeyExists", (filterKey)=>{
+            const filter = this.getFilterByKey(filterKey);
+            if (!filter) {
+                throw new Error(`Filter with key "${filterKey}" does not exist.`);
             }
         });
-        Object.defineProperty(this, "getFilterByKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (filterKey) => {
-                return this.filters.find(f => f.key === filterKey);
+        _define_property(this, "assertOptionKeyExists", (filterKey, optionKey)=>{
+            var _filter_subOptions;
+            this.assertFilterKeyExists(filterKey);
+            const filter = this.getFilterByKey(filterKey);
+            const option = (_filter_subOptions = filter.subOptions) === null || _filter_subOptions === void 0 ? void 0 : _filter_subOptions.find((o)=>o.key === optionKey);
+            if (!option) {
+                throw new Error(`Option with key "${optionKey}" does not exist in filter "${filterKey}".`);
             }
         });
-        Object.defineProperty(this, "getOptionFilter", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (option) => {
-                const parentUid = this.mapUidToParentUid.get(option.uid);
-                if (!parentUid) {
-                    return undefined;
-                }
-                return this.mapUidToOption.get(parentUid);
+        _define_property(this, "getFilterByKey", (filterKey)=>{
+            return this.filters.find((f)=>f.key === filterKey);
+        });
+        _define_property(this, "getOptionFilter", (option)=>{
+            const parentUid = this.mapUidToParentUid.get(option.uid);
+            if (!parentUid) {
+                return undefined;
             }
+            return this.mapUidToOption.get(parentUid);
         });
-        Object.defineProperty(this, "uncheckDisabledOptions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: () => {
-                for (const [filterKey, selectedOptions] of this.selected.entries()) {
-                    const filter = this.getFilterByKey(filterKey);
-                    if (!filter) {
-                        continue;
-                    }
-                    const validSelectedOptions = selectedOptions.filter(optionKey => {
-                        var _a;
-                        const option = (_a = filter.subOptions) === null || _a === void 0 ? void 0 : _a.find(o => o.key === optionKey);
-                        if (!option) {
-                            return false;
-                        }
-                        return !this.isOptionDisabled(filterKey, optionKey);
-                    });
-                    this.selected.set(filterKey, validSelectedOptions);
+        _define_property(this, "uncheckDisabledOptions", ()=>{
+            for (const [filterKey, selectedOptions] of this.selected.entries()){
+                const filter = this.getFilterByKey(filterKey);
+                if (!filter) {
+                    continue;
                 }
+                const validSelectedOptions = selectedOptions.filter((optionKey)=>{
+                    var _filter_subOptions;
+                    const option = (_filter_subOptions = filter.subOptions) === null || _filter_subOptions === void 0 ? void 0 : _filter_subOptions.find((o)=>o.key === optionKey);
+                    if (!option) {
+                        return false;
+                    }
+                    return !this.isOptionDisabled(filterKey, optionKey);
+                });
+                this.selected.set(filterKey, validSelectedOptions);
             }
         });
         /**
-         * Sets unique IDs (uids) for each option and builds a parent options map that tracks parent-child relationships.
-         * @param options The list of options to process (recursive).
-         */
-        Object.defineProperty(this, "initLocalFilters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (options) => {
-                // Set up local filters uids
-                this.localFilters = cloneDeep(options);
-                const setUids = (o, parentUid) => {
-                    if (!o) {
-                        return;
-                    }
-                    o.forEach(x => {
-                        x.uid = nanoid();
-                        x.parentUids = parentUid ? [parentUid] : [];
-                        setUids(x.subOptions, x.uid);
-                    });
-                };
-                setUids(this.localFilters);
-                this.initLocalUiFilters(this.localFilters);
-            }
+     * Sets unique IDs (uids) for each option and builds a parent options map that tracks parent-child relationships.
+     * @param options The list of options to process (recursive).
+     */ _define_property(this, "initLocalFilters", (options)=>{
+            // Set up local filters uids
+            this.localFilters = cloneDeep(options);
+            const setUids = (o, parentUid)=>{
+                if (!o) {
+                    return;
+                }
+                o.forEach((x)=>{
+                    x.uid = nanoid();
+                    x.parentUids = parentUid ? [
+                        parentUid
+                    ] : [];
+                    setUids(x.subOptions, x.uid);
+                });
+            };
+            setUids(this.localFilters);
+            this.initLocalUiFilters(this.localFilters);
         });
         /**
-         * Go through local filters and set up UI objects that will be rendered: filters and filter selectables
-         */
-        Object.defineProperty(this, "initLocalUiFilters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (options) => {
-                this.mapUidToOption = new Map();
-                this.mapUidToParentUid = new Map();
-                const filtersKeyToFilter = new Map();
-                // Function to merge duplicate selectable options by key
-                const mergeDuplicates = (options) => {
-                    // Merge selectables with the same keys. Original uids will be stored in "parentUids"
-                    const keyToOption = new Map();
-                    for (const option of options) {
-                        if (option.type !== Models.OptionType.Selectable) {
-                            continue;
-                        }
-                        if (!keyToOption.has(option.key)) {
-                            keyToOption.set(option.key, {
-                                uid: option.uid,
-                                parentUids: [],
-                                key: option.key,
-                                displayName: option.displayName,
-                                type: option.type,
-                                subOptions: [],
-                            });
-                        }
-                        const existingOption = keyToOption.get(option.key);
-                        existingOption.parentUids = [...existingOption.parentUids, ...option.parentUids];
-                    }
-                    return Array.from(keyToOption.values());
-                };
-                // Recursive flattening function
-                const flatten = (curr, parent) => {
-                    var _a, _b, _c, _d;
-                    // Skip empty objects and none types
-                    if (!curr || curr.type === Models.OptionType.None) {
-                        return;
-                    }
-                    // Map uid to parent uid
-                    if (parent) {
-                        this.mapUidToParentUid.set(curr.uid, parent.uid);
-                    }
-                    // Process selectable
-                    if (curr.type === Models.OptionType.Selectable) {
-                        const newOption = {
-                            uid: curr.uid,
-                            parentUids: parent ? [parent.uid] : [],
-                            key: curr.key,
-                            displayName: curr.displayName,
-                            type: curr.type,
-                        };
-                        this.mapUidToOption.set(newOption.uid, newOption);
-                        const optionFilter = filtersKeyToFilter.get(parent.key);
-                        optionFilter.subOptions = [...((_a = optionFilter.subOptions) !== null && _a !== void 0 ? _a : []), newOption];
-                        // Go into subfilters
-                        for (const subOption of (_b = curr.subOptions) !== null && _b !== void 0 ? _b : []) {
-                            flatten(subOption, newOption);
-                        }
-                        return;
-                    }
-                    // Process filter
-                    if (!filtersKeyToFilter.has(curr.key)) {
-                        const newFilter = {
-                            uid: curr.uid,
-                            parentUids: parent ? [parent.uid] : [],
-                            key: curr.key,
-                            type: curr.type,
-                            displayName: curr.displayName,
-                            subOptions: [],
-                        };
-                        filtersKeyToFilter.set(curr.key, newFilter);
+     * Go through local filters and set up UI objects that will be rendered: filters and filter selectables
+     */ _define_property(this, "initLocalUiFilters", (options)=>{
+            this.mapUidToOption = new Map();
+            this.mapUidToParentUid = new Map();
+            const filtersKeyToFilter = new Map();
+            // Function to merge duplicate selectable options by key
+            const mergeDuplicates = (options)=>{
+                // Merge selectables with the same keys. Original uids will be stored in "parentUids"
+                const keyToOption = new Map();
+                for (const option of options){
+                    if (option.type !== Models.OptionType.Selectable) {
+                        continue;
                     }
-                    const filter = filtersKeyToFilter.get(curr.key);
-                    this.mapUidToOption.set(curr.uid, curr);
-                    for (const subOption of (_c = curr.subOptions) !== null && _c !== void 0 ? _c : []) {
-                        flatten(subOption, curr);
+                    if (!keyToOption.has(option.key)) {
+                        keyToOption.set(option.key, {
+                            uid: option.uid,
+                            parentUids: [],
+                            key: option.key,
+                            displayName: option.displayName,
+                            type: option.type,
+                            subOptions: []
+                        });
                     }
-                    if ((_d = filter.subOptions) === null || _d === void 0 ? void 0 : _d.length) {
-                        filter.subOptions = mergeDuplicates(filter.subOptions);
+                    const existingOption = keyToOption.get(option.key);
+                    existingOption.parentUids = [
+                        ...existingOption.parentUids,
+                        ...option.parentUids
+                    ];
+                }
+                return Array.from(keyToOption.values());
+            };
+            // Recursive flattening function
+            const flatten = (curr, parent)=>{
+                var _curr_subOptions;
+                var _filter_subOptions;
+                // Skip empty objects and none types
+                if (!curr || curr.type === Models.OptionType.None) {
+                    return;
+                }
+                // Map uid to parent uid
+                if (parent) {
+                    this.mapUidToParentUid.set(curr.uid, parent.uid);
+                }
+                // Process selectable
+                if (curr.type === Models.OptionType.Selectable) {
+                    var _optionFilter_subOptions, _curr_subOptions1;
+                    const newOption = {
+                        uid: curr.uid,
+                        parentUids: parent ? [
+                            parent.uid
+                        ] : [],
+                        key: curr.key,
+                        displayName: curr.displayName,
+                        type: curr.type
+                    };
+                    this.mapUidToOption.set(newOption.uid, newOption);
+                    const optionFilter = filtersKeyToFilter.get(parent.key);
+                    optionFilter.subOptions = [
+                        ...(_optionFilter_subOptions = optionFilter.subOptions) !== null && _optionFilter_subOptions !== void 0 ? _optionFilter_subOptions : [],
+                        newOption
+                    ];
+                    // Go into subfilters
+                    for (const subOption of (_curr_subOptions1 = curr.subOptions) !== null && _curr_subOptions1 !== void 0 ? _curr_subOptions1 : []){
+                        flatten(subOption, newOption);
                     }
-                };
-                for (const option of options) {
-                    flatten(option);
+                    return;
+                }
+                // Process filter
+                if (!filtersKeyToFilter.has(curr.key)) {
+                    const newFilter = {
+                        uid: curr.uid,
+                        parentUids: parent ? [
+                            parent.uid
+                        ] : [],
+                        key: curr.key,
+                        type: curr.type,
+                        displayName: curr.displayName,
+                        subOptions: []
+                    };
+                    filtersKeyToFilter.set(curr.key, newFilter);
                 }
-                this.filters = Array.from(filtersKeyToFilter.values());
+                const filter = filtersKeyToFilter.get(curr.key);
+                this.mapUidToOption.set(curr.uid, curr);
+                for (const subOption of (_curr_subOptions = curr.subOptions) !== null && _curr_subOptions !== void 0 ? _curr_subOptions : []){
+                    flatten(subOption, curr);
+                }
+                if ((_filter_subOptions = filter.subOptions) === null || _filter_subOptions === void 0 ? void 0 : _filter_subOptions.length) {
+                    filter.subOptions = mergeDuplicates(filter.subOptions);
+                }
+            };
+            for (const option of options){
+                flatten(option);
             }
+            this.filters = Array.from(filtersKeyToFilter.values());
         });
         makeObservable(this);
     }
-    initFilters(model, options) {
-        var _a, _b;
-        this.originalFilters = cloneDeep((_b = (_a = model === null || model === void 0 ? void 0 : model.options.subOptions) === null || _a === void 0 ? void 0 : _a.filter(x => x.type === Models.OptionType.Group)) !== null && _b !== void 0 ? _b : []);
-        this.initLocalFilters(this.originalFilters);
-        this.applyDefaultSelections(options === null || options === void 0 ? void 0 : options.isDefaultSelected);
-    }
-    export() {
-        return ModelsUtils.createSelectionsModel(this.originalFilters, this.selected);
-    }
-    /**
-     * Applies default selections based on the provided customization function.
-     * Iterates through all filters and their options, selecting those where
-     * isDefaultSelected returns true.
-     */
-    applyDefaultSelections(isDefaultSelected) {
-        if (!isDefaultSelected) {
-            return;
-        }
-        for (const filter of this.filters) {
-            const filterOptions = this.getFilterOptions(filter.key);
-            for (const option of filterOptions) {
-                if (isDefaultSelected(filter.key, option.key)) {
-                    this.selectOption(filter.key, option.key);
-                }
-            }
-        }
-    }
 }
-__decorate([
-    observable,
-    __metadata("design:type", Object)
+_ts_decorate([
+    observable
 ], FilterStore.prototype, "selected", void 0);
-__decorate([
+_ts_decorate([
     observable,
-    __metadata("design:type", Array)
+    _ts_metadata("design:type", Array)
 ], FilterStore.prototype, "filters", void 0);
-__decorate([
+_ts_decorate([
     action,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", void 0)
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Models === "undefined" || typeof Models.IFrontendModel === "undefined" ? Object : Models.IFrontendModel,
+        typeof IFilterStoreInitOptions === "undefined" ? Object : IFilterStoreInitOptions
+    ]),
+    _ts_metadata("design:returntype", void 0)
 ], FilterStore.prototype, "initFilters", null);
-__decorate([
-    action,
-    __metadata("design:type", Object)
+_ts_decorate([
+    action
 ], FilterStore.prototype, "selectOption", void 0);
-__decorate([
-    action,
-    __metadata("design:type", Object)
+_ts_decorate([
+    action
 ], FilterStore.prototype, "selectAll", void 0);
-__decorate([
-    action,
-    __metadata("design:type", Object)
+_ts_decorate([
+    action
 ], FilterStore.prototype, "deselectOption", void 0);
-__decorate([
-    action,
-    __metadata("design:type", Object)
+_ts_decorate([
+    action
 ], FilterStore.prototype, "deselectAll", void 0);
-__decorate([
+_ts_decorate([
     action,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Function]),
-    __metadata("design:returntype", void 0)
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof FilterDefaultSelectionFn === "undefined" ? Object : FilterDefaultSelectionFn
+    ]),
+    _ts_metadata("design:returntype", void 0)
 ], FilterStore.prototype, "applyDefaultSelections", null);
-__decorate([
-    action,
-    __metadata("design:type", Object)
+_ts_decorate([
+    action
 ], FilterStore.prototype, "uncheckDisabledOptions", void 0);
-__decorate([
-    action,
-    __metadata("design:type", Object)
+_ts_decorate([
+    action
 ], FilterStore.prototype, "initLocalUiFilters", void 0);
+
 //# sourceMappingURL=filter.store.js.map