@servicetitan/titan-chatbot-api 5.3.0 → 6.0.0

package/src/stores/__tests__/filter.store.test.ts

@@ -401,4 +401,86 @@ describe('[FilterStore]', () => {
         store.selectOption('Sources', 'Jarvis');
         checkDisabled([false, false, false, false, false]);
     });
+
+    describe('isDefaultSelected customization', () => {
+        test('should not select any options by default when isDefaultSelected is not provided', () => {
+            store.initFilters(ModelsMocks.mockFrontendModel());
+
+            expect(store.selected.get('Sources')).toBeUndefined();
+            expect(store.selected.get('ContentTypes')).toBeUndefined();
+            expect(store.selected.get('ProductAreas')).toBeUndefined();
+        });
+
+        test('should select options where isDefaultSelected returns true', () => {
+            store.initFilters(ModelsMocks.mockFrontendModel(), {
+                isDefaultSelected: (filterKey, optionKey) => {
+                    return filterKey === 'Sources' && optionKey === 'KnowledgeBase';
+                },
+            });
+
+            expect(store.selected.get('Sources')).toEqual(['KnowledgeBase']);
+            expect(store.selected.get('ContentTypes')).toBeUndefined();
+            expect(store.selected.get('ProductAreas')).toBeUndefined();
+        });
+
+        test('should select multiple options across filters when isDefaultSelected returns true', () => {
+            store.initFilters(ModelsMocks.mockFrontendModel(), {
+                isDefaultSelected: (filterKey, optionKey) => {
+                    if (filterKey === 'Sources') {
+                        return true; // Select all sources
+                    }
+                    if (filterKey === 'ProductAreas' && optionKey === 'Marketing') {
+                        return true;
+                    }
+                    return false;
+                },
+            });
+
+            expect(store.selected.get('Sources')).toEqual(['KnowledgeBase', 'Jarvis']);
+            expect(store.selected.get('ContentTypes')).toBeUndefined();
+            expect(store.selected.get('ProductAreas')).toEqual(['Marketing']);
+        });
+
+        test('should not select any options when isDefaultSelected always returns false', () => {
+            store.initFilters(ModelsMocks.mockFrontendModel(), {
+                isDefaultSelected: () => false,
+            });
+
+            expect(store.selected.get('Sources')).toBeUndefined();
+            expect(store.selected.get('ContentTypes')).toBeUndefined();
+            expect(store.selected.get('ProductAreas')).toBeUndefined();
+        });
+
+        test('should select all options when isDefaultSelected always returns true', () => {
+            store.initFilters(ModelsMocks.mockFrontendModel(), {
+                isDefaultSelected: () => true,
+            });
+
+            expect(store.selected.get('Sources')).toEqual(['KnowledgeBase', 'Jarvis']);
+            expect(store.selected.get('ContentTypes')).toEqual([
+                'kbReleaseNotes',
+                'kbFaq',
+                'kbHowTo',
+                'xxx',
+                'yyy',
+            ]);
+            expect(store.selected.get('ProductAreas')).toEqual([
+                'Call Booking',
+                'Marketing',
+                'Marketing Pro',
+            ]);
+        });
+
+        test('should work with flat filter structure', () => {
+            store.initFilters(ModelsMocks.mockFrontendModelFlat(), {
+                isDefaultSelected: (filterKey, optionKey) => {
+                    return filterKey === 'ContentTypes' && optionKey === 'kbFaq';
+                },
+            });
+
+            expect(store.selected.get('Sources')).toBeUndefined();
+            expect(store.selected.get('ContentTypes')).toEqual(['kbFaq']);
+            expect(store.selected.get('ProductAreas')).toBeUndefined();
+        });
+    });
 });

package/src/stores/chatbot-ui-backend.store.ts

@@ -253,7 +253,9 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
         await super.initializeInternal();
         const options = await this.chatbotApiClient.getOptions();
         runInAction(() => {
-            this.chatUiStore.filterStore.initFilters(options);
+            this.chatUiStore.filterStore.initFilters(options, {
+                isDefaultSelected: this.customizations?.filters?.isDefaultSelected,
+            });
         });
     }
 

package/src/stores/chatbot-ui.store.ts

@@ -3,7 +3,7 @@ import { ChatUiEvent, ChatUiStore, IChatUiStore } from '@servicetitan/titan-chat
 import { action, makeObservable } from 'mobx';
 import { Models } from '../api-client';
 import { ChatbotCustomizations } from '../models';
-import { FilterStore, IFilterStore } from './filter.store';
+import { FilterStore, IFilterStore, IFilterStoreInitOptions } from './filter.store';
 
 export const CHATBOT_UI_STORE_TOKEN = symbolToken<IChatbotUiStore>('CHATBOT_UI_STORE_TOKEN');
 
@@ -16,7 +16,7 @@ export enum ChatbotUiEvent {
 export interface IChatbotUiStore extends IChatUiStore<ChatbotCustomizations> {
     filterStore: IFilterStore;
     settings?: Models.IFrontendModel;
-    setFilters: (filterOptions: Models.IFrontendModel) => void;
+    setFilters: (filterOptions: Models.IFrontendModel, options?: IFilterStoreInitOptions) => void;
     startSession: (
         sessionData?: Models.ISession['data'],
         forceRecreate?: boolean
@@ -59,8 +59,8 @@ export class ChatbotUiStore extends ChatUiStore<ChatbotCustomizations> implement
     }
 
     @action
-    setFilters(filterOptions: Models.IFrontendModel) {
-        this.filterStore.initFilters(filterOptions);
+    setFilters(filterOptions: Models.IFrontendModel, options?: IFilterStoreInitOptions) {
+        this.filterStore.initFilters(filterOptions, options);
     }
 
     @action

package/src/stores/filter.store.ts

@@ -2,6 +2,7 @@ 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 interface IUiFilterOption {
     uid: string;
@@ -12,10 +13,17 @@ export interface IUiFilterOption {
     subOptions?: IUiFilterOption[] | undefined;
 }
 
+export interface IFilterStoreInitOptions {
+    /**
+     * Function to determine if a filter option should be selected by default.
+     */
+    isDefaultSelected?: FilterDefaultSelectionFn;
+}
+
 export interface IFilterStore {
     selected: Map<string, string[]>;
     filters: IUiFilterOption[];
-    initFilters(model: Models.IFrontendModel): void;
+    initFilters(model: Models.IFrontendModel, options?: IFilterStoreInitOptions): void;
     isOptionChecked(filterKey: string, optionKey: string): boolean;
     isOptionDisabled(filterKey: string, optionKey: string): boolean;
     getFilterOptions(filterKey: string): IUiFilterOption[];
@@ -46,11 +54,12 @@ export class FilterStore implements IFilterStore {
     }
 
     @action
-    initFilters(model: Models.IFrontendModel) {
+    initFilters(model: Models.IFrontendModel, options?: IFilterStoreInitOptions) {
         this.originalFilters = cloneDeep(
             model?.options.subOptions?.filter(x => x.type === Models.OptionType.Group) ?? []
         );
         this.initLocalFilters(this.originalFilters as IUiFilterOption[]);
+        this.applyDefaultSelections(options?.isDefaultSelected);
     }
 
     isOptionChecked = (filterKey: string, optionKey: string): boolean => {
@@ -164,6 +173,26 @@ export class FilterStore implements IFilterStore {
         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.
+     */
+    @action
+    private applyDefaultSelections(isDefaultSelected?: FilterDefaultSelectionFn) {
+        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);
+                }
+            }
+        }
+    }
+
     private assertFilterKeyExists = (filterKey: string) => {
         const filter = this.getFilterByKey(filterKey);
         if (!filter) {

package/src/stores/index.ts

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