@nyris/nyris-webapp 0.3.97 → 0.3.99

package/src/services/feedbackSubtypes.ts

@@ -0,0 +1,63 @@
+/**
+ * Recommended subtype vocabulary for Feedback API events.
+ *
+ * Subtypes are free strings on the API side, so customers can add their own,
+ * but these constants are the default vocabulary the search suite converges on.
+ * Casing is normalized (trimmed + lowercased) before sending; the API does the
+ * same at ingestion.
+ */
+
+export const FEEDBACK_EVENT = {
+  CLICK: 'click',
+  CONVERSION: 'conversion',
+  FEEDBACK: 'feedback',
+  REGION: 'region',
+} as const;
+
+/** Interaction actions on the result set. */
+export const CLICK_SUBTYPE = {
+  RESULT_CARD: 'result_card',
+  EXPAND_DETAILS: 'expand_details',
+  SIMILAR_PART_SEARCH: 'similar_part_search',
+  COPY_DETAILS: 'copy_details',
+  RAISE_INQUIRY: 'raise_inquiry',
+  FILTER_APPLIED: 'filter_applied',
+  PRE_FILTER_APPLIED: 'pre_filter_applied',
+  CHAT_WITH_VIZO: 'chat_with_vizo',
+} as const;
+
+/** Actions that create business value. Omit subtype for legacy conversions. */
+export const CONVERSION_SUBTYPE = {
+  ADD_TO_CART: 'add_to_cart',
+  PURCHASE: 'purchase',
+  DOWNLOAD_CART: 'download_cart',
+  SHARE_CART: 'share_cart',
+} as const;
+
+/** Explicit result-quality feedback. */
+export const FEEDBACK_SUBTYPE = {
+  THUMBS_UP: 'thumbs_up',
+  THUMBS_DOWN: 'thumbs_down',
+} as const;
+
+/** How the searched image region was selected. */
+export const REGION_SUBTYPE = {
+  CROP: 'crop',
+  OBJECT_DETECTION_CLICK: 'object_detection_click',
+} as const;
+
+export type FeedbackEventType =
+  (typeof FEEDBACK_EVENT)[keyof typeof FEEDBACK_EVENT];
+export type ClickSubtype = (typeof CLICK_SUBTYPE)[keyof typeof CLICK_SUBTYPE];
+export type ConversionSubtype =
+  (typeof CONVERSION_SUBTYPE)[keyof typeof CONVERSION_SUBTYPE];
+export type FeedbackSubtype =
+  (typeof FEEDBACK_SUBTYPE)[keyof typeof FEEDBACK_SUBTYPE];
+export type RegionSubtype =
+  (typeof REGION_SUBTYPE)[keyof typeof REGION_SUBTYPE];
+
+/** Normalizes a subtype the same way the API does at ingestion. */
+export const normalizeSubtype = (subtype?: string): string | undefined => {
+  const normalized = subtype?.trim().toLowerCase();
+  return normalized ? normalized : undefined;
+};

package/src/services/filter.ts

@@ -1,4 +1,5 @@
 import NyrisAPI, { NyrisAPISettings } from '@nyris/nyris-api';
+import { getNyrisSettings } from 'utils/nyrisApiKey';
 
 export interface Filter {
   key?: string;
@@ -9,7 +10,7 @@ export const getFilters = async (
   number: number = 10,
   settings: NyrisAPISettings,
 ) => {
-  const nyrisApi = new NyrisAPI(settings);
+  const nyrisApi = new NyrisAPI(getNyrisSettings(settings));
   return nyrisApi.getFilters(number);
 };
 
@@ -18,7 +19,7 @@ export const searchFilters = async (
   value: string,
   settingsNyris: NyrisAPISettings,
 ) => {
-  const nyrisApi = new NyrisAPI(settingsNyris);
+  const nyrisApi = new NyrisAPI(getNyrisSettings(settingsNyris));
   const newValue = value ? value : '';
   return nyrisApi.searchFilters(key, newValue);
 };
@@ -32,6 +33,6 @@ export const getScopes = async (
   scopeIds: string,
   settings: NyrisAPISettings,
 ): Promise<ScopeResponse> => {
-  const nyrisApi = new NyrisAPI(settings);
+  const nyrisApi = new NyrisAPI(getNyrisSettings(settings));
   return nyrisApi.getScopes(scopeIds);
 };

package/src/services/initialMachinePartsText.payload.test.ts

@@ -0,0 +1,61 @@
+import NyrisAPI, { NyrisAPISettings } from '@nyris/nyris-api';
+
+function entries(body: FormData) {
+  return Array.from(body.entries()).map(([key, value]) => [key, String(value)]);
+}
+
+async function capture(
+  text: string | undefined,
+  scopeIds: string[],
+) {
+  const api = new NyrisAPI({
+    apiKey: 'test-key',
+    baseUrl: 'https://api.nyris.io',
+    jpegQuality: 0.9,
+    maxWidth: 1024,
+    maxHeight: 1024,
+    xOptions: false,
+  } as NyrisAPISettings);
+  const request = jest.fn().mockResolvedValue({ data: { results: [] } });
+  (api as unknown as { httpClient: { request: jest.Mock } }).httpClient = {
+    request,
+  };
+  await api.find(
+    text !== undefined ? { text } : {},
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    scopeIds,
+  );
+  return request.mock.calls[0][0] as {
+    url: string;
+    data: FormData | null;
+  };
+}
+
+describe('initial machine find payload', () => {
+  it('sends the caller-provided item-key batch and scope id', async () => {
+    const itemKeys = Array.from(
+      { length: 15 },
+      (_, index) => `ITEM-${index + 1}`,
+    );
+    const text = itemKeys.slice(10).join(', ');
+    const config = await capture(text, ['TestScope2']);
+
+    expect(config.url).toBe('https://api.nyris.io/find/v1.1');
+    expect(entries(config.data as FormData)).toEqual([
+      ['text', text],
+      ['scope[0]', 'TestScope2'],
+    ]);
+  });
+
+  it('sends a keyword without item keys when a machine scope is active', async () => {
+    const config = await capture('pump', ['TestScope2']);
+
+    expect(entries(config.data as FormData)).toEqual([
+      ['text', 'pump'],
+      ['scope[0]', 'TestScope2'],
+    ]);
+  });
+});

package/src/services/initialMachinePartsText.test.ts

@@ -0,0 +1,33 @@
+import { initialMachinePartsText } from './initialMachinePartsText';
+
+function keys(count: number) {
+  return Array.from({ length: count }, (_, index) => `ITEM-${index + 1}`);
+}
+
+describe('initialMachinePartsText', () => {
+  it('joins fewer than 20 item keys in order', () => {
+    const itemKeys = keys(3);
+    expect(initialMachinePartsText(itemKeys)).toBe(
+      'ITEM-1, ITEM-2, ITEM-3',
+    );
+    expect(itemKeys).toEqual(keys(3));
+  });
+
+  it('joins exactly 20 item keys', () => {
+    const text = initialMachinePartsText(keys(20));
+    expect(text?.split(', ')).toHaveLength(20);
+    expect(text?.endsWith('ITEM-20')).toBe(true);
+  });
+
+  it('stops at the first 20 item keys', () => {
+    const itemKeys = keys(21);
+    const text = initialMachinePartsText(itemKeys);
+    expect(text?.split(', ')).toHaveLength(20);
+    expect(text?.includes('ITEM-21')).toBe(false);
+    expect(itemKeys).toHaveLength(21);
+  });
+
+  it('returns undefined when there are no item keys', () => {
+    expect(initialMachinePartsText([])).toBeUndefined();
+  });
+});

package/src/services/initialMachinePartsText.ts

@@ -0,0 +1,11 @@
+import {
+  DEFAULT_MACHINE_PARTS_PAGE_SIZE,
+  machinePartsPageText,
+} from './machinePartsPage';
+
+/** First page at the default page size. The source array is not changed. */
+export function initialMachinePartsText(
+  itemKeys: readonly string[],
+): string | undefined {
+  return machinePartsPageText(itemKeys, 0, DEFAULT_MACHINE_PARTS_PAGE_SIZE);
+}

package/src/services/machinePartsPage.test.ts

@@ -0,0 +1,74 @@
+import {
+  isScopeOnlyMachinePartsListing,
+  machinePartsPageCount,
+  machinePartsPageItemKeys,
+  machinePartsPageText,
+  visibleMachinePartsPageIndexes,
+} from './machinePartsPage';
+
+function keys(count: number) {
+  return Array.from({ length: count }, (_, index) => `ITEM-${index + 1}`);
+}
+
+describe('machinePartsPage', () => {
+  it('splits 15 item keys into pages of 10 without overlap', () => {
+    const itemKeys = keys(15);
+    expect(machinePartsPageCount(itemKeys.length, 10)).toBe(2);
+    expect(machinePartsPageItemKeys(itemKeys, 0, 10)).toEqual(keys(10));
+    expect(machinePartsPageItemKeys(itemKeys, 1, 10)).toEqual(
+      keys(15).slice(10),
+    );
+    expect(machinePartsPageText(itemKeys, 1, 10)).toBe(
+      'ITEM-11, ITEM-12, ITEM-13, ITEM-14, ITEM-15',
+    );
+    expect(itemKeys).toHaveLength(15);
+  });
+
+  it('counts pages for 611 item keys from the key list, not the response', () => {
+    expect(machinePartsPageCount(611, 10)).toBe(62);
+    expect(machinePartsPageCount(611, 20)).toBe(31);
+    expect(machinePartsPageCount(611, 30)).toBe(21);
+    expect(machinePartsPageCount(611, 40)).toBe(16);
+    expect(machinePartsPageCount(611, 50)).toBe(13);
+
+    const itemKeys = keys(611);
+    const lastPage = machinePartsPageItemKeys(itemKeys, 30, 20);
+    expect(lastPage).toHaveLength(11);
+    expect(lastPage[0]).toBe('ITEM-601');
+    expect(lastPage[lastPage.length - 1]).toBe('ITEM-611');
+  });
+
+  it('keeps a full last page when the key count divides evenly', () => {
+    expect(machinePartsPageCount(10000, 50)).toBe(200);
+    expect(machinePartsPageItemKeys(keys(10000), 199, 50)).toHaveLength(50);
+  });
+
+  it('returns no text for an empty page', () => {
+    expect(machinePartsPageText(keys(15), 2, 10)).toBeUndefined();
+    expect(machinePartsPageCount(0, 20)).toBe(0);
+  });
+
+  it('shows every page when the count fits, otherwise a window', () => {
+    expect(visibleMachinePartsPageIndexes(0, 2)).toEqual([0, 1]);
+    expect(visibleMachinePartsPageIndexes(0, 62)).toHaveLength(7);
+    expect(visibleMachinePartsPageIndexes(61, 62)).toContain(61);
+  });
+
+  it('treats an active machine scope as a listing even if Algolia is on', () => {
+    const listing = {
+      scopeEnabled: true,
+      scopeId: 'TestScope2',
+      itemKeyCount: 15,
+      keyword: '',
+      hasSearchImage: false,
+      hasPostFilters: false,
+    };
+    expect(isScopeOnlyMachinePartsListing(listing)).toBe(true);
+    expect(
+      isScopeOnlyMachinePartsListing({ ...listing, keyword: 'pump' }),
+    ).toBe(false);
+    expect(
+      isScopeOnlyMachinePartsListing({ ...listing, scopeEnabled: false }),
+    ).toBe(false);
+  });
+});

package/src/services/machinePartsPage.ts

@@ -0,0 +1,120 @@
+export const DEFAULT_MACHINE_PARTS_PAGE_SIZE = 20;
+
+export function normalizeMachinePartsPageSize(pageSize: number): number {
+  if (!Number.isFinite(pageSize) || pageSize <= 0) {
+    return DEFAULT_MACHINE_PARTS_PAGE_SIZE;
+  }
+  return Math.floor(pageSize);
+}
+
+/** 0-based page index, matching the existing pagination control. */
+export function normalizeMachinePartsPageIndex(pageIndex: number): number {
+  if (!Number.isFinite(pageIndex) || pageIndex <= 0) {
+    return 0;
+  }
+  return Math.floor(pageIndex);
+}
+
+export function machinePartsPageCount(
+  itemKeyCount: number,
+  pageSize: number,
+): number {
+  if (!Number.isFinite(itemKeyCount) || itemKeyCount <= 0) {
+    return 0;
+  }
+  const size = normalizeMachinePartsPageSize(pageSize);
+  return Math.ceil(itemKeyCount / size);
+}
+
+/** Does not mutate `itemKeys`. */
+export function machinePartsPageItemKeys(
+  itemKeys: readonly string[],
+  pageIndex: number,
+  pageSize: number,
+): string[] {
+  const size = normalizeMachinePartsPageSize(pageSize);
+  const start = normalizeMachinePartsPageIndex(pageIndex) * size;
+  return itemKeys.slice(start, start + size);
+}
+
+export function machinePartsPageText(
+  itemKeys: readonly string[],
+  pageIndex: number,
+  pageSize: number,
+): string | undefined {
+  const text = machinePartsPageItemKeys(itemKeys, pageIndex, pageSize).join(
+    ', ',
+  );
+  if (text.length === 0) {
+    return undefined;
+  }
+  return text;
+}
+
+/** Page numbers shown around the current page. Indexes are 0-based. */
+export function visibleMachinePartsPageIndexes(
+  pageIndex: number,
+  pageCount: number,
+  padding = 3,
+): number[] {
+  if (pageCount <= 0) {
+    return [];
+  }
+  const current = Math.min(
+    normalizeMachinePartsPageIndex(pageIndex),
+    pageCount - 1,
+  );
+  if (pageCount <= padding * 2 + 1) {
+    return Array.from({ length: pageCount }, (_, index) => index);
+  }
+
+  let start = Math.max(0, current - padding);
+  let end = Math.min(pageCount - 1, current + padding);
+  if (current - padding < 0) {
+    end = Math.min(pageCount - 1, end + (padding - current));
+  }
+  if (current + padding > pageCount - 1) {
+    start = Math.max(0, start - (current + padding - (pageCount - 1)));
+  }
+
+  const pages: number[] = [];
+  for (let index = start; index <= end; index += 1) {
+    pages.push(index);
+  }
+  return pages;
+}
+
+export function hasActivePostFilters(
+  selections: Record<string, string[]> | undefined,
+): boolean {
+  return Object.values(selections || {}).some(
+    values => Array.isArray(values) && values.length > 0,
+  );
+}
+
+export function isScopeOnlyMachinePartsListing({
+  scopeEnabled,
+  scopeId,
+  itemKeyCount,
+  keyword,
+  hasSearchImage,
+  hasPostFilters,
+}: {
+  scopeEnabled: boolean;
+  scopeId: string | null;
+  itemKeyCount: number;
+  keyword: string;
+  hasSearchImage: boolean;
+  hasPostFilters: boolean;
+}): boolean {
+  if (!scopeEnabled) {
+    return false;
+  }
+  if (!scopeId || itemKeyCount <= 0) {
+    return false;
+  }
+  if (keyword.trim().length > 0 || hasSearchImage || hasPostFilters) {
+    return false;
+  }
+  return true;
+}

package/src/services/normalizeChatResponse.ts

@@ -0,0 +1,26 @@
+/**
+ * The chat API sometimes returns the JSON payload as a string, optionally
+ * wrapped in a markdown code fence (```json ... ```). Parse such strings into
+ * objects; leave plain-text responses (e.g. request_quality) untouched.
+ *
+ * A JSON object embedded in surrounding text is left as text. Callers must not
+ * treat that leftover text as structured data.
+ */
+export function normalizeChatResponse(data: unknown): unknown {
+  if (typeof data !== 'string') {
+    return data;
+  }
+
+  const fenced = data.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  const candidate = (fenced ? fenced[1] : data).trim();
+
+  if (!candidate.startsWith('{') && !candidate.startsWith('[')) {
+    return data;
+  }
+
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    return data;
+  }
+}

package/src/services/scopeLookup.test.ts

@@ -0,0 +1,67 @@
+import { getScopes } from 'services/filter';
+import { lookupScopeById } from './scopeLookup';
+
+jest.mock('services/filter', () => ({
+  getScopes: jest.fn(),
+}));
+
+jest.mock('utils/nyrisApiKey', () => ({
+  isNyrisApiKeyReady: () => true,
+}));
+
+const getScopesMock = getScopes as jest.MockedFunction<typeof getScopes>;
+
+describe('lookupScopeById', () => {
+  beforeEach(() => {
+    getScopesMock.mockReset();
+    window.settings = {
+      scopes: { scopeID: true },
+      apiKey: 'test-key',
+    } as typeof window.settings;
+  });
+
+  it('sends the serial number unchanged', async () => {
+    getScopesMock.mockResolvedValue({
+      itemKeys: ['sku-1'],
+      filterAttributes: [],
+    });
+
+    const result = await lookupScopeById('Ab-12/c 9');
+
+    expect(getScopesMock).toHaveBeenCalledWith(
+      'Ab-12/c 9',
+      window.settings,
+    );
+    expect(result).toEqual({
+      status: 'found',
+      itemKeys: ['sku-1'],
+      filterAttributes: [],
+    });
+  });
+
+  it('does not call the scopes API for a blank id', async () => {
+    const result = await lookupScopeById('   ');
+
+    expect(getScopesMock).not.toHaveBeenCalled();
+    expect(result).toEqual({ status: 'not_found' });
+  });
+
+  it('returns empty when the machine has no item keys', async () => {
+    getScopesMock.mockResolvedValue({
+      itemKeys: [],
+      filterAttributes: [],
+    });
+
+    await expect(lookupScopeById('2234GH')).resolves.toEqual({
+      status: 'empty',
+    });
+  });
+
+  it('returns not found when the scopes request fails', async () => {
+    getScopesMock.mockRejectedValue(new Error('unavailable'));
+
+    await expect(lookupScopeById('2234GH')).resolves.toEqual({
+      status: 'not_found',
+    });
+  });
+});

package/src/services/scopeLookup.ts

@@ -0,0 +1,39 @@
+import { getScopes } from 'services/filter';
+import { isNyrisApiKeyReady } from 'utils/nyrisApiKey';
+import { TypePlateLookupResult } from 'components/ScopeSelect/identifyTypePlateImage';
+
+/**
+ * GET /v1/scopes?scopeIds=... using the existing client encoding.
+ * Does not write the scope store. Callers apply a machine only after confirm.
+ * The id is sent unchanged; trimming only rejects a blank value.
+ */
+export async function lookupScopeById(
+  scopeId: string,
+): Promise<TypePlateLookupResult> {
+  const settings = window.settings;
+  if (!settings.scopes?.scopeID) {
+    return { status: 'unavailable' };
+  }
+
+  if (!isNyrisApiKeyReady()) {
+    return { status: 'unavailable' };
+  }
+
+  if (scopeId.trim().length === 0 || scopeId.trim() === 'NOT_FOUND') {
+    return { status: 'not_found' };
+  }
+
+  try {
+    const scopesResponse = await getScopes(scopeId, settings);
+    const itemKeys = (scopesResponse.itemKeys || []).filter(Boolean);
+    const filterAttributes = scopesResponse.filterAttributes || [];
+
+    if (itemKeys.length === 0) {
+      return { status: 'empty' };
+    }
+
+    return { status: 'found', itemKeys, filterAttributes };
+  } catch {
+    return { status: 'not_found' };
+  }
+}

package/src/services/visualSearch.listingOptions.test.ts

@@ -0,0 +1,79 @@
+import { machinePartsPageText } from './machinePartsPage';
+import { machinePartsListingXOptions } from './visualSearch';
+
+const X_OPTIONS = 'hybrid_search.text.reranking=false';
+
+function keys(count: number) {
+  return Array.from({ length: count }, (_, index) => `ITEM-${index + 1}`);
+}
+
+const listing = {
+  hasSearchImage: false,
+  hasFilters: false,
+  scopeId: 'TestScope2',
+  itemKeys: keys(15),
+  keyword: '',
+  pageSize: 10,
+};
+
+describe('machinePartsListingXOptions', () => {
+  it('sends the override for each scope-only item key page', () => {
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 0,
+        text: machinePartsPageText(listing.itemKeys, 0, 10),
+      }),
+    ).toBe(X_OPTIONS);
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 1,
+        text: machinePartsPageText(listing.itemKeys, 1, 10),
+      }),
+    ).toBe(X_OPTIONS);
+  });
+
+  it('omits the override for a keyword, image, filters, or another page', () => {
+    const firstPage = machinePartsPageText(listing.itemKeys, 0, 10);
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 1,
+        text: firstPage,
+      }),
+    ).toBeUndefined();
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 0,
+        text: 'pump',
+        keyword: 'pump',
+      }),
+    ).toBeUndefined();
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 0,
+        text: firstPage,
+        hasSearchImage: true,
+      }),
+    ).toBeUndefined();
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 0,
+        text: firstPage,
+        hasFilters: true,
+      }),
+    ).toBeUndefined();
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 0,
+        text: firstPage,
+        scopeId: null,
+      }),
+    ).toBeUndefined();
+  });
+});