@nyris/nyris-webapp 0.3.98 → 0.3.99

package/src/services/Feedback.ts

@@ -1,74 +1,262 @@
 import NyrisAPI, {
+  ConversionRevenue,
   FeedbackEventPayload,
   NyrisAPISettings,
   RectCoords,
 } from '@nyris/nyris-api';
 import { getNyrisSettings } from 'utils/nyrisApiKey';
+import useResultStore from 'stores/result/resultStore';
+import { CONVERSION_SUBTYPE, normalizeSubtype } from './feedbackSubtypes';
 
-export const feedbackSuccessEpic = async (
-  requestId: string,
-  success: boolean,
+export interface FeedbackIds {
+  requestId?: string;
+  sessionId?: string;
+}
+
+interface ProductRef {
+  sku?: string;
+  position?: number;
+}
+
+interface ProductRefs {
+  skus?: (string | undefined)[];
+  positions?: (number | undefined)[];
+}
+
+type ConversionDetails = ProductRefs & {
+  quantity?: number;
+  revenue?: ConversionRevenue;
+};
+
+const compactStrings = (values?: (string | undefined)[]) =>
+  values?.filter((value): value is string => !!value) ?? [];
+
+const compactNumbers = (values?: (number | undefined)[]) =>
+  values?.filter(
+    (value): value is number => typeof value === 'number' && value >= 0,
+  ) ?? [];
+
+/**
+ * Builds the `product_ids` / `positions` part of a click or conversion payload,
+ * dropping empty arrays so the payload matches the API examples.
+ */
+const productData = ({ skus, positions }: ProductRefs) => {
+  const product_ids = compactStrings(skus);
+  const cleanPositions = compactNumbers(positions);
+  return {
+    ...(product_ids.length ? { product_ids } : {}),
+    ...(cleanPositions.length ? { positions: cleanPositions } : {}),
+  };
+};
+
+const resolveIds = (ids?: FeedbackIds): FeedbackIds => {
+  if (ids && (ids.requestId || ids.sessionId)) {
+    return ids;
+  }
+  const { requestId, sessionId } = useResultStore.getState();
+  return { requestId, sessionId };
+};
+
+/**
+ * An event is suppressed when its event type OR its subtype appears in
+ * `window.settings.disabledFeedbackEvents` (case-insensitive).
+ */
+export const isFeedbackEventEnabled = (event: string, subtype?: string) => {
+  const disabled = (window.settings?.disabledFeedbackEvents || [])
+    .filter((entry): entry is string => typeof entry === 'string')
+    .map(entry => entry.trim().toLowerCase())
+    .filter(Boolean);
+
+  if (disabled.length === 0) return true;
+  if (disabled.includes(event.trim().toLowerCase())) return false;
+
+  const normalized = normalizeSubtype(subtype);
+  return !(normalized && disabled.includes(normalized));
+};
+
+/**
+ * Central dispatcher: resolves request/session ids from the result store when
+ * not provided, applies the disabled-events setting, normalizes the subtype,
+ * and sends the event.
+ */
+export const trackFeedbackEvent = async (
+  payload: FeedbackEventPayload,
+  ids?: FeedbackIds,
 ) => {
-  const settings = window.settings;
+  const data = payload.data as { subtype?: string } | undefined;
+  const subtype = normalizeSubtype(data?.subtype);
 
-  return await sendFeedbackByApi(settings, undefined, requestId, {
-    event: 'feedback',
-    data: { success },
-  });
+  if (!isFeedbackEventEnabled(payload.event, subtype)) return;
+
+  const normalizedPayload = (
+    data
+      ? {
+          ...payload,
+          data: subtype ? { ...data, subtype } : omitSubtype(data),
+        }
+      : payload
+  ) as FeedbackEventPayload;
+
+  const { requestId, sessionId } = resolveIds(ids);
+  return sendFeedbackByApi(
+    window.settings,
+    sessionId,
+    requestId,
+    normalizedPayload,
+  );
 };
 
+const omitSubtype = <T extends { subtype?: string }>(data: T) => {
+  const { subtype: _ignored, ...rest } = data;
+  return rest;
+};
+
+/** `click` event for a single result or a product-less interaction. */
+export const trackClick = (
+  subtype: string,
+  product?: ProductRef,
+  ids?: FeedbackIds,
+) =>
+  trackFeedbackEvent(
+    {
+      event: 'click',
+      data: {
+        subtype,
+        ...productData({
+          skus: [product?.sku],
+          positions: [product?.position],
+        }),
+      },
+    },
+    ids,
+  );
+
+/** `conversion` event. Pass `undefined` as subtype for a legacy conversion. */
+export const trackConversion = (
+  subtype: string | undefined,
+  details: ConversionDetails = {},
+  ids?: FeedbackIds,
+) => {
+  const { quantity, revenue, ...refs } = details;
+  return trackFeedbackEvent(
+    {
+      event: 'conversion',
+      data: {
+        ...(subtype ? { subtype } : {}),
+        ...productData(refs),
+        ...(typeof quantity === 'number' ? { quantity } : {}),
+        ...(revenue ? { revenue } : {}),
+      },
+    },
+    ids,
+  );
+};
+
+/**
+ * `conversion` / `purchase`. There is no checkout flow in the search suite
+ * today, so this is provided for host integrations and future use.
+ */
+export const trackPurchase = (details: ConversionDetails, ids?: FeedbackIds) =>
+  trackConversion(CONVERSION_SUBTYPE.PURCHASE, details, ids);
+
+/** `feedback` event from the "Did we find what you were looking for?" prompt. */
+export const trackResultFeedback = (
+  success: boolean,
+  comment?: string,
+  ids?: FeedbackIds,
+) =>
+  trackFeedbackEvent(
+    {
+      event: 'feedback',
+      data: {
+        success,
+        ...(comment ? { comment } : {}),
+      },
+    },
+    ids,
+  );
+
+/** `region` event; converts x1/y1/x2/y2 to the API's x/y/w/h rectangle. */
+export const trackRegion = (
+  region: RectCoords,
+  subtype: string,
+  ids?: FeedbackIds,
+) => {
+  const { x1, x2, y1, y2 } = region;
+  return trackFeedbackEvent(
+    {
+      event: 'region',
+      data: { subtype, rect: { x: x1, y: y1, w: x2 - x1, h: y2 - y1 } },
+    },
+    ids,
+  );
+};
+
+// ---------------------------------------------------------------------------
+// Legacy wrappers kept for backwards compatibility.
+// ---------------------------------------------------------------------------
+
+export const feedbackSuccessEpic = async (
+  requestId: string,
+  success: boolean,
+) => trackResultFeedback(success, undefined, { requestId });
+
 export const feedbackClickEpic = async (
   requestId: string,
   sessionId: string,
   position: number,
   id?: string,
-) => {
-  const settings = window.settings;
-  return await sendFeedbackByApi(settings, sessionId, requestId, {
-    event: 'click',
-    data: { positions: [position], ...(id ? { product_ids: [id] } : {}) },
-  });
-};
+) =>
+  trackFeedbackEvent(
+    {
+      event: 'click',
+      data: { positions: [position], ...(id ? { product_ids: [id] } : {}) },
+    },
+    { requestId, sessionId },
+  );
 
 export const feedbackConversionEpic = async (
   requestId: string,
   sessionId: string,
   position: number,
   id?: string,
-) => {
-  const settings = window.settings;
-  return await sendFeedbackByApi(settings, sessionId, requestId, {
-    event: 'conversion',
-    data: { positions: [position], ...(id ? { product_ids: [id] } : {}) },
-  });
-};
+) =>
+  trackConversion(
+    undefined,
+    { skus: [id], positions: [position] },
+    {
+      requestId,
+      sessionId,
+    },
+  );
 
 export const feedbackRegionEpic = async (
   requestId: string,
   sessionId: string,
   region: RectCoords,
 ) => {
-  const settings = window.settings;
   const { x1, x2, y1, y2 } = region;
-  const payload: FeedbackEventPayload = {
-    event: 'region',
-    data: { rect: { x: x1, y: y1, w: x2 - x1, h: y2 - y1 } },
-  };
-  return await sendFeedbackByApi(settings, sessionId, requestId, payload);
+  return trackFeedbackEvent(
+    {
+      event: 'region',
+      data: { rect: { x: x1, y: y1, w: x2 - x1, h: y2 - y1 } },
+    },
+    { requestId, sessionId },
+  );
 };
 
+/** Transport. Silently skips when there is no request id to attach to. */
 export const sendFeedbackByApi = async (
   settings: NyrisAPISettings,
   sessionId: string | undefined,
   requestId: string | undefined,
   payload: FeedbackEventPayload,
 ) => {
-  const api = new NyrisAPI(getNyrisSettings(settings));
-  if (requestId) {
-    try {
-      await api.sendFeedback({ sessionId, requestId, payload }).then(() => {});
-    } catch (error) {
-      console.log('error sendFeedbackByApi', error);
-    }
+  if (!requestId || !window.settings.showFeedback) return;
+  try {
+    const api = new NyrisAPI(getNyrisSettings(settings));
+    await api.sendFeedback({ sessionId, requestId, payload });
+  } catch (error) {
+    console.log('error sendFeedbackByApi', error);
   }
 };

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

@@ -33,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;
+  }
+}