@envive-ai/react-hooks 0.1.5 → 0.1.6

package/src/application/service/pageVariantService.ts

@@ -1,866 +0,0 @@
-import { v4 as uuid } from "uuid";
-import { createVisitUserEvent } from "src/hooks/utils";
-import CommerceApiClient from "src/adapters/spiffy/commerce/api";
-import Logger from "src/application/logging/logger";
-import { getAtomStore } from "src/atoms/atomStore/atomStore";
-import { featureFlagServiceAtom } from "src/atoms/org/org";
-import {
-  CategoryExtractor,
-  CategoryExtractorType,
-  IdExtractor,
-  OrgPageConfig,
-  PageVariantConfig,
-  PageVariantTest,
-  PageVariantTestType,
-} from "src/contexts/types";
-import { ShopifyUrlService } from "src/application/service/shopifyUrlService";
-import {
-  Message,
-  MessageRole,
-  MessageType,
-  VariantInfo,
-} from "src/application/models";
-import { FeatureGates } from "src/application/models/featureGates";
-import { appDetailsAtom } from "src/atoms/app";
-
-import {
-  PageVisitCategory,
-  type SupportedEventProductCategory,
-} from "@spiffy-ai/commerce-api-client";
-import {
-  SupportedEvent,
-  urlResolverAtom,
-  UrlResolverResponse,
-  UrlResolvingPDPConfig,
-  UrlResolvingPLPConfig,
-} from "src/atoms/app/variant";
-import { chatAtom, lastAssistantMessageAtom } from "src/atoms/chat";
-import { StringUtils } from "../utils/stringUtils";
-
-/**
- * This class is used to resolve the PageVariants for the Spiffy App.
- * It includes a number of static utility functions for performing pageTests and
- * extracting data necessary to build the PageVariants.
- *
- * Under most circumstances only `getVariantInfoWithPageConfig` will be called externally
- * The other functions should be used internally by that function.
- */
-class PageVariantService {
-  public static readonly pageTest = async (
-    test: PageVariantTest,
-    pageVariantConfig: PageVariantConfig,
-    atomValues?: {
-      responseStreaming: boolean;
-      messages: Message[][];
-      lastAssistantMessage?: Message[] | null | undefined;
-    }
-  ): Promise<boolean> => {
-    switch (test.testType) {
-      case PageVariantTestType.UrlResolver: {
-        const url = window._spiffy.variantUrlOverride ?? window.location.href;
-        const response = await PageVariantService.getCachedUrlResolver(url);
-        return (
-          response.ready &&
-          response.variant_type === pageVariantConfig.variantType
-        );
-      }
-      case PageVariantTestType.ShopifyPDP:
-        return ShopifyUrlService.isOnPdpPage();
-      case PageVariantTestType.ShopifyPLP:
-        return ShopifyUrlService.isOnPlpPage();
-      case PageVariantTestType.PageCategory:
-        return !!PageVariantService.getCategory(test.extractor);
-      case PageVariantTestType.FeatureGate:
-        return PageVariantService.checkFeatureGate(test.featureGate);
-      case PageVariantTestType.PlpId:
-        return PageVariantService.checkPlpIds({
-          plpIds: test.plpIds,
-          plpIdExtractor: test.plpIdExtractor,
-        });
-      case PageVariantTestType.QueryParam:
-        return PageVariantService.checkQueryParam({
-          queryParam: test.queryParam,
-        });
-      case PageVariantTestType.ProductId:
-        return PageVariantService.checkProductId({
-          productIds: test.productIds,
-          productIdExtractor: test.productIdExtractor,
-        });
-      case PageVariantTestType.Fallback:
-        // The 'fallback' testType will always evaluate to true
-        return true;
-      case PageVariantTestType.CatalogCategory:
-        return PageVariantService.checkCatalogCategory(
-          test.category,
-          pageVariantConfig
-        );
-      case PageVariantTestType.TopCatalogCategory:
-        return PageVariantService.checkInTopCategory(
-          test.topCategory,
-          pageVariantConfig
-        );
-      case PageVariantTestType.HasReviews:
-        return PageVariantService.checkHasReviews(
-          pageVariantConfig,
-          test.reviewMinimum
-        );
-      case PageVariantTestType.InCollection:
-        return PageVariantService.checkInCollection(
-          test.collections,
-          pageVariantConfig
-        );
-      case PageVariantTestType.HasMerchantTag:
-        return PageVariantService.checkHasMerchantTag(
-          test.merchantTags,
-          pageVariantConfig
-        );
-      case PageVariantTestType.UserHasInteracted:
-        return PageVariantService.userHasInteracted(atomValues?.messages);
-      case PageVariantTestType.UserHasNotInteracted:
-        return PageVariantService.userHasNotInteracted(atomValues?.messages);
-      case PageVariantTestType.isLoading:
-        return PageVariantService.isLoading(
-          atomValues?.messages,
-          atomValues?.responseStreaming
-        );
-      case PageVariantTestType.isProductComparison:
-        return PageVariantService.isProductComparison(
-          atomValues?.lastAssistantMessage
-        );
-      default:
-        // If there is a testType that we do not cover - default to false
-        Logger.logInfo(`[Spiffy] pageTest - ${test} not supported`);
-        return false;
-    }
-  };
-
-  private static readonly getCachedUrlResolver = async (url: string) => {
-    // Check atom cache first (like OrgConfig does)
-    const atomStore = getAtomStore();
-    const cache = atomStore.get(urlResolverAtom);
-    const cachedUrlResolver = cache?.[url];
-
-    if (cachedUrlResolver) {
-      return cachedUrlResolver;
-    }
-
-    const response = (await CommerceApiClient.resolveUrl(
-      url
-    )) as UrlResolverResponse;
-
-    // Store in atom cache for this URL (will be persisted to sessionStorage automatically)
-    atomStore.set(urlResolverAtom, { url, response });
-
-    return response;
-  };
-
-  /**
-   * Checks if the current page matches the expected catalog category.
-   *
-   * @param category - The expected catalog category as defined by data in Elastic Search.
-   * @param pageVariantConfig - The variant config for the current page.
-   *
-   * @returns True if the current page matches the expected catalog category.
-   */
-  private static readonly checkCatalogCategory = async (
-    category: SupportedEventProductCategory | string,
-    pageVariantConfig: PageVariantConfig
-  ): Promise<boolean> => {
-    const supportedEventResponse = await PageVariantService.checkSupportedEvent(
-      pageVariantConfig
-    );
-    if (supportedEventResponse && supportedEventResponse.category) {
-      return supportedEventResponse?.category === category;
-    }
-
-    return false;
-  };
-
-  private static readonly checkInTopCategory = async (
-    topCategory: string[],
-    pageVariantConfig: PageVariantConfig
-  ): Promise<boolean> => {
-    const supportedEventResponse = await PageVariantService.checkSupportedEvent(
-      pageVariantConfig
-    );
-    if (supportedEventResponse && supportedEventResponse?.top_category) {
-      return topCategory.includes(supportedEventResponse?.top_category);
-    }
-
-    return false;
-  };
-
-  private static readonly checkHasReviews = async (
-    pageVariantConfig: PageVariantConfig,
-    reviewMinimum: number = 0
-  ): Promise<boolean> => {
-    const supportedEventResponse = await PageVariantService.checkSupportedEvent(
-      pageVariantConfig
-    );
-    if (supportedEventResponse?.numberOfReviews) {
-      return supportedEventResponse.numberOfReviews >= reviewMinimum;
-    }
-    return false;
-  };
-
-  private static readonly checkInCollection = async (
-    collections: string[],
-    pageVariantConfig: PageVariantConfig
-  ): Promise<boolean> => {
-    const supportedEventResponse = await PageVariantService.checkSupportedEvent(
-      pageVariantConfig
-    );
-    if (supportedEventResponse?.collections) {
-      return supportedEventResponse.collections.some((collection) =>
-        collections.includes(collection)
-      );
-    }
-    return false;
-  };
-
-  private static readonly checkHasMerchantTag = async (
-    merchantTags: string[],
-    pageVariantConfig: PageVariantConfig
-  ): Promise<boolean> => {
-    const supportedEventResponse = await PageVariantService.checkSupportedEvent(
-      pageVariantConfig
-    );
-
-    if (supportedEventResponse?.merchant_tags) {
-      return supportedEventResponse.merchant_tags.some((tag) =>
-        merchantTags.includes(tag)
-      );
-    }
-
-    return false;
-  };
-
-  private static readonly userHasInteracted = (msgs?: Message[][]): boolean => {
-    if (msgs) {
-      return msgs.some((m) => m.some((msg) => msg.role === MessageRole.User));
-    }
-
-    const atomStore = getAtomStore();
-    const { messages } = atomStore.get(chatAtom);
-    return messages.some((m) => m.some((msg) => msg.role === MessageRole.User));
-  };
-
-  private static readonly userHasNotInteracted = (
-    msgs?: Message[][]
-  ): boolean => {
-    if (msgs) {
-      return !msgs.some((m) => m.some((msg) => msg.role === MessageRole.User));
-    }
-
-    const atomStore = getAtomStore();
-    const chat = atomStore.get(chatAtom);
-    return !chat.messages.some((m) =>
-      m.some((msg) => msg.role === MessageRole.User)
-    );
-  };
-
-  private static readonly isLoading = (
-    msgs?: Message[][],
-    responseStream?: boolean
-  ): boolean => {
-    if (msgs) {
-      return responseStream || (!responseStream && msgs.length === 0);
-    }
-
-    const atomStore = getAtomStore();
-    const { responseStreaming, messages } = atomStore.get(chatAtom);
-    return responseStreaming || (!responseStreaming && messages.length === 0);
-  };
-
-  private static readonly isProductComparison = (
-    lastMsg: Message[] | null | undefined
-  ): boolean => {
-    if (lastMsg) {
-      return (
-        lastMsg?.filter((msg) => msg.type === MessageType.Product).length === 2
-      );
-    }
-
-    const atomStore = getAtomStore();
-    const lastAssistantMessage = atomStore.get(lastAssistantMessageAtom);
-    return (
-      lastAssistantMessage?.filter((msg) => msg.type === MessageType.Product)
-        .length === 2
-    );
-  };
-
-  private static readonly checkPlpIds = async ({
-    plpIds,
-    plpIdExtractor,
-  }: {
-    plpIds: string[];
-    plpIdExtractor: IdExtractor;
-  }): Promise<boolean> => {
-    let currentPlpId: string | null;
-    if (plpIdExtractor === "url-resolver-plp-id") {
-      currentPlpId = await PageVariantService.getIdFromUrlResolver("plpId");
-    } else {
-      currentPlpId = await PageVariantService.getId(plpIdExtractor);
-    }
-    const result = plpIds.includes(currentPlpId ?? "");
-    return result;
-  };
-
-  private static readonly checkQueryParam = async ({
-    queryParam,
-  }: {
-    queryParam: string;
-  }): Promise<boolean> => {
-    const params = new URLSearchParams(window.location.search);
-    return params.has(queryParam);
-  };
-
-  private static readonly checkProductId = async ({
-    productIds,
-    productIdExtractor,
-  }: {
-    productIds: string[];
-    productIdExtractor: IdExtractor;
-  }): Promise<boolean> => {
-    let currentProductId: string | null;
-    if (productIdExtractor === "url-resolver-product-id") {
-      currentProductId = await PageVariantService.getIdFromUrlResolver(
-        "productId"
-      );
-    } else {
-      currentProductId = await PageVariantService.getId(productIdExtractor);
-    }
-    const result = productIds.includes(currentProductId ?? "");
-    return result;
-  };
-
-  static checkFeatureGate(featureGate: FeatureGates): boolean {
-    const atomStore = getAtomStore();
-    const featureFlagService = atomStore.get(featureFlagServiceAtom);
-
-    return featureFlagService?.isFeatureGateEnabled(featureGate) || false;
-  }
-
-  static getCategory(extractor: CategoryExtractor): PageVisitCategory | null {
-    if (extractor.type === CategoryExtractorType.VisitCategoryDefault) {
-      return extractor.value;
-    }
-
-    if (extractor.type === CategoryExtractorType.VisitCategoryMap) {
-      const urlMap = Object.entries(extractor.map);
-
-      const matched = urlMap.find(([, urls]) => {
-        const hostMatched = StringUtils.findMatchingPattern(
-          urls,
-          window.location
-        );
-        if (hostMatched) {
-          return hostMatched;
-        }
-
-        return urls.find((url) => window.location.pathname.includes(url));
-      });
-
-      if (matched) {
-        return matched[0] as PageVisitCategory;
-      }
-
-      return null;
-    }
-
-    Logger.logError(
-      `[spiffy-ai] PageVariantService.getCategory error - extractor=${extractor} not supported`,
-      undefined
-    );
-    return null;
-  }
-
-  static async getId(extractor?: IdExtractor): Promise<string | null> {
-    if (!extractor || extractor === "null") {
-      Logger.logDebug(
-        `[spiffy-ai] PageVariantService.getId - extractor=${extractor} is null or not supported`
-      );
-      return null;
-    }
-
-    // Handle URL resolver extractors
-    if (extractor === "url-resolver-product-id") {
-      return PageVariantService.getIdFromUrlResolver("productId");
-    }
-
-    if (extractor === "url-resolver-plp-id") {
-      return PageVariantService.getIdFromUrlResolver("plpId");
-    }
-
-    // Handle regular extractors
-    return ShopifyUrlService.getPlpOrPdpId(extractor);
-  }
-
-  private static readonly getIdFromUrlResolver = async (
-    field: "productId" | "plpId"
-  ) => {
-    const url = window._spiffy.variantUrlOverride ?? window.location.href;
-    const response = await this.getCachedUrlResolver(url);
-    // PDP
-    if (field === "productId" && response.variant_type === "pdp") {
-      let productId: string | undefined;
-      if (
-        response.user_event?.attributes &&
-        "product_id" in response.user_event.attributes
-      ) {
-        productId = response.user_event.attributes.product_id;
-      }
-      return productId ?? null;
-    }
-
-    // PLP
-    if (field === "plpId" && response.variant_type === "plp") {
-      let plpId: string | undefined;
-      if (
-        response.user_event?.category === "plp_visit" &&
-        response.user_event.attributes &&
-        "attributes" in response.user_event.attributes &&
-        response.user_event.attributes.attributes &&
-        "id" in response.user_event.attributes.attributes
-      ) {
-        plpId = response.user_event.attributes.attributes.id;
-      }
-      return plpId ?? null;
-    }
-    return null;
-  };
-
-  // /**
-  //  * Transforms backend page_variant to frontend PageVariantConfig: check -> test
-  //  *
-  //  * @param backendPageVariant - Backend page variant with variant_checks
-  //  * @returns Frontend PageVariantConfig with variantTests
-  //  */
-  // private static readonly transformBackendPageVariantToFrontend = (
-  //   backendPageVariant: BackendPageVariantConfig,
-  // ): PageVariantConfig => {
-  //   const convertChecktoTest = (checks: PageVariantCheckConfig[]): PageVariantTest[] => checks.map((check: PageVariantCheckConfig): PageVariantTest => {
-  //     switch (check.check_type) {
-  //       case 'ShopifyPDP':
-  //         return {
-  //           testType: PageVariantTestType.ShopifyPDP,
-  //         };
-  //       case 'ShopifyPLP':
-  //         return {
-  //           testType: PageVariantTestType.ShopifyPLP,
-  //         };
-  //       case 'FeatureGate':
-  //         return {
-  //           testType: PageVariantTestType.FeatureGate,
-  //           featureGate: check.feature_gate as FeatureGates,
-  //         };
-  //       case 'ProductId':
-  //         return {
-  //           testType: PageVariantTestType.ProductId,
-  //           productIdExtractor: check.product_id_extractor as IdExtractor,
-  //           productIds: check.product_ids as string[],
-  //         };
-  //       case 'PlpId':
-  //         return {
-  //           testType: PageVariantTestType.PlpId,
-  //           plpIdExtractor: check.plp_id_extractor as IdExtractor,
-  //           plpIds: check.plp_ids as string[],
-  //         };
-  //       case 'InCollection':
-  //         return {
-  //           testType: PageVariantTestType.InCollection,
-  //           collections: check.collections as string[],
-  //         };
-  //       case 'QueryParam':
-  //         return {
-  //           testType: PageVariantTestType.QueryParam,
-  //           queryParam: check.query_param as string,
-  //         };
-  //       case 'PageCategory':
-  //         return {
-  //           testType: PageVariantTestType.PageCategory,
-  //           extractor: check.extractor as CategoryExtractor,
-  //         };
-  //       case 'CatalogCategory':
-  //         return {
-  //           testType: PageVariantTestType.CatalogCategory,
-  //           category: check.category as SupportedEventProductCategory,
-  //         };
-  //       case 'TopCatalogCategory':
-  //         return {
-  //           testType: PageVariantTestType.TopCatalogCategory,
-  //           topCategory: check.top_category as SupportedEventProductCategory[],
-  //         };
-  //       case 'HasReviews':
-  //         return {
-  //           testType: PageVariantTestType.HasReviews,
-  //           reviewMinimum: check?.review_minimum,
-  //         };
-  //       case 'UrlResolver':
-  //         return {
-  //           testType: PageVariantTestType.UrlResolver,
-  //         };
-  //       case 'Fallback':
-  //         return {
-  //           testType: PageVariantTestType.Fallback,
-  //         };
-  //       case 'HasMerchantTag':
-  //         return {
-  //           testType: PageVariantTestType.HasMerchantTag,
-  //           merchantTags: check.merchant_tags as string[],
-  //         };
-  //       default:
-  //         throw new Error(`Unsupported check_type: ${check.check_type}`);
-  //     }
-  //   });
-  //   const variantTests: PageVariantTest[] = convertChecktoTest(
-  //     backendPageVariant.variant_checks || [],
-  //   );
-
-  //   const widgetMounting: WidgetMounting[] = backendPageVariant.widget_mounting.map(
-  //     (widgetMountingConfig: BackendWidgetMountingConfig) => {
-  //       if (widgetMountingConfig.mounting_point_widgets?.length) {
-  //         return {
-  //           mountingConfigId: widgetMountingConfig.mounting_config_id,
-  //           mountingPointWidgets: widgetMountingConfig.mounting_point_widgets.map(
-  //             (mountingPointWidget) => ({
-  //               tests: convertChecktoTest(mountingPointWidget.checks),
-  //               widgetConfigId: mountingPointWidget.widget_config_id,
-  //             }),
-  //           ),
-  //         } as DynamicWidgetMounting;
-  //       }
-  //       return {
-  //         mountingConfigId: widgetMountingConfig.mounting_config_id,
-  //         widgetConfigId: widgetMountingConfig.widget_config_id,
-  //       } as StaticWidgetMounting;
-  //     },
-  //   );
-
-  //   return {
-  //     variantId: backendPageVariant.variant_id,
-  //     variantType: backendPageVariant.variant_type,
-  //     variantTests,
-  //     widgetMounting,
-  //     ...(backendPageVariant.variant_type === 'pdp' && {
-  //       productIdExtractor: backendPageVariant.product_id_extractor as IdExtractor,
-  //       ...(backendPageVariant.parent_product_id_extractor && {
-  //         parentProductIdExtractor: backendPageVariant.parent_product_id_extractor as IdExtractor,
-  //       }),
-  //     }),
-  //     ...(backendPageVariant.variant_type === 'plp' && {
-  //       plpIdExtractor: backendPageVariant.plp_id_extractor as IdExtractor,
-  //     }),
-  //   } as PageVariantConfig;
-  // };
-
-  /**
-   * Gets the variant info for the current page based on the merchant's page config.
-   *
-   * @param orgPageConfig - The merchant's page config.
-   *
-   * @returns The variant info for the current page, or undefined if the page tests do not
-   * return any matches.
-   */
-  static readonly getVariantInfoWithPageConfig = async (
-    orgPageConfig: OrgPageConfig
-  ): Promise<[VariantInfo, PageVariantConfig] | undefined> => {
-    // First check if there is a variant override set
-    if (window?._spiffy?.variantInfoOverride) {
-      Logger.logDebug(
-        "[spiffy-ai] Found variantInfoOverride",
-        window._spiffy.variantInfoOverride
-      );
-      const matchingPageVariantConfig = orgPageConfig.pageVariants.find(
-        (pageVariant) =>
-          pageVariant.variantId ===
-          window._spiffy.variantInfoOverride?.variantId
-      );
-      if (matchingPageVariantConfig) {
-        Logger.logInfo(
-          "[spiffy-ai] Returning overriden variantInfo",
-          window._spiffy.variantInfoOverride
-        );
-        return [window._spiffy.variantInfoOverride, matchingPageVariantConfig];
-      }
-      Logger.logWarn(
-        "[spiffy-ai] Found variantInfoOverride but no matching pageVariantConfig",
-        window._spiffy.variantInfoOverride
-      );
-    }
-
-    // Disable the page_variant coming from the backend as it is returning null for merchants today
-    // const atomStore = getAtomStore();
-
-    // const isGraphQLPageConfigsEnabled = PageVariantService.checkFeatureGate(
-    //   FeatureGates.IsGraphQLPageConfigsEnabled,
-    // );
-
-    // if (isGraphQLPageConfigsEnabled) {
-    //   // If GraphQL page configs are enabled, use the URL resolver to get the page variant
-    //   const url =
-    //     window._spiffy.variantUrlOverride ?? `${window.location.origin}${window.location.pathname}`;
-    //   const response = await PageVariantService.getCachedUrlResolver(url);
-
-    //   if (response?.page_variant) {
-    //     // Transform backend page_variant to frontend PageVariantConfig
-    //     const frontendPageVariant = PageVariantService.transformBackendPageVariantToFrontend(
-    //       response.page_variant,
-    //     );
-
-    //     atomStore.set(orgPageConfigAtom, [frontendPageVariant]);
-
-    //     const variantInfo = await PageVariantService.parsePageVariantConfig(
-    //       frontendPageVariant,
-    //       url,
-    //     );
-    //     if (variantInfo) {
-    //       return [variantInfo, frontendPageVariant];
-    //     }
-    //   }
-
-    //   Logger.logWarn('[spiffy-ai] no page variant fetched', undefined);
-    //   await tellExtensionAboutInjectionError(new Error('No pagevariantConfig matched'));
-
-    //   return undefined;
-    // }
-
-    // If GraphQL page configs are not enabled, use the local page config
-
-    // return the first variant that passes all of its tests
-    for await (const pageVariant of [...orgPageConfig.pageVariants]) {
-      const testResults = await Promise.all(
-        pageVariant.variantTests.map((test) =>
-          PageVariantService.pageTest(test, pageVariant)
-        )
-      );
-
-      if (testResults.every((result) => result)) {
-        // this URL eventually gets used to look up whether a product/page is supported
-        // the backend does not strip out query params which can return different results
-        // for the same page. Strip out the query params here to ensure consistent results.
-        const url = `${window.location.origin}${window.location.pathname}`;
-        const variantInfo = await this.parsePageVariantConfig(pageVariant, url);
-
-        if (variantInfo) {
-          return [variantInfo, pageVariant];
-        }
-      }
-    }
-
-    Logger.logWarn(
-      "[spiffy-ai] no pageVariantConfig matched",
-      undefined,
-      orgPageConfig.pageVariants
-    );
-    // TODO: remove or enable if we decide to support injection in this repo.
-    // await tellExtensionAboutInjectionError(
-    //   new Error("No pagevariantConfig matched")
-    // );
-
-    return undefined;
-  };
-
-  /**
-   * Checks if the current page is supported. A page is supported if it has been indexed in
-   * Elastic Search and its category has been whitelisted by the backend.
-   *
-   * @param pageVariantConfig - The variant config for the current page which is used to get
-   * the variant info.
-   *
-   * @returns The supported event response from the backend, or undefined if the page is not supported.
-   */
-  static readonly checkSupportedEvent = async (
-    pageVariantConfig: PageVariantConfig
-  ): Promise<SupportedEvent | undefined> => {
-    try {
-      const variantInfo = await this.parsePageVariantConfig(
-        pageVariantConfig,
-        window.location.href
-      );
-
-      const usesURLResolver = pageVariantConfig.variantTests.some(
-        (test) => test.testType === PageVariantTestType.UrlResolver
-      );
-
-      if (
-        !variantInfo ||
-        (variantInfo.variant === "plp" && !variantInfo.plpId) ||
-        (variantInfo.variant === "pdp" && !variantInfo.productId) ||
-        (variantInfo.variant === "page_visit" && !variantInfo.url)
-      ) {
-        return undefined;
-      }
-
-      const atomStore = getAtomStore();
-      const appDetails = atomStore.get(appDetailsAtom);
-
-      const visitEvent = createVisitUserEvent({ variantInfo });
-
-      if (!visitEvent) {
-        Logger.logWarn("spiffy-ai] no visitEvent found", variantInfo);
-        return undefined;
-      }
-
-      if (!usesURLResolver) {
-        return await CommerceApiClient.isSupportedEvent({
-          id: uuid(),
-          context: appDetails,
-          userEvent: visitEvent,
-        });
-      }
-
-      // If it got here, it means that the page is supported by the URL resolver.
-      // We still need to populate a supported event object to make the widgets show up.
-      const url = window._spiffy.variantUrlOverride ?? window.location.href;
-      const response = await this.getCachedUrlResolver(url);
-
-      const basicResponse = {
-        supported: true,
-        ready: response.ready,
-        numberOfReviews: 0,
-      } as SupportedEvent;
-
-      if (variantInfo.variant === "plp") {
-        const { top_category } =
-          response.specific_details as UrlResolvingPLPConfig;
-        return {
-          ...basicResponse,
-          top_category,
-        };
-      }
-
-      if (variantInfo.variant === "pdp") {
-        const { collections, number_of_reviews, merchant_tags } =
-          response.specific_details as UrlResolvingPDPConfig;
-        return {
-          ...basicResponse,
-          numberOfReviews: number_of_reviews || 0,
-          collections: collections || [],
-          merchant_tags,
-        };
-      }
-
-      return basicResponse;
-    } catch (error) {
-      Logger.logError("spiffy-ai] error checking supported event", error, {
-        pageVariantConfig,
-      });
-      return undefined;
-    }
-  };
-
-  /**
-   * Parses the page variant config into a variant info object.
-   *
-   * @param pageVariantConfig - The variant config for the current page.
-   * @param url - The current URL of the page. This is used to extract the pdp/plp id.
-   *
-   * @returns The variant info for the current page, or undefined if the page variant config is invalid or not supported.
-   */
-  private static readonly parsePageVariantConfig = async (
-    pageVariantConfig: PageVariantConfig,
-    url: string
-  ): Promise<VariantInfo | undefined> => {
-    if (window?._spiffy?.variantInfoOverride) {
-      return window._spiffy.variantInfoOverride;
-    }
-
-    if (pageVariantConfig.variantType === "pdp") {
-      let productId: string = "";
-      if (pageVariantConfig.productIdExtractor === "url-resolver-product-id") {
-        productId =
-          (await PageVariantService.getIdFromUrlResolver("productId")) ?? "";
-      } else {
-        productId =
-          (await PageVariantService.getId(
-            pageVariantConfig.productIdExtractor
-          )) ?? "";
-      }
-      const parentProductId =
-        (await PageVariantService.getId(
-          pageVariantConfig.parentProductIdExtractor
-        )) ?? "";
-      return {
-        variantId: pageVariantConfig.variantId,
-        variant: pageVariantConfig.variantType,
-        parentProductId,
-        productId,
-        url,
-      };
-    }
-
-    if (pageVariantConfig.variantType === "plp") {
-      let plpId: string = "";
-      if (pageVariantConfig.plpIdExtractor === "url-resolver-plp-id") {
-        plpId = (await PageVariantService.getIdFromUrlResolver("plpId")) ?? "";
-      } else {
-        plpId =
-          (await PageVariantService.getId(pageVariantConfig.plpIdExtractor)) ??
-          "";
-      }
-      return {
-        variantId: pageVariantConfig.variantId,
-        variant: pageVariantConfig.variantType,
-        plpId,
-        url,
-      };
-    }
-
-    if (pageVariantConfig.variantType === "page_visit") {
-      const pageVisitCategory =
-        pageVariantConfig.variantTests.reduce<PageVisitCategory | null>(
-          (acc, currentTest) =>
-            currentTest.testType === PageVariantTestType.PageCategory
-              ? PageVariantService.getCategory(currentTest.extractor)
-              : acc,
-          null
-        );
-
-      // This *should* only be the result of invalid config. Should we throw an error here or handle it with a default value?
-      if (pageVisitCategory === null) {
-        throw new Error(
-          "[spiffy-ai] - Invalid variant config produced invalid pageVisitCategory"
-        );
-      }
-
-      return {
-        variantId: pageVariantConfig.variantId,
-        variant: pageVariantConfig.variantType,
-        url,
-        pageVisitCategory,
-      };
-    }
-
-    if (pageVariantConfig.variantType === "homepage") {
-      return {
-        variantId: pageVariantConfig.variantId,
-        variant: "page_visit",
-        pageVisitCategory: PageVisitCategory.Homepage,
-        url,
-      };
-    }
-
-    if (pageVariantConfig.variantType === "search") {
-      return {
-        variantId: pageVariantConfig.variantId,
-        variant: "page_visit",
-        pageVisitCategory: PageVisitCategory.Search,
-        url,
-      };
-    }
-
-    if (pageVariantConfig.variantType === "other") {
-      return {
-        variantId: pageVariantConfig.variantId,
-        variant: "page_visit",
-        pageVisitCategory: PageVisitCategory.Other,
-        url,
-      };
-    }
-
-    return undefined;
-  };
-}
-
-export { PageVariantService };