@nyris/nyris-webapp 0.3.98 → 0.4.0

package/src/stores/chat/conversationStore.test.ts

@@ -0,0 +1,133 @@
+import useConversationStore from './conversationStore';
+
+beforeEach(() => {
+  window.settings = {
+    vizo: { requestSupport: true },
+    support: { emailInquiry: true, emailTemplateId: 'support-template' },
+  } as typeof window.settings;
+  useConversationStore.getState().reset();
+});
+
+const sendUserMessages = (count: number) => {
+  for (let index = 0; index < count; index += 1) {
+    useConversationStore.getState().addMessage({
+      role: 'user',
+      content: `Still searching ${index}`,
+    });
+  }
+};
+
+const addApiResponse = () => {
+  useConversationStore.getState().addMessage(
+    {
+      role: 'assistant',
+      content: 'Let us keep looking.',
+      options: [{ label: 'Continue search', action_type: 'filter' }],
+    },
+    { isApiResponse: true },
+  );
+};
+
+test('offers support within the third API reply, once per session', () => {
+  sendUserMessages(2);
+  addApiResponse();
+  expect(useConversationStore.getState().supportPromptShown).toBe(false);
+
+  sendUserMessages(1);
+  expect(useConversationStore.getState().supportPromptShown).toBe(false);
+  addApiResponse();
+  const state = useConversationStore.getState();
+  expect(state.userMessageCount).toBe(3);
+  expect(state.messages).toHaveLength(5);
+  expect(state.messages[state.messages.length - 1]).toMatchObject({
+    role: 'assistant',
+    content: 'Let us keep looking.',
+    options: [
+      { label: 'Continue search', action_type: 'filter' },
+      { label: 'Request support', action_type: 'request_support' },
+    ],
+  });
+
+  sendUserMessages(2);
+  addApiResponse();
+  expect(
+    useConversationStore
+      .getState()
+      .messages.filter(message =>
+        message.options?.some(
+          option => option.action_type === 'request_support',
+        ),
+      ),
+  ).toHaveLength(1);
+});
+
+test('waits for a response and excludes assistant and empty user messages', () => {
+  const store = useConversationStore.getState();
+  store.addMessage({ role: 'assistant', content: 'How can I help?' });
+  store.addMessage({ role: 'user', content: ' ' });
+  expect(useConversationStore.getState().userMessageCount).toBe(0);
+  sendUserMessages(3);
+  store.setIsLoading(true);
+  expect(useConversationStore.getState().supportPromptShown).toBe(false);
+  store.setIsLoading(false);
+  expect(useConversationStore.getState().supportPromptShown).toBe(false);
+  store.addMessage({ role: 'assistant', content: 'Something went wrong.' });
+  expect(useConversationStore.getState().supportPromptShown).toBe(false);
+  addApiResponse();
+  expect(useConversationStore.getState().supportPromptShown).toBe(true);
+});
+
+test('does not offer support after a successful outcome', () => {
+  sendUserMessages(3);
+  useConversationStore.getState().setSearchResolved(true);
+  addApiResponse();
+  expect(useConversationStore.getState().supportPromptShown).toBe(false);
+});
+
+test('offers support on the third reply when recovery exits without another API call', () => {
+  sendUserMessages(3);
+  useConversationStore.getState().addMessage({
+    role: 'assistant',
+    content: 'I was not able to find a match.',
+    action: { type: 'exit' },
+  });
+  const state = useConversationStore.getState();
+  expect(state.supportPromptShown).toBe(true);
+  expect(state.messages[state.messages.length - 1].options).toContainEqual({
+    label: 'Request support',
+    action_type: 'request_support',
+  });
+});
+
+test('a new session resets message counting and allows another support prompt', () => {
+  sendUserMessages(3);
+  addApiResponse();
+  useConversationStore.getState().startNewSession();
+  expect(useConversationStore.getState()).toMatchObject({
+    userMessageCount: 0,
+    supportPromptShown: false,
+    searchResolved: false,
+  });
+  sendUserMessages(3);
+  addApiResponse();
+  expect(useConversationStore.getState().supportPromptShown).toBe(true);
+});
+
+test('does not offer support when vizo.requestSupport is disabled', () => {
+  window.settings.vizo!.requestSupport = false;
+  sendUserMessages(3);
+  addApiResponse();
+  const state = useConversationStore.getState();
+  expect(state.supportPromptShown).toBe(false);
+  expect(state.messages[state.messages.length - 1].options).not.toContainEqual(
+    expect.objectContaining({ action_type: 'request_support' }),
+  );
+});
+
+test('offers support even when the inquiry banner and email template are disabled', () => {
+  window.settings.support.emailInquiry = false;
+  window.settings.support.emailTemplateId = '';
+  sendUserMessages(3);
+  addApiResponse();
+  expect(useConversationStore.getState().supportPromptShown).toBe(true);
+});

package/src/stores/chat/conversationStore.ts

@@ -39,7 +39,8 @@ export interface QuickReplyOption {
     | 'restore_previous'
     | 'related_part'
     | 'find_related_parts'
-    | 'restore_original';
+    | 'restore_original'
+    | 'request_support';
   value?: string;
   key?: string;
 }
@@ -72,7 +73,7 @@ export interface RelatedPartSuggestion {
 interface ConversationState {
   // Session state
   sessionId: string;
-  isEvaluated: boolean;  // P2 has fired
+  isEvaluated: boolean; // P2 has fired
   // Routing
   route: ConversationRoute;
   quality: ResultQuality;
@@ -84,6 +85,9 @@ interface ConversationState {
   // Conversation
   messages: ChatMessage[];
   activeFilters: ActiveFilter[];
+  userMessageCount: number;
+  supportPromptShown: boolean;
+  searchResolved: boolean;
 
   // UI state
   isOpen: boolean;
@@ -126,8 +130,12 @@ interface ConversationActions {
   ) => void;
 
   // Messages
-  addMessage: (message: Omit<ChatMessage, 'id' | 'timestamp'>) => void;
+  addMessage: (
+    message: Omit<ChatMessage, 'id' | 'timestamp'>,
+    options?: { isApiResponse?: boolean },
+  ) => void;
   clearMessages: () => void;
+  setSearchResolved: (resolved: boolean) => void;
 
   // Filters (for P3)
   addFilter: (key: string, value: string) => void;
@@ -172,6 +180,9 @@ const initialState: ConversationState = {
   attemptCounter: 0,
   messages: [],
   activeFilters: [],
+  userMessageCount: 0,
+  supportPromptShown: false,
+  searchResolved: false,
   isOpen: false, // Start closed so left panel is open by default
   hasNotification: false,
   isLoading: false,
@@ -240,20 +251,50 @@ const useConversationStore = create<ConversationState & ConversationActions>()(
       }));
     },
 
-    addMessage: message =>
-      set(state => ({
-        messages: [
-          ...state.messages,
-          {
-            ...message,
-            id: generateId(),
-            timestamp: Date.now(),
-          },
-        ],
-      })),
+    addMessage: (message, { isApiResponse = false } = {}) =>
+      set(state => {
+        const shouldOfferSupport =
+          window.settings?.vizo?.requestSupport &&
+          (isApiResponse || message.action?.type === 'exit') &&
+          message.role === 'assistant' &&
+          state.userMessageCount > 2 &&
+          !state.supportPromptShown &&
+          !state.searchResolved;
+
+        return {
+          userMessageCount:
+            state.userMessageCount +
+            (message.role === 'user' &&
+            (message.content.trim() || message.imageUrl)
+              ? 1
+              : 0),
+          supportPromptShown: state.supportPromptShown || shouldOfferSupport,
+          messages: [
+            ...state.messages,
+            {
+              ...message,
+              id: generateId(),
+              timestamp: Date.now(),
+              ...(shouldOfferSupport
+                ? {
+                    options: [
+                      ...(message.options || []),
+                      {
+                        label: 'Request support',
+                        action_type: 'request_support' as const,
+                      },
+                    ],
+                  }
+                : {}),
+            },
+          ],
+        };
+      }),
 
     clearMessages: () => set({ messages: [] }),
 
+    setSearchResolved: searchResolved => set({ searchResolved }),
+
     addFilter: (key, value) =>
       set(state => ({
         activeFilters: [

package/src/stores/machinePartsListing/machinePartsListingStore.ts

@@ -0,0 +1,35 @@
+import { create } from 'zustand';
+import {
+  DEFAULT_MACHINE_PARTS_PAGE_SIZE,
+  machinePartsPageText,
+} from 'services/machinePartsPage';
+import useScopeStore from 'stores/scope/scopeStore';
+
+interface MachinePartsListingState {
+  pageSize: number;
+  pageIndex: number;
+  setPageSize: (pageSize: number) => void;
+  setPageIndex: (pageIndex: number) => void;
+  resetPage: () => void;
+}
+
+const useMachinePartsListingStore = create<MachinePartsListingState>()(set => ({
+  pageSize: DEFAULT_MACHINE_PARTS_PAGE_SIZE,
+  pageIndex: 0,
+  setPageSize: pageSize => set({ pageSize, pageIndex: 0 }),
+  setPageIndex: pageIndex => set({ pageIndex }),
+  resetPage: () => set({ pageIndex: 0 }),
+}));
+
+/** Scope-only listing restarts at page 1 and keeps the selected page size. */
+export function firstMachinePartsListingText(): string | undefined {
+  useMachinePartsListingStore.getState().resetPage();
+  const { pageSize } = useMachinePartsListingStore.getState();
+  return machinePartsPageText(
+    useScopeStore.getState().itemKeys || [],
+    0,
+    pageSize,
+  );
+}
+
+export default useMachinePartsListingStore;

package/src/stores/request/filter/filter.initialState.ts

@@ -8,4 +8,5 @@ export const initialState: FilterState = {
   specificationFilter: {},
   postFilterSelections: {},
   preFilterLoading: false,
+  typePlatePreFilterValues: [],
 };

package/src/stores/request/filter/filter.slice.ts

@@ -13,6 +13,8 @@ const filterSlice: StateCreator<FilterState & FilterAction> = set => ({
   setPreFilterList: filter => set(() => ({ preFilterList: filter })),
   setPreFilterLoading: isLoading =>
     set(() => ({ preFilterLoading: isLoading })),
+  setTypePlatePreFilterValues: values =>
+    set(() => ({ typePlatePreFilterValues: values })),
   setPostFilterSelections: filters =>
     set(() => ({ postFilterSelections: filters })),
   togglePostFilterSelection: (attribute, value) =>

package/src/stores/result/prodcuts/products.initialState.ts

@@ -31,6 +31,7 @@ export const initialState: ProductsState = {
     rerankStatus: 'idle',
     errorMessage: null,
   },
+  requestQuality: null,
   postFilterFacets: [],
   initialFindSearchSnapshot: null,
 };

package/src/stores/result/prodcuts/products.slice.ts

@@ -61,6 +61,10 @@ const productsSlice: StateCreator<ProductsState & ProductsAction> = set => ({
     set(() => ({
       smartFilters,
     })),
+  setRequestQuality: requestQuality =>
+    set(() => ({
+      requestQuality,
+    })),
   setPostFilterFacets: facets =>
     set(() => ({
       postFilterFacets: facets,

package/src/stores/scope/scopeStore.ts

@@ -1,35 +1,98 @@
 import { create } from 'zustand';
 import { Filter } from '@nyris/nyris-api';
 
+export type ScopeSource = 'manual' | 'image';
+
+export type AppliedScopeInput =
+  | { source: 'manual'; value: string }
+  | { source: 'image'; fileKey: string };
+
 interface ScopeState {
   itemKeys: string[];
   filterAttributes: Filter[];
+  scopeId: string | null;
   isLoading: boolean;
   hasFetched: boolean;
+  formResetKey: number;
+  manualScopeId: string;
+  pendingFile: File | null;
+  previewUrl: string | null;
+  activeSource: ScopeSource | null;
+  lastAppliedInput: AppliedScopeInput | null;
+  lastExtractedFromImage: string;
 }
 
 interface ScopeAction {
-  setScope: (itemKeys: string[], filterAttributes: Filter[]) => void;
+  setScope: (
+    itemKeys: string[],
+    filterAttributes: Filter[],
+    scopeId?: string | null,
+  ) => void;
   setScopeLoading: (isLoading: boolean) => void;
   setScopeFetched: (hasFetched: boolean) => void;
+  setManualScopeId: (manualScopeId: string) => void;
+  setPendingFile: (pendingFile: File | null) => void;
+  setPreviewUrl: (previewUrl: string | null) => void;
+  setActiveSource: (activeSource: ScopeSource | null) => void;
+  setLastAppliedInput: (lastAppliedInput: AppliedScopeInput | null) => void;
+  setLastExtractedFromImage: (lastExtractedFromImage: string) => void;
   resetScope: () => void;
 }
 
 const initialState: ScopeState = {
   itemKeys: [],
   filterAttributes: [],
+  scopeId: null,
   isLoading: false,
   hasFetched: false,
+  formResetKey: 0,
+  manualScopeId: '',
+  pendingFile: null,
+  previewUrl: null,
+  activeSource: null,
+  lastAppliedInput: null,
+  lastExtractedFromImage: '',
 };
 
 const useScopeStore = create<ScopeState & ScopeAction>()(set => ({
   ...initialState,
 
-  setScope: (itemKeys, filterAttributes) =>
-    set({ itemKeys, filterAttributes, hasFetched: true }),
+  setScope: (itemKeys, filterAttributes, scopeId = null) =>
+    set({ itemKeys, filterAttributes, scopeId, hasFetched: true }),
   setScopeLoading: isLoading => set({ isLoading }),
   setScopeFetched: hasFetched => set({ hasFetched }),
-  resetScope: () => set(initialState),
+  setManualScopeId: manualScopeId => set({ manualScopeId }),
+  setPendingFile: pendingFile => set({ pendingFile }),
+  setPreviewUrl: previewUrl => set({ previewUrl }),
+  setActiveSource: activeSource => set({ activeSource }),
+  setLastAppliedInput: lastAppliedInput => set({ lastAppliedInput }),
+  setLastExtractedFromImage: lastExtractedFromImage =>
+    set({ lastExtractedFromImage }),
+  resetScope: () =>
+    set(state => {
+      if (state.previewUrl) {
+        try {
+          URL.revokeObjectURL(state.previewUrl);
+        } catch {}
+      }
+      return {
+        ...initialState,
+        formResetKey: state.formResetKey + 1,
+      };
+    }),
 }));
 
+/** Machine scope that should constrain the results currently on screen. */
+export function hasActiveMachineScope(): boolean {
+  if (!window.settings?.scopes?.scopeID) {
+    return false;
+  }
+  const { scopeId, itemKeys } = useScopeStore.getState();
+  return (
+    typeof scopeId === 'string' &&
+    scopeId.trim().length > 0 &&
+    itemKeys.length > 0
+  );
+}
+
 export default useScopeStore;

package/src/stores/types.ts

@@ -71,20 +71,21 @@ export interface ProductsState {
   groundingError: string | null;
   firstAlgoliaProducts: any[];
   fullResultPool: any[];
-    smartFilters: {
-        status: 'idle' | 'loading' | 'success' | 'error';
-        filters: Array<{
-            key: string;
-            label: string;
-            value: string;
-            selected?: boolean;
-        }>;
-        selectedFilterKey: string | null;
-        selectedFilterValue: string | null;
-        rerankedSkus: string[];
-        rerankStatus: 'idle' | 'loading' | 'success' | 'error';
-        errorMessage: string | null;
-    };
+  smartFilters: {
+    status: 'idle' | 'loading' | 'success' | 'error';
+    filters: Array<{
+      key: string;
+      label: string;
+      value: string;
+      selected?: boolean;
+    }>;
+    selectedFilterKey: string | null;
+    selectedFilterValue: string | null;
+    rerankedSkus: string[];
+    rerankStatus: 'idle' | 'loading' | 'success' | 'error';
+    errorMessage: string | null;
+  };
+  requestQuality: string | null;
   postFilterFacets: any[];
   initialFindSearchSnapshot: {
     results: any[];
@@ -110,6 +111,7 @@ export interface ProductsAction {
   setFullResultPool: (products: any[]) => void;
   resetGrounding: () => void;
   setSmartFilters: (smartFilters: ProductsState['smartFilters']) => void;
+  setRequestQuality: (requestQuality: string | null) => void;
   setPostFilterFacets: (facets: any[]) => void;
   setInitialFindSearchSnapshot: (
     snapshot: ProductsState['initialFindSearchSnapshot'],
@@ -132,6 +134,8 @@ export interface FilterState {
   specificationFilter: Record<string, string>;
   postFilterSelections: Record<string, string[]>;
   preFilterLoading: boolean;
+  // Values applied from type-plate upload; cleared independently of manual picks.
+  typePlatePreFilterValues: string[];
 }
 
 export interface FilterAction {
@@ -144,6 +148,7 @@ export interface FilterAction {
   togglePostFilterSelection: (attribute: string, value: string) => void;
   clearPostFilterSelections: () => void;
   setPreFilterLoading: (isLoading: boolean) => void;
+  setTypePlatePreFilterValues: (values: string[]) => void;
 }
 
 export interface MiscState {