@nyris/nyris-webapp 0.3.97 → 0.3.99

package/src/services/visualSearch.ts

@@ -9,6 +9,46 @@ import { isEqual } from 'lodash';
 
 import { DEFAULT_REGION } from '../constants';
 import { getUserLocation } from 'helpers/getGeoLocation';
+import { getNyrisSettings } from 'utils/nyrisApiKey';
+import useRequestStore from 'stores/request/requestStore';
+import useScopeStore from 'stores/scope/scopeStore';
+import { machinePartsPageText } from './machinePartsPage';
+import useMachinePartsListingStore from 'stores/machinePartsListing/machinePartsListingStore';
+
+const MACHINE_PARTS_LISTING_X_OPTIONS = 'hybrid_search.text.reranking=false';
+
+/** Scope-only listing: generated item-key text, no keyword, image, or filters. */
+export function machinePartsListingXOptions({
+  text,
+  hasSearchImage,
+  hasFilters,
+  scopeId,
+  itemKeys,
+  keyword,
+  pageIndex,
+  pageSize,
+}: {
+  text?: string;
+  hasSearchImage: boolean;
+  hasFilters: boolean;
+  scopeId: string | null;
+  itemKeys: readonly string[];
+  keyword: string;
+  pageIndex: number;
+  pageSize: number;
+}): string | undefined {
+  if (!scopeId || hasSearchImage || hasFilters) {
+    return undefined;
+  }
+  const listingText = machinePartsPageText(itemKeys, pageIndex, pageSize);
+  if (!listingText || text !== listingText) {
+    return undefined;
+  }
+  if (keyword.trim().length > 0) {
+    return undefined;
+  }
+  return MACHINE_PARTS_LISTING_X_OPTIONS;
+}
 
 export interface Filter {
   key?: string;
@@ -41,7 +81,7 @@ export const findRegions = async (
   image: HTMLCanvasElement,
   settings: NyrisAPISettings,
 ) => {
-  const nyrisApi = new NyrisAPI(settings);
+  const nyrisApi = new NyrisAPI(getNyrisSettings(settings));
   let regions = await nyrisApi.findRegions(image);
   const selectedRegion = getRegionByMaxConfidence(regions);
   return {
@@ -52,6 +92,18 @@ export const findRegions = async (
   };
 };
 
+/** Validated machine scope id. Item keys from /v1/scopes are not used. */
+function appliedMachineScopeId(): string | null {
+  if (!window.settings?.scopes?.scopeID) {
+    return null;
+  }
+  const { scopeId } = useScopeStore.getState();
+  if (typeof scopeId !== 'string' || scopeId.trim().length === 0) {
+    return null;
+  }
+  return scopeId;
+}
+
 export const find = async ({
   image,
   settings,
@@ -67,8 +119,9 @@ export const find = async ({
   text?: string;
   scopeIds?: string;
 }) => {
-  const nyrisApi = new NyrisAPI(settings);
-  let options: ImageSearchOptions = text ? { text } : {};
+  const nyrisApi = new NyrisAPI(getNyrisSettings(settings));
+  let options: ImageSearchOptions =
+    typeof text === 'string' && text.length > 0 ? { text } : {};
 
   if (window.settings?.geoLocation) {
     try {
@@ -84,13 +137,29 @@ export const find = async ({
   if (region) {
     options = { ...options, cropRect: region };
   }
+  const machineScopeId = appliedMachineScopeId();
+  const listingPage = useMachinePartsListingStore.getState();
+  const xOptions = machinePartsListingXOptions({
+    text,
+    hasSearchImage: Boolean(image),
+    hasFilters: Boolean(filters && filters.length > 0),
+    scopeId: machineScopeId,
+    itemKeys: useScopeStore.getState().itemKeys || [],
+    keyword: useRequestStore.getState().query || '',
+    pageIndex: listingPage.pageIndex,
+    pageSize: listingPage.pageSize,
+  });
   return nyrisApi.find(
     options,
     image,
     filters,
     undefined,
-    undefined,
-    scopeIds ? [scopeIds] : [],
+    xOptions,
+    machineScopeId
+      ? [machineScopeId]
+      : scopeIds
+        ? [scopeIds]
+        : [],
   );
 };
 
@@ -103,7 +172,7 @@ export const findCad = ({
   settings: NyrisAPISettings;
   filters?: Filter[];
 }) => {
-  const nyrisApi = new NyrisAPI(settings);
+  const nyrisApi = new NyrisAPI(getNyrisSettings(settings));
 
   return nyrisApi.findByCad(file, {}, filters);
 };
@@ -115,7 +184,7 @@ export const getRequestImage = ({
   url: string;
   settings: NyrisAPISettings;
 }) => {
-  const nyrisApi = new NyrisAPI(settings);
+  const nyrisApi = new NyrisAPI(getNyrisSettings(settings));
 
   return nyrisApi.getCadRequestImage(url);
 };

package/src/services/vizo.ts

@@ -1,6 +1,18 @@
 import { RectCoords } from '@nyris/nyris-api';
 import axios from 'axios';
 import { cropImage } from 'utils/cropImageToBase64';
+import { getEffectiveApiKey } from 'utils/nyrisApiKey';
+import { normalizeChatResponse } from './normalizeChatResponse';
+
+function resolveAiOrNyrisApiKey(explicitApiKey?: string): string {
+  if (explicitApiKey) {
+    return explicitApiKey;
+  }
+  if (window.settings.aiApiKey) {
+    return window.settings.aiApiKey;
+  }
+  return getEffectiveApiKey();
+}
 
 export interface ChatMultimodalInput {
   metadata: string;
@@ -111,7 +123,7 @@ export async function rerankSmartFilters({
       formData,
       {
         headers: {
-          'x-api-key': apiKey || window.settings.aiApiKey || window.settings.apiKey,
+          'x-api-key': resolveAiOrNyrisApiKey(apiKey),
         },
       },
     );
@@ -156,7 +168,7 @@ export async function generateSmartFilters({
       formData,
       {
         headers: {
-          'x-api-key':  window.settings.aiApiKey || window.settings.apiKey,
+          'x-api-key': resolveAiOrNyrisApiKey(),
         },
       },
     );
@@ -319,20 +331,20 @@ export async function chatAnalysis({
 }: ChatAnalysisParams): Promise<any> {
   try {
     const response = await axios.post(
-      'https://api.nyris.io/api/ai-analysis/chat',
+      `${window.settings.baseUrl}/api/ai-analysis/chat`,
       {
         promptKey,
         multimodalInputs,
       },
       {
         headers: {
-          'x-api-key': apiKey || window.settings.aiApiKey || '',
+          'x-api-key': resolveAiOrNyrisApiKey(apiKey),
           'Content-Type': 'application/json',
         },
       },
     );
 
-    return response.data;
+    return normalizeChatResponse(response.data);
   } catch (error: any) {
     if (error.response) {
       throw new Error(`API error: ${error.response.statusText}`);

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 {