@servicetitan/titan-chatbot-api 4.3.3 → 4.4.1

package/src/stores/filter.store.ts

@@ -3,17 +3,43 @@ import { action, makeObservable, observable } from 'mobx';
 import { nanoid } from 'nanoid';
 import { Models, ModelsUtils } from '../api-client';
 
-interface IOption extends Models.IOption {
-    uid?: string;
-    parentKeys?: string[];
+export interface IUiFilterOption {
+    uid: string;
+    parentUids: string[];
+    key: string;
+    displayName?: string | undefined;
+    type: Models.OptionType;
+    subOptions?: IUiFilterOption[] | undefined;
 }
 
-export class FilterStore {
-    @observable selectedOptions: Record<string, string[]> = {};
-    @observable filters: IOption[] = [];
+export interface IFilterStore {
+    selected: Map<string, string[]>;
+    filters: IUiFilterOption[];
+    initFilters(model: Models.IFrontendModel): void;
+    isOptionChecked(filterKey: string, optionKey: string): boolean;
+    isOptionDisabled(filterKey: string, optionKey: string): boolean;
+    getFilterOptions(filterKey: string): IUiFilterOption[];
+    selectOption(filterKey: string, optionKey: string): void;
+    selectAll(filterKey: string): void;
+    deselectOption(filterKey: string, optionKey: string): void;
+    deselectAll(filterKey: string): void;
+    getFilterLabel(key: string): string;
+    export(): Models.Selections | undefined;
+}
 
-    private model?: Models.IFrontendModel;
-    private originalFilters: IOption[] = [];
+export class FilterStore implements IFilterStore {
+    /**
+     * Selected items map: filter key -> selectable keys
+     */
+    @observable selected = new Map<string, string[]>();
+    /**
+     * Available filters with their selectable options (flattened and merged)
+     */
+    @observable filters: IUiFilterOption[] = [];
+    private localFilters: IUiFilterOption[] = [];
+    private originalFilters: Models.IOption[] = [];
+    private mapUidToOption = new Map<string, IUiFilterOption>();
+    private mapUidToParentUid = new Map<string, string | undefined>();
 
     constructor() {
         makeObservable(this);
@@ -21,56 +47,108 @@ export class FilterStore {
 
     @action
     initFilters(model: Models.IFrontendModel) {
-        const setUids = (o?: IOption[]) => {
-            o?.forEach(x => {
-                x.uid = nanoid();
-                setUids(x.subOptions as IOption[]);
-            });
-        };
-
-        this.model = model;
         this.originalFilters = cloneDeep(
-            model!.options.subOptions?.filter(x => x.type === Models.OptionType.Group) ?? []
+            model?.options.subOptions?.filter(x => x.type === Models.OptionType.Group) ?? []
         );
-        setUids(this.originalFilters);
-        this.filters = this.originalFilters;
+        this.initLocalFilters(this.originalFilters as IUiFilterOption[]);
     }
 
+    isOptionChecked = (filterKey: string, optionKey: string): boolean => {
+        const selectedOptions = this.selected.get(filterKey);
+        if (!selectedOptions) {
+            return false;
+        }
+        return selectedOptions.includes(optionKey);
+    };
+
+    isOptionDisabled = (filterKey: string, optionKey: string): boolean => {
+        const filter = this.getFilterByKey(filterKey);
+        const option = 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)) {
+            if (!optionFilter?.parentUids?.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;
+                }
+                const parentFilter = this.getOptionFilter(parentOption);
+                if (!parentFilter) {
+                    continue;
+                }
+                const isParentSelected = this.isOptionChecked(parentFilter.key, parentOption.key);
+                if (isParentSelected) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    };
+
+    getFilterOptions = (filterKey: string): IUiFilterOption[] => {
+        const filter = this.getFilterByKey(filterKey);
+        if (!filter?.subOptions) {
+            return [];
+        }
+        return filter.subOptions.filter(x => x.type === Models.OptionType.Selectable);
+    };
+
     @action
     selectOption = (filterKey: string, optionKey: string) => {
-        const allFilterOptions = this.getExistingFilterOptions(filterKey);
-        const option = allFilterOptions.find(o => o.key === optionKey);
-        if (!option) {
-            throw new Error(`Option "${optionKey}" does not exist in the filter "${filterKey}".`);
+        this.assertFilterKeyExists(filterKey);
+        this.assertOptionKeyExists(filterKey, optionKey);
+        if (!this.selected.has(filterKey)) {
+            this.selected.set(filterKey, []);
         }
-        if (!this.selectedOptions[filterKey]) {
-            this.selectedOptions[filterKey] = [];
+        const selectedOptions = this.selected.get(filterKey)!;
+        if (selectedOptions.includes(optionKey)) {
+            return;
         }
-        this.selectedOptions[filterKey] = [...this.selectedOptions[filterKey], option.key];
-        this.addSubSequentFilters(filterKey);
+        this.selected.set(filterKey, [...selectedOptions, optionKey]);
     };
 
     @action
     selectAll = (filterKey: string) => {
-        this.selectedOptions[filterKey] = this.getExistingFilterOptions(filterKey).map(o => o.key);
-        this.addSubSequentFilters(filterKey);
+        this.assertFilterKeyExists(filterKey);
+        const filter = this.getFilterByKey(filterKey);
+        if (!filter?.subOptions) {
+            return;
+        }
+        const selectableOptions = filter.subOptions.filter(
+            x => x.type === Models.OptionType.Selectable
+        );
+        this.selected.set(
+            filterKey,
+            selectableOptions.map(o => o.key)
+        );
     };
 
     @action
     deselectOption = (filterKey: string, optionKey: string) => {
-        this.selectedOptions[filterKey] = this.selectedOptions[filterKey].filter(
-            o => o !== optionKey
+        this.assertFilterKeyExists(filterKey);
+        this.assertOptionKeyExists(filterKey, optionKey);
+        const selectedOptions = this.selected.get(filterKey) ?? [];
+        this.selected.set(
+            filterKey,
+            selectedOptions.filter(o => o !== optionKey)
         );
-        this.cleanUpFilterOptions(filterKey, optionKey);
-        this.removeSubSequentFilters(filterKey);
-        this.addSubSequentFilters(filterKey);
+        this.uncheckDisabledOptions();
     };
 
     @action
     deselectAll = (filterKey: string) => {
-        for (const selectedKey of this.selectedOptions[filterKey]) {
-            this.deselectOption(filterKey, selectedKey);
-        }
+        this.assertFilterKeyExists(filterKey);
+        this.selected.set(filterKey, []);
+        this.uncheckDisabledOptions();
     };
 
     getFilterLabel = (key: string) => {
@@ -83,180 +161,165 @@ export class FilterStore {
     };
 
     export(): Models.Selections | undefined {
-        return ModelsUtils.createSelectionsModel(this.originalFilters, this.selectedOptions);
+        return ModelsUtils.createSelectionsModel(this.originalFilters, this.selected);
     }
 
-    @action
-    private removeSubSequentFilters = (filterKey: string) => {
-        const filter = this.getExistingFilterByKey(filterKey);
-        const subFilters = this.getSubFilters(filter);
-        this.filters = this.filters.filter(x => !subFilters.some(f => f.key === x.key));
-    };
-
-    @action
-    private addSubSequentFilters = (filterKey: string) => {
-        const filter = this.getExistingFilterByKey(filterKey);
-        if (!filter.subOptions) {
-            return;
+    private assertFilterKeyExists = (filterKey: string) => {
+        const filter = this.getFilterByKey(filterKey);
+        if (!filter) {
+            throw new Error(`Filter with key "${filterKey}" does not exist.`);
         }
+    };
 
-        // Get selected items for the filter
-        const filterSelectedKeys = this.selectedOptions[filterKey] ?? [];
-        const filterSelectedOptions: IOption[] = filter.subOptions.filter(
-            x => x.type === Models.OptionType.Selectable && filterSelectedKeys.includes(x.key!)
-        );
-
-        // Find all sub-filters for the selected options
-        const allSubFilters: IOption[] =
-            filterSelectedOptions.flatMap<IOption>(selectedOption => {
-                // For each selected option, collect its sub-filters
-                const subFilters: IOption[] = [];
-                for (const subFilter of selectedOption.subOptions ?? []) {
-                    const originalFilter = cloneDeep(
-                        this.getOriginalFilter((subFilter as IOption).uid)
-                    );
-                    originalFilter.parentKeys = [selectedOption.uid!];
-                    subFilters.push(originalFilter);
-                }
-                return subFilters;
-            }) ?? [];
-
-        // Merge sub-filters with the same key and their options (with parent keys merging)
-        const mergedSubFilters = allSubFilters.reduce<IOption[]>((acc, subFilter) => {
-            if (!subFilter.subOptions) {
-                return acc;
-            }
-            const subfilterOptions = (subFilter.subOptions ?? []) as IOption[];
-            const subfilterParentKeys = subFilter.parentKeys;
-
-            // Merge filters with the same key and their options if they already exist
-            subfilterOptions.forEach(subfilterOption => {
-                subfilterOption.parentKeys = this.mergeParentKeys(
-                    subfilterOption.parentKeys,
-                    subfilterParentKeys
-                );
-            });
-
-            // Check if the filter already exists in the accumulator
-            const existingFilter = acc.find(x => x.key === subFilter.key);
-            if (!existingFilter) {
-                return [...acc, subFilter];
-            }
-
-            // Merge parent keys for the filter
-            existingFilter.parentKeys = this.mergeParentKeys(
-                existingFilter.parentKeys,
-                subfilterParentKeys
+    private assertOptionKeyExists = (filterKey: string, optionKey: string) => {
+        this.assertFilterKeyExists(filterKey);
+        const filter = this.getFilterByKey(filterKey)!;
+        const option = filter.subOptions?.find(o => o.key === optionKey);
+        if (!option) {
+            throw new Error(
+                `Option with key "${optionKey}" does not exist in filter "${filterKey}".`
             );
-
-            // Merge options for subfilters by key
-            existingFilter.subOptions = subfilterOptions.reduce(
-                (acc2, subfilterOption) => {
-                    const existing = acc2.find(o => o.key === subfilterOption.key) as
-                        | IOption
-                        | undefined;
-                    if (!existing) {
-                        return [...acc2, subfilterOption];
-                    }
-                    existing.parentKeys = this.mergeParentKeys(
-                        existing.parentKeys,
-                        subfilterOption.parentKeys
-                    );
-
-                    return acc2;
-                },
-                [...(existingFilter.subOptions ?? [])]
-            ) as Models.Option[];
-            return acc;
-        }, []);
-
-        // Update the filters with the merged sub-filters
-        for (const newFilter of mergedSubFilters) {
-            const existingFilterIdx = this.filters.findIndex(f => f.key === newFilter.key);
-            if (existingFilterIdx < 0) {
-                this.filters.push(newFilter);
-            } else {
-                this.filters[existingFilterIdx] = newFilter;
-            }
-            this.addSubSequentFilters(newFilter.key);
         }
     };
 
-    private mergeParentKeys = (keys1?: string[], keys2?: string[]): string[] => {
-        if (!keys1 && !keys2) {
-            return [];
-        }
-        if (!keys1) {
-            return keys2 ?? [];
-        }
-        if (!keys2) {
-            return keys1;
+    private getFilterByKey = (filterKey: string): IUiFilterOption | undefined => {
+        return this.filters.find(f => f.key === filterKey);
+    };
+
+    private getOptionFilter = (option: IUiFilterOption): IUiFilterOption | undefined => {
+        const parentUid = this.mapUidToParentUid.get(option.uid);
+        if (!parentUid) {
+            return undefined;
         }
-        const mergedKeys = new Set<string>([...keys1, ...keys2]);
-        return Array.from(mergedKeys);
+        return this.mapUidToOption.get(parentUid);
     };
 
-    private cleanUpFilterOptions = (filterKey: string, parentKeyToRemove: string) => {
-        const filter = this.getExistingFilterByKey(filterKey);
-        const filterSubOptionToRemove = filter.subOptions?.find(x => x.key === parentKeyToRemove);
-        const filterSubOptionToRemoveUid = (filterSubOptionToRemove as IOption)?.uid;
-        const filterIdx = this.filters.findIndex(f => f.key === filterKey);
-        for (let i = filterIdx + 1; i < this.filters.length; i++) {
-            const subFilter = this.filters[i];
-            if (!subFilter.parentKeys?.some(k => k === filterSubOptionToRemoveUid)) {
-                // If the sub-filter does not depend on the removed option, skip it
+    @action
+    private uncheckDisabledOptions = () => {
+        for (const [filterKey, selectedOptions] of this.selected.entries()) {
+            const filter = this.getFilterByKey(filterKey);
+            if (!filter) {
                 continue;
             }
-            subFilter.subOptions?.forEach((o: IOption) => {
-                o.parentKeys = (o.parentKeys ?? []).filter(p => p !== filterSubOptionToRemoveUid);
-                // Uncheck sub-filter options if they no longer have parent keys
-                if (!o.parentKeys?.length) {
-                    this.selectedOptions[subFilter.key] = this.selectedOptions[
-                        subFilter.key
-                    ]?.filter(x => x !== o.key);
+            const validSelectedOptions = selectedOptions.filter(optionKey => {
+                const option = filter.subOptions?.find(o => o.key === optionKey);
+                if (!option) {
+                    return false;
                 }
+                return !this.isOptionDisabled(filterKey, optionKey);
             });
-            subFilter.subOptions = subFilter.subOptions?.filter((o: IOption) =>
-                Boolean(o.parentKeys?.length)
-            );
+            this.selected.set(filterKey, validSelectedOptions);
         }
     };
 
-    private getSubFilters = (filter: IOption): IOption[] => {
-        const result: IOption[] = [];
-        filter.subOptions?.forEach(filterSelectable => {
-            filterSelectable.subOptions?.forEach(subFilter => {
-                result.push(subFilter, ...this.getSubFilters(subFilter));
+    /**
+     * 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).
+     */
+    private initLocalFilters = (options: IUiFilterOption[]) => {
+        // Set up local filters uids
+        this.localFilters = cloneDeep(options);
+        const setUids = (o?: IUiFilterOption[], parentUid?: string) => {
+            if (!o) {
+                return;
+            }
+            o.forEach(x => {
+                x.uid = nanoid();
+                x.parentUids = parentUid ? [parentUid] : [];
+                setUids(x.subOptions, x.uid);
             });
-        });
-        return result;
+        };
+        setUids(this.localFilters);
+        this.initLocalUiFilters(this.localFilters);
     };
 
-    private getOriginalFilters = (): IOption[] => {
-        return this.originalFilters.reduce<IOption[]>((acc, next) => {
-            return [...acc, next, ...this.getSubFilters(next)];
-        }, []);
-    };
+    /**
+     * Go through local filters and set up UI objects that will be rendered: filters and filter selectables
+     */
+    @action
+    private initLocalUiFilters = (options: IUiFilterOption[]) => {
+        this.mapUidToOption = new Map<string, IUiFilterOption>();
+        this.mapUidToParentUid = new Map<string, string | undefined>();
+        const filtersKeyToFilter = new Map<string, IUiFilterOption>();
 
-    private getOriginalFilter = (uid?: string): IOption => {
-        const originalFilters = this.getOriginalFilters();
-        const filter = originalFilters.find(f => f.uid === uid);
-        if (!filter) {
-            throw new Error(`Filter with key "${uid}" does not exist.`);
-        }
-        return filter;
-    };
+        // Function to merge duplicate selectable options by key
+        const mergeDuplicates = (options: IUiFilterOption[]) => {
+            // Merge selectables with the same keys. Original uids will be stored in "parentUids"
+            const keyToOption = new Map<string, IUiFilterOption>();
+            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());
+        };
 
-    private getExistingFilterOptions = (filterKey: string): IOption[] => {
-        const filter = this.getExistingFilterByKey(filterKey);
-        return filter.subOptions?.filter(x => x.type === Models.OptionType.Selectable) ?? [];
-    };
+        // Recursive flattening function
+        const flatten = (curr: IUiFilterOption, parent?: IUiFilterOption) => {
+            // 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);
+            }
 
-    private getExistingFilterByKey = (filterKey: string): IOption => {
-        const filter = this.filters.find(f => f.key === filterKey);
-        if (!filter) {
-            throw new Error(`Filter with key "${filterKey}" does not exist.`);
+            // Process selectable
+            if (curr.type === Models.OptionType.Selectable) {
+                const newOption: IUiFilterOption = {
+                    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 ?? []), newOption];
+                // Go into subfilters
+                for (const subOption of curr.subOptions ?? []) {
+                    flatten(subOption, newOption);
+                }
+                return;
+            }
+
+            // Process filter
+            if (!filtersKeyToFilter.has(curr.key)) {
+                const newFilter: IUiFilterOption = {
+                    uid: curr.uid,
+                    parentUids: parent ? [parent.uid] : [],
+                    key: curr.key,
+                    type: curr.type,
+                    displayName: curr.displayName,
+                    subOptions: [],
+                };
+                filtersKeyToFilter.set(curr.key, newFilter);
+            }
+            const filter = filtersKeyToFilter.get(curr.key)!;
+            this.mapUidToOption.set(curr.uid, curr);
+            for (const subOption of curr.subOptions ?? []) {
+                flatten(subOption, curr);
+            }
+            if (filter.subOptions?.length) {
+                filter.subOptions = mergeDuplicates(filter.subOptions);
+            }
+        };
+        for (const option of options) {
+            flatten(option);
         }
-        return filter;
+        this.filters = Array.from(filtersKeyToFilter.values());
     };
 }

package/src/stores/index.ts

@@ -9,6 +9,7 @@ export {
     ChatbotUiStore,
     ChatbotUiEvent,
 } from './chatbot-ui.store';
+export { type IUiFilterOption, type IFilterStore } from './filter.store';
 export { InitializeStore, InitializeStoreStatus } from './initialize.store';
 export { MessageFeedbackStore } from './message-feedback.store';
 export { MessageFeedbackGuardrailStore } from './message-feedback-guardrail.store';