@envive-ai/react-hooks 0.2.5 → 0.2.6-alpha

package/src/contexts/searchContext/searchContext.tsx

@@ -1,30 +1,23 @@
-import React, {
-  createContext,
-  useContext,
-  useCallback,
-  useMemo,
-  useEffect,
-} from "react";
-import { useAtomValue } from "jotai";
+import React, { createContext, useContext, useCallback, useMemo, useEffect } from 'react';
+import { useAtomValue } from 'jotai';
 import {
   Configuration,
   ResponseCategory,
   ResponseError,
   SearchApi,
-} from "@spiffy-ai/commerce-api-client";
-import { baseUrlAtom } from "src/atoms/envive/enviveConfig";
-import Logger from "src/application/logging/logger";
-import { useAppDetails } from "src/hooks/AppDetails/useAppDetails";
-import { useEnviveConfig } from "src/contexts/enviveConfigContext/enviveConfigContext";
-import { SessionRestartRequired } from "src/types/exceptions/sessionExceptions";
-import { UnsupportedProductException } from "src/types/exceptions/unsupportedProductExceptions";
-import { SearchParams, SearchResult } from "src/application/models/api/search";
+} from '@spiffy-ai/commerce-api-client';
+import { baseUrlAtom } from '../../atoms/envive/enviveConfig';
+import Logger from '../../application/logging/logger';
+import { SessionRestartRequired, UnsupportedProductException } from '../../exceptions';
+import { useAppDetails } from '../../hooks/AppDetails/useAppDetails';
+import { useEnviveConfig } from '../../contexts/enviveConfigContext/enviveConfigContext';
 import {
   clearSearchServiceFunction,
   setSearchServiceFunction,
-} from "src/atoms/search/searchServiceAdapter";
+} from '../../atoms/search/searchServiceAdapter';
+import { SearchContextValue, SearchParams, SearchResult } from '@envive-ai/types';
 
-const transformProductResponses = (products: SearchResult["products"]) =>
+const transformProductResponses = (products: SearchResult['products']) =>
   products.map((data) => ({
     id: data.id,
     responseId: data.response_id,
@@ -61,19 +54,19 @@ async function throwSessionRestartRequiredIf(errorMsg: string, error: unknown) {
 
   const errorResponse = await errorResponseBody(error);
   if (
-    errorResponse?.message?.toLowerCase() === "unsupported product" ||
-    errorResponse?.app_code?.toUpperCase() === "PRODUCT_NOT_FOUND"
+    errorResponse?.message?.toLowerCase() === 'unsupported product' ||
+    errorResponse?.app_code?.toUpperCase() === 'PRODUCT_NOT_FOUND'
   ) {
     throw new UnsupportedProductException();
   } else if (
-    errorResponse?.app_code?.toUpperCase() === "RESTART_SESSION" ||
-    errorResponse?.sub_code?.toUpperCase() === "NOT_FOUND"
+    errorResponse?.app_code?.toUpperCase() === 'RESTART_SESSION' ||
+    errorResponse?.sub_code?.toUpperCase() === 'NOT_FOUND'
   ) {
     Logger.logInfo(
-      "Session does not exist. Re-start session",
+      'Session does not exist. Re-start session',
       error,
       error.response,
-      errorResponse
+      errorResponse,
     );
     throw new SessionRestartRequired();
   }
@@ -82,16 +75,9 @@ async function throwSessionRestartRequiredIf(errorMsg: string, error: unknown) {
   throw error;
 }
 
-interface SearchContextValue {
-  searchProducts: (params: SearchParams) => Promise<SearchResult>;
-  isReady: boolean;
-}
-
 const SearchContext = createContext<SearchContextValue | undefined>(undefined);
 
-export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
-  children,
-}) => {
+export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
   const { orgLevelApiKey, publicKey } = useEnviveConfig();
   const apiKey = orgLevelApiKey || publicKey; // Replicate apiKeyAtom logic
   const appDetails = useAppDetails();
@@ -106,8 +92,8 @@ export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
       accessToken: apiKey,
       basePath: baseUrl,
       headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
       },
     });
     return new SearchApi(config);
@@ -116,7 +102,7 @@ export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
   const searchProducts = useCallback(
     async (params: SearchParams): Promise<SearchResult> => {
       if (!isReady || !searchApi) {
-        throw new Error("SearchService not ready - missing dependencies");
+        throw new Error('SearchService not ready - missing dependencies');
       }
 
       try {
@@ -126,30 +112,26 @@ export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
           org_id: appDetails.orgId,
           user_id: appDetails.userId,
         });
-        const {
-          products,
-          filters,
-          search_response_id: searchResponseId,
-        } = response;
+        const { products, filters, search_response_id: searchResponseId } = response;
 
         return {
           products: transformProductResponses(products) || [],
           filters: filters || [],
           totalProductCount: products?.length || 0,
-          searchResponseId: searchResponseId || "",
+          searchResponseId: searchResponseId || '',
         };
       } catch (error) {
-        await throwSessionRestartRequiredIf("Failed to search products", error);
+        await throwSessionRestartRequiredIf('Failed to search products', error);
         // This part will not be reached if an exception is thrown, but it's required for type safety
         return {
           products: [],
           filters: [],
           totalProductCount: 0,
-          searchResponseId: "",
+          searchResponseId: '',
         };
       }
     },
-    [searchApi, isReady, appDetails]
+    [searchApi, isReady, appDetails],
   );
 
   // Register the search function with the adapter for use in atoms
@@ -170,18 +152,16 @@ export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
       searchProducts,
       isReady,
     }),
-    [searchProducts, isReady]
+    [searchProducts, isReady],
   );
 
-  return (
-    <SearchContext.Provider value={value}>{children}</SearchContext.Provider>
-  );
+  return <SearchContext.Provider value={value}>{children}</SearchContext.Provider>;
 };
 
 export const useSearchService = () => {
   const context = useContext(SearchContext);
   if (!context) {
-    throw new Error("useSearchService must be used within a SearchProvider");
+    throw new Error('useSearchService must be used within a SearchProvider');
   }
   return context;
 };

package/src/contexts/sessionStorageContext/sessionStorageContext.tsx

@@ -1,28 +1,15 @@
-import React, {
-  createContext,
-  useContext,
-  useCallback,
-  useMemo,
-  useEffect,
-} from "react";
-import Logger from "../../application/logging/logger";
+import React, { createContext, useContext, useCallback, useMemo, useEffect } from 'react';
+import Logger from '../../application/logging/logger';
+import { SessionStorageContextType } from '@envive-ai/types';
 
-interface SessionStorageContextType {
-  setItem: (key: string, value: string) => void;
-  getItem: (key: string) => string | null;
-  isAvailable: boolean;
-}
-
-const SessionStorageContext = createContext<SessionStorageContextType | null>(
-  null
-);
+const SessionStorageContext = createContext<SessionStorageContextType | null>(null);
 
 export const SessionStorageProvider: React.FC<{
   children: React.ReactNode;
 }> = ({ children }) => {
   const isAvailable = useMemo(() => {
     try {
-      return typeof window !== "undefined" && !!window.sessionStorage;
+      return typeof window !== 'undefined' && !!window.sessionStorage;
     } catch {
       return false;
     }
@@ -30,7 +17,7 @@ export const SessionStorageProvider: React.FC<{
 
   useEffect(() => {
     if (!isAvailable) {
-      Logger.logError("sessionStorage is not available", undefined);
+      Logger.logError('sessionStorage is not available', undefined);
     }
   }, [isAvailable]);
 
@@ -38,11 +25,9 @@ export const SessionStorageProvider: React.FC<{
     (key: string, value: string) => {
       if (!isAvailable) return;
       sessionStorage.setItem(key, value);
-      window.dispatchEvent(
-        new StorageEvent("storage", { key, newValue: value })
-      );
+      window.dispatchEvent(new StorageEvent('storage', { key, newValue: value }));
     },
-    [isAvailable]
+    [isAvailable],
   );
 
   const getItem = useCallback(
@@ -50,7 +35,7 @@ export const SessionStorageProvider: React.FC<{
       if (!isAvailable) return null;
       return sessionStorage.getItem(key);
     },
-    [isAvailable]
+    [isAvailable],
   );
 
   const value = useMemo(
@@ -59,22 +44,16 @@ export const SessionStorageProvider: React.FC<{
       getItem,
       isAvailable,
     }),
-    [setItem, getItem, isAvailable]
+    [setItem, getItem, isAvailable],
   );
 
-  return (
-    <SessionStorageContext.Provider value={value}>
-      {children}
-    </SessionStorageContext.Provider>
-  );
+  return <SessionStorageContext.Provider value={value}>{children}</SessionStorageContext.Provider>;
 };
 
 export const useSessionStorage = () => {
   const context = useContext(SessionStorageContext);
   if (!context) {
-    throw new Error(
-      "useSessionStorage must be used within a SessionStorageProvider"
-    );
+    throw new Error('useSessionStorage must be used within a SessionStorageProvider');
   }
   return context;
 };

package/src/contexts/shopifyUrlContext/shopifyUrlContext.tsx

@@ -1,32 +1,20 @@
-import React, { createContext, useCallback, useContext, useMemo } from "react";
-import { IdExtractor } from "src/contexts/types";
-import { parseHref } from "src/application/utils/urlsParser";
+import React, { createContext, useCallback, useContext, useMemo } from 'react';
+import { parseHref } from '../../application/utils/urlsParser';
+import { IdExtractor, ShopifyUrlContextType } from '@envive-ai/types';
 
-interface ShopifyUrlContextType {
-  getTrimmedPathName: () => string | null;
-  getPlpOrPdpId: (extractor: IdExtractor) => string | null;
-  isOnPdpPage: () => boolean;
-  isOnPlpPage: () => boolean;
-  isReady: boolean;
-}
+const ShopifyUrlContext = createContext<ShopifyUrlContextType | undefined>(undefined);
 
-const ShopifyUrlContext = createContext<ShopifyUrlContextType | undefined>(
-  undefined
-);
-
-export const ShopifyUrlProvider: React.FC<{ children: React.ReactNode }> = ({
-  children,
-}) => {
+export const ShopifyUrlProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
   const isReady = true; // No external dependencies, so always ready
 
   const getTrimmedPathName = useCallback((): string | null => {
     let { pathname } = window.location;
     // strip out the proxy path so local dev still works
-    pathname = pathname.replace("/proxy", "");
+    pathname = pathname.replace('/proxy', '');
     // remove trailing hash if it exists
-    pathname = pathname.replace(/#.*$/, "");
+    pathname = pathname.replace(/#.*$/, '');
     // remove trailing /, ie. some URLs can end with '/' like /collections/cast-iron/
-    pathname = pathname.replace(/\/$/, "");
+    pathname = pathname.replace(/\/$/, '');
 
     if (pathname === undefined || pathname === null || pathname.length === 0) {
       return null;
@@ -37,35 +25,34 @@ export const ShopifyUrlProvider: React.FC<{ children: React.ReactNode }> = ({
 
   const getPlpOrPdpId = useCallback(
     (extractor: IdExtractor): string | null => {
-      if (extractor === "shopify-product-variant-id") {
+      if (extractor === 'shopify-product-variant-id') {
         const parsedHref = parseHref(window.location.href);
-        const variantId = parsedHref?.urlSearchParams?.get("variant");
+        const variantId = parsedHref?.urlSearchParams?.get('variant');
         if (!variantId) {
-          return getPlpOrPdpId("shopify-product-id");
+          return getPlpOrPdpId('shopify-product-id');
         }
         return variantId;
       }
 
-      const pathSegment =
-        extractor === "shopify-product-id" ? "products" : "collections";
-      const tokens = getTrimmedPathName()?.split("/");
+      const pathSegment = extractor === 'shopify-product-id' ? 'products' : 'collections';
+      const tokens = getTrimmedPathName()?.split('/');
       const idIndex = tokens?.findIndex((token) => token === pathSegment);
       if (idIndex !== undefined && idIndex >= 0 && tokens) {
         return decodeURIComponent(tokens[idIndex + 1]);
       }
       return null;
     },
-    [getTrimmedPathName]
+    [getTrimmedPathName],
   );
 
   const isOnPdpPage = useCallback((): boolean => {
-    return getTrimmedPathName()?.includes("/products") ?? false;
+    return getTrimmedPathName()?.includes('/products') ?? false;
   }, [getTrimmedPathName]);
 
   const isOnPlpPage = useCallback((): boolean => {
     return (
-      (getTrimmedPathName()?.includes("/collections") &&
-        !getTrimmedPathName()?.includes("/products")) ??
+      (getTrimmedPathName()?.includes('/collections') &&
+        !getTrimmedPathName()?.includes('/products')) ??
       false
     );
   }, [getTrimmedPathName]);
@@ -78,20 +65,16 @@ export const ShopifyUrlProvider: React.FC<{ children: React.ReactNode }> = ({
       isOnPlpPage,
       isReady,
     }),
-    [getTrimmedPathName, getPlpOrPdpId, isOnPdpPage, isOnPlpPage, isReady]
+    [getTrimmedPathName, getPlpOrPdpId, isOnPdpPage, isOnPlpPage, isReady],
   );
 
-  return (
-    <ShopifyUrlContext.Provider value={value}>
-      {children}
-    </ShopifyUrlContext.Provider>
-  );
+  return <ShopifyUrlContext.Provider value={value}>{children}</ShopifyUrlContext.Provider>;
 };
 
 export const useShopifyUrl = () => {
   const context = useContext(ShopifyUrlContext);
   if (!context) {
-    throw new Error("useShopifyUrl must be used within a ShopifyUrlProvider");
+    throw new Error('useShopifyUrl must be used within a ShopifyUrlProvider');
   }
   return context;
 };

package/src/contexts/systemSettingsContext/systemSettingsContext.tsx

@@ -1,14 +1,7 @@
-import { useAtomValue } from "jotai";
-import {
-  Dispatch,
-  ReactNode,
-  SetStateAction,
-  createContext,
-  useMemo,
-  useState,
-} from "react";
-import { GenerationParams } from "src/application/models";
-import { baseUrlAtom } from "src/atoms/envive/enviveConfig";
+import { GenerationParams } from '@envive-ai/types';
+import { useAtomValue } from 'jotai';
+import { Dispatch, ReactNode, SetStateAction, createContext, useMemo, useState } from 'react';
+import { baseUrlAtom } from 'src/atoms/envive/enviveConfig';
 
 // TODO: Refactor this to a common service that handles query params (and spiffy variables all together)
 const getChatModelName = () => {
@@ -37,9 +30,7 @@ interface SystemSettingsContextProviderProps {
   showDebugBar?: boolean;
 }
 
-const SystemSettingsContext = createContext<
-  SystemSettingsContextParams | undefined
->(undefined);
+const SystemSettingsContext = createContext<SystemSettingsContextParams | undefined>(undefined);
 
 const SystemSettingsContextProvider = ({
   children,
@@ -47,7 +38,7 @@ const SystemSettingsContextProvider = ({
   showDebugBar,
 }: SystemSettingsContextProviderProps) => {
   const [params, setParams] = useState<GenerationParams | undefined>(
-    () => generationParams ?? defaultGenerationParams
+    () => generationParams ?? defaultGenerationParams,
   );
   const endpointURL = useAtomValue(baseUrlAtom);
   const settingsContextValues = useMemo(
@@ -57,7 +48,7 @@ const SystemSettingsContextProvider = ({
       setGenerationParams: setParams,
       endpointURL,
     }),
-    [generationParams, endpointURL, showDebugBar]
+    [generationParams, endpointURL, showDebugBar],
   );
 
   return (
@@ -67,8 +58,4 @@ const SystemSettingsContextProvider = ({
   );
 };
 
-export {
-  SystemSettingsContextProvider,
-  SystemSettingsContext,
-  defaultGenerationParams,
-};
+export { SystemSettingsContextProvider, SystemSettingsContext, defaultGenerationParams };

package/src/contexts/userIdentityContext/userIdentityContext.tsx

@@ -1,17 +1,10 @@
-import React, {
-  createContext,
-  useCallback,
-  useContext,
-  useMemo,
-  useState,
-  useEffect,
-} from "react";
-import UAParser from "ua-parser-js";
-import Logger from "src/application/logging/logger";
-import CommerceApiClient from "src/application/commerce-api";
-import { v4 as uuid } from "uuid";
-import { ClientDetails } from "src/application/models/clientDetails";
-import { useLocalStorage } from "src/contexts/localStorageContext";
+import React, { createContext, useCallback, useContext, useMemo, useState, useEffect } from 'react';
+import UAParser from 'ua-parser-js';
+import { ClientDetails, UserIdentityContextType } from '@envive-ai/types';
+import Logger from '../../application/logging/logger';
+import CommerceApiClient from '../../application/commerce-api';
+import { useLocalStorage } from '../localStorageContext';
+import { v4 as uuid } from 'uuid';
 
 // Helper function from the original service
 const getUserAgentDetails = (): ClientDetails => {
@@ -30,29 +23,10 @@ const getUserAgentDetails = (): ClientDetails => {
   };
 };
 
-export interface UserIdentityContextType {
-  identifyUser: () => Promise<void>;
-  getUserIdOrDefault: () => string;
-  getUserIdOverrideFromLocalStorage: () => string | undefined;
-  getUserIdDefaultFromLocalStorage: () => string | undefined;
-  setUserIdDefaultInLocalStorage: (userId: string) => string;
-  setUserIdOverrideInLocalStorage: (userId: string) => string;
-  clearUserIdOverrideInLocalStorage: () => void;
-  isReady: boolean;
-}
-
-const UserIdentityContext = createContext<UserIdentityContextType | undefined>(
-  undefined
-);
-
-export const UserIdentityProvider: React.FC<{ children: React.ReactNode }> = ({
-  children,
-}) => {
-  const {
-    getItem,
-    setItem,
-    isAvailable: localStorageIsReady,
-  } = useLocalStorage();
+const UserIdentityContext = createContext<UserIdentityContextType | undefined>(undefined);
+
+export const UserIdentityProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+  const { getItem, setItem, isAvailable: localStorageIsReady } = useLocalStorage();
 
   const [isReady, setIsReady] = useState(false);
 
@@ -62,50 +36,44 @@ export const UserIdentityProvider: React.FC<{ children: React.ReactNode }> = ({
     setIsReady(localStorageIsReady);
   }, [localStorageIsReady]);
 
-  const USER_ID_OVERRIDE_KEY = "v1-spiffy-user-id-override";
-  const USER_ID_DEFAULT_KEY = "v1-spiffy-user-id-default";
+  const USER_ID_OVERRIDE_KEY = 'v1-spiffy-user-id-override';
+  const USER_ID_DEFAULT_KEY = 'v1-spiffy-user-id-default';
 
-  const getUserIdOverrideFromLocalStorage = useCallback(():
-    | string
-    | undefined => {
-    return getItem(USER_ID_OVERRIDE_KEY) ?? undefined;
-  }, [getItem]);
+  const getUserIdOverrideFromLocalStorage = useCallback(
+    (): string | undefined => getItem(USER_ID_OVERRIDE_KEY) ?? undefined,
+    [getItem],
+  );
 
-  const getUserIdDefaultFromLocalStorage = useCallback(():
-    | string
-    | undefined => {
-    return getItem(USER_ID_DEFAULT_KEY) ?? undefined;
-  }, [getItem]);
+  const getUserIdDefaultFromLocalStorage = useCallback(
+    (): string | undefined => getItem(USER_ID_DEFAULT_KEY) ?? undefined,
+    [getItem],
+  );
 
   const setUserIdDefaultInLocalStorage = useCallback(
     (userId: string): string => {
-      Logger.logInfo(
-        `setUserIdDefaultInLocalStorage - Setting user_id=${userId}`
-      );
+      Logger.logInfo(`setUserIdDefaultInLocalStorage - Setting user_id=${userId}`);
       setItem(USER_ID_DEFAULT_KEY, userId);
       // window.dispatchEvent is handled by useLocalStorage now
       return userId;
     },
-    [setItem, USER_ID_DEFAULT_KEY]
+    [setItem, USER_ID_DEFAULT_KEY],
   );
 
   const setUserIdOverrideInLocalStorage = useCallback(
     (userId: string): string => {
-      Logger.logInfo(
-        `setUserIdOverrideInLocalStorage - Setting user_id=${userId}`
-      );
+      Logger.logInfo(`setUserIdOverrideInLocalStorage - Setting user_id=${userId}`);
       setItem(USER_ID_OVERRIDE_KEY, userId);
       // window.dispatchEvent is handled by useLocalStorage now
       return userId;
     },
-    [setItem, USER_ID_OVERRIDE_KEY]
+    [setItem, USER_ID_OVERRIDE_KEY],
   );
 
   const clearUserIdOverrideInLocalStorage = useCallback(() => {
     Logger.logInfo(`clearUserIdOverrideInLocalStorage - Clearing user_id`);
     // LocalStorageService.getLocalStorage()?.removeItem(USER_ID_OVERRIDE_KEY);
     // window.dispatchEvent is handled by useLocalStorage now
-    setItem(USER_ID_OVERRIDE_KEY, ""); // Set to empty string to clear
+    setItem(USER_ID_OVERRIDE_KEY, ''); // Set to empty string to clear
   }, [setItem, USER_ID_OVERRIDE_KEY]);
 
   const getUserIdOrDefault = useCallback((): string => {
@@ -128,31 +96,25 @@ export const UserIdentityProvider: React.FC<{ children: React.ReactNode }> = ({
 
   const identifyUser = useCallback(async (): Promise<void> => {
     if (!isReady) {
-      Logger.logWarn(
-        "[UserIdentityContext] Context not ready, skipping identifyUser",
-        undefined
-      );
+      Logger.logWarn('[UserIdentityContext] Context not ready, skipping identifyUser', undefined);
       return;
     }
 
     try {
       // Temporarily commented out until WindowDataLayerService is resolved
       // const cdpUserId = WindowDataLayerService.getGoogleAnalyticsClientId();
-      const cdpUserId = "UNKNOWN_CDP_USER_ID"; // Placeholder
+      const cdpUserId = 'UNKNOWN_CDP_USER_ID'; // Placeholder
       const userId = getUserIdOrDefault();
       const userAgentDetails = getUserAgentDetails();
 
       if (!cdpUserId) {
-        Logger.logWarn(
-          "[spiffy-ai] No GA Client ID found, skipping identifyUser",
-          undefined
-        );
+        Logger.logWarn('[spiffy-ai] No GA Client ID found, skipping identifyUser', undefined);
         return;
       }
 
       await CommerceApiClient.identifyUser(userId, cdpUserId, userAgentDetails);
     } catch (error) {
-      Logger.logError("[spiffy-ai] Error identifying user", error);
+      Logger.logError('[spiffy-ai] Error identifying user', error);
     }
   }, [isReady, getUserIdOrDefault]);
 
@@ -176,22 +138,16 @@ export const UserIdentityProvider: React.FC<{ children: React.ReactNode }> = ({
       setUserIdOverrideInLocalStorage,
       clearUserIdOverrideInLocalStorage,
       isReady,
-    ]
+    ],
   );
 
-  return (
-    <UserIdentityContext.Provider value={value}>
-      {children}
-    </UserIdentityContext.Provider>
-  );
+  return <UserIdentityContext.Provider value={value}>{children}</UserIdentityContext.Provider>;
 };
 
 export const useUserIdentity = () => {
   const context = useContext(UserIdentityContext);
   if (!context) {
-    throw new Error(
-      "useUserIdentity must be used within a UserIdentityProvider"
-    );
+    throw new Error('useUserIdentity must be used within a UserIdentityProvider');
   }
   return context;
 };

package/src/events/index.ts

@@ -1,15 +1,13 @@
-export { SpiffyEvent } from './event-types';
-
+/* eslint-disable @typescript-eslint/no-explicit-any */
 /**
  * A singleton class for dispatching Spiffy events to the document object.
  * Provides functionality for adding default event data, managing listeners,
  * and dispatching events.
- * 
+ *
  * TODO: could add observability to the listeners, would need to track listeners
  * internally.
  */
 export class EventsDispatcher {
-
   static eventData: Record<string, any> = {};
 
   /**
@@ -38,7 +36,12 @@ export class EventsDispatcher {
       includeDefault = true;
     }
     const eventData = includeDefault ? { ...this.eventData, ...detail } : detail;
-    const event = new CustomEvent(eventName, { detail: eventData, bubbles: true, composed: true, cancelable: false });
+    const event = new CustomEvent(eventName, {
+      detail: eventData,
+      bubbles: true,
+      composed: true,
+      cancelable: false,
+    });
     window.dispatchEvent(event);
   }