@redotech/redo-hydrogen 1.4.6 → 1.4.8

package/src/utils/cart.ts

@@ -1,20 +1,24 @@
 import { FetcherWithComponents, useFetcher } from "@remix-run/react";
 import { CartInfoToEnable } from "../types";
-import { CartForm, CartReturn, OptimisticCart, OptimisticCartLine } from "@shopify/hydrogen";
-import type { AppData } from '@remix-run/react/dist/data';
-import React, { useCallback, useEffect, useRef } from 'react'
+import { CartForm, CartReturn, OptimisticCart } from "@shopify/hydrogen";
+import type { AppData } from "@remix-run/react/dist/data";
+import React, { useCallback, useEffect, useRef } from "react";
 import { CartWithActionsDocs } from "@shopify/hydrogen-react/dist/types/cart-types";
 import { CartLine, ComponentizableCartLine } from "@shopify/hydrogen-react/storefront-api-types";
 
-const DEFAULT_REDO_ENABLED_CART_ATTRIBUTE = 'redo_opted_in_from_cart';
+const DEFAULT_REDO_ENABLED_CART_ATTRIBUTE = "redo_opted_in_from_cart";
 const CONCIERGE_ATTRIBUTION_CART_ATTRIBUTE_KEY = "redo.conciergeAssisted";
 const CONCIERGE_CONVERSATION_IDS_STORAGE_KEY = "redoConciergeConversationIds";
 
-const isCartWithActionsDocs = (cart: CartReturn | CartWithActionsDocs| OptimisticCart): cart is CartWithActionsDocs => {
-  return (Array.isArray(cart.lines) && 'linesAdd' in cart && typeof cart.linesAdd === 'function');
-}
+const isCartWithActionsDocs = (
+  cart: CartReturn | CartWithActionsDocs | OptimisticCart,
+): cart is CartWithActionsDocs => {
+  return Array.isArray(cart.lines) && "linesAdd" in cart && typeof cart.linesAdd === "function";
+};
 
-const getCartLines = (cart: CartReturn | CartWithActionsDocs | OptimisticCart): Array<CartLine | ComponentizableCartLine> => {
+const getCartLines = (
+  cart: CartReturn | CartWithActionsDocs | OptimisticCart,
+): Array<CartLine | ComponentizableCartLine> => {
   if (isOptimisticCart(cart)) {
     return cart.lines.nodes;
   } else if (isCartWithActionsDocs(cart)) {
@@ -22,85 +26,75 @@ const getCartLines = (cart: CartReturn | CartWithActionsDocs | OptimisticCart):
   } else {
     return cart.lines.nodes ?? cart.lines.edges.map((edge) => edge.node);
   }
-}
+};
 
 // https://shopify.dev/docs/api/hydrogen/2025-01/hooks/useoptimisticcart
 const isOptimisticCart = (cart: CartReturn | CartWithActionsDocs | OptimisticCart): cart is OptimisticCart => {
-  return 'isOptimistic' in cart && (cart.isOptimistic ?? false);
-}
+  return "isOptimistic" in cart && (cart.isOptimistic ?? false);
+};
 
-const isRedoInCart = ({
-  cart
-}: {
-  cart: CartReturn | CartWithActionsDocs | OptimisticCart
-}): boolean => {
-  if(!cart) {
-    return false;
+// Build a stable key from non-Redo cart lines so effects can detect changes that
+// affect coverage eligibility/price even when the cart object is mutated in place.
+// Excludes Redo items so toggling coverage doesn't cause us to re-evaluate.
+const getCartEligibilityPriceKey = (cart: CartReturn | CartWithActionsDocs | OptimisticCart | undefined): string => {
+  if (!cart) {
+    return "";
   }
 
-  return getCartLines(cart).some((cartLine) => {
-    return cartLine.merchandise.product.vendor === 're:do';
-  });
-}
-
-const waitForConditionsMetOrTimeout = ({
-  conditions,
-  timeoutMs
-}: {
-  conditions: (() => boolean)[];
-  timeoutMs: number;
-}): Promise<boolean> => {
-  return new Promise((resolve, reject) => {
-    let start = Date.now();
-    let interval = setInterval(() => {
-      if((Date.now() - start) > timeoutMs) {
-        clearInterval(interval);
-        return resolve(false);
-      }
-
-      let conditionsMet = conditions.every((conditionCallback) => conditionCallback());
-
-      if(conditionsMet) {
-        clearInterval(interval);
-        return resolve(true);
-      }
-    }, 100);
-  })
-}
+  return getCartLines(cart)
+    .filter((cartLine) => cartLine.merchandise?.product?.vendor !== "re:do")
+    .map((cartLine) =>
+      [
+        cartLine.id,
+        cartLine.merchandise?.id,
+        cartLine.quantity,
+        cartLine.merchandise?.price?.amount,
+        cartLine.merchandise?.price?.currencyCode,
+        cartLine.cost?.totalAmount?.amount,
+        cartLine.cost?.totalAmount?.currencyCode,
+      ].join(":"),
+    )
+    .join("|");
+};
 
 const addProductToCartIfNeeded = async ({
   cart,
   fetcher,
   waitCartIdle,
-  cartInfoToEnable
+  cartInfoToEnable,
 }: {
-  cart: CartReturn | CartWithActionsDocs | OptimisticCart | undefined,
-  fetcher: FetcherWithComponents<unknown>,
+  cart: CartReturn | CartWithActionsDocs | OptimisticCart | undefined;
+  fetcher: FetcherWithComponents<unknown>;
   waitCartIdle: WaitCartIdleCallback;
-  cartInfoToEnable: CartInfoToEnable
+  cartInfoToEnable: CartInfoToEnable;
 }) => {
-  if(!cart) {
+  if (!cart) {
     return await addProductToCart({ cart, fetcher, waitCartIdle, cartInfoToEnable });
   }
 
   const redoProductsInCart = getCartLines(cart).filter((cartLine) => {
-    return cartLine.merchandise.product.vendor === 're:do';
+    return cartLine.merchandise.product.vendor === "re:do";
   });
   const correctRedoProductInCart = redoProductsInCart?.filter((cartLine) => {
     return cartLine.merchandise.id === `gid://shopify/ProductVariant/${cartInfoToEnable.variantId}`;
   });
-  if(redoProductsInCart.length === 0) {
+  if (redoProductsInCart.length === 0) {
     return await addProductToCart({ cart, fetcher, waitCartIdle, cartInfoToEnable });
-  } else if (redoProductsInCart.length === 1 && correctRedoProductInCart.length === 1 && correctRedoProductInCart[0].quantity === 1) {
+  } else if (
+    redoProductsInCart.length === 1 &&
+    correctRedoProductInCart.length === 1 &&
+    correctRedoProductInCart[0].quantity === 1
+  ) {
     // No action needed
     return;
   } else {
-    let isSuccess = true;
-
-    await removeLinesFromCart({ cart, fetcher, waitCartIdle, lineIds: redoProductsInCart.map((cartLine) => cartLine.id) });
+    await removeLinesFromCart({
+      cart,
+      fetcher,
+      waitCartIdle,
+      lineIds: redoProductsInCart.map((cartLine) => cartLine.id),
+    });
     await addProductToCart({ cart, fetcher, waitCartIdle, cartInfoToEnable });
-
-    return;
   }
 };
 
@@ -108,7 +102,7 @@ const removeLinesFromCart = async ({
   cart,
   fetcher,
   waitCartIdle,
-  lineIds
+  lineIds,
 }: {
   cart: CartReturn | CartWithActionsDocs | OptimisticCart | undefined;
   fetcher: FetcherWithComponents<unknown>;
@@ -118,11 +112,11 @@ const removeLinesFromCart = async ({
   const formInput = {
     action: CartForm.ACTIONS.LinesRemove,
     inputs: {
-      lineIds
-    }
-  }
+      lineIds,
+    },
+  };
 
-  if(cart && isCartWithActionsDocs(cart)) {
+  if (cart && isCartWithActionsDocs(cart)) {
     cart.linesRemove(lineIds);
     await waitCartIdle();
   } else {
@@ -130,7 +124,7 @@ const removeLinesFromCart = async ({
       {
         [CartForm.INPUT_NAME]: JSON.stringify(formInput),
       },
-      {method: 'POST', action: '/cart'},
+      { method: "POST", action: "/cart" },
     );
   }
 };
@@ -139,25 +133,28 @@ const removeProductFromCartIfNeeded = async ({
   cart,
   fetcher,
   waitCartIdle,
-  cartInfoToEnable
 }: {
-  cart: CartReturn | CartWithActionsDocs | OptimisticCart | undefined,
-  fetcher: FetcherWithComponents<unknown>,
-  waitCartIdle: WaitCartIdleCallback
-  cartInfoToEnable: CartInfoToEnable
+  cart: CartReturn | CartWithActionsDocs | OptimisticCart | undefined;
+  fetcher: FetcherWithComponents<unknown>;
+  waitCartIdle: WaitCartIdleCallback;
+  cartInfoToEnable: CartInfoToEnable;
 }) => {
-  if(!cart) {
-    console.error('No cart');
+  if (!cart) {
+    console.error("No cart");
     return;
   }
 
   const redoProductsInCart = getCartLines(cart).filter((cartLine) => {
-    return cartLine.merchandise.product.vendor === 're:do';
+    return cartLine.merchandise.product.vendor === "re:do";
   });
 
-  if(redoProductsInCart.length !== 0) {
-    await removeLinesFromCart({ cart, fetcher, waitCartIdle, lineIds: redoProductsInCart.map((cartLine) => cartLine.id) });
-  } else {
+  if (redoProductsInCart.length !== 0) {
+    await removeLinesFromCart({
+      cart,
+      fetcher,
+      waitCartIdle,
+      lineIds: redoProductsInCart.map((cartLine) => cartLine.id),
+    });
   }
 };
 
@@ -168,25 +165,23 @@ const addProductToCart = async ({
   cartInfoToEnable,
 }: {
   waitCartIdle: WaitCartIdleCallback;
-  cart: CartReturn | CartWithActionsDocs | OptimisticCart | undefined,
-  fetcher: FetcherWithComponents<unknown>,
-  cartInfoToEnable: CartInfoToEnable
+  cart: CartReturn | CartWithActionsDocs | OptimisticCart | undefined;
+  fetcher: FetcherWithComponents<unknown>;
+  cartInfoToEnable: CartInfoToEnable;
 }) => {
   const redoProductLine = {
-    "merchandiseId": `gid://shopify/ProductVariant/${cartInfoToEnable.variantId}`,
-    "quantity": 1,
+    merchandiseId: `gid://shopify/ProductVariant/${cartInfoToEnable.variantId}`,
+    quantity: 1,
   };
 
   const formInput = {
     action: CartForm.ACTIONS.LinesAdd,
     inputs: {
-      lines: [
-        redoProductLine
-      ]
-    }
-  }
+      lines: [redoProductLine],
+    },
+  };
 
-  if(cart && isCartWithActionsDocs(cart)) {
+  if (cart && isCartWithActionsDocs(cart)) {
     cart.linesAdd([redoProductLine]);
     await waitCartIdle();
   } else {
@@ -194,7 +189,7 @@ const addProductToCart = async ({
       {
         [CartForm.INPUT_NAME]: JSON.stringify(formInput),
       },
-      {method: 'POST', action: '/cart'},
+      { method: "POST", action: "/cart" },
     );
   }
 };
@@ -211,8 +206,7 @@ function getConciergeConversationIdsFromStorage(): string[] | null {
       return null;
     }
 
-    const conversationIdsWithExpiry: ConversationIdWithExpiry[] =
-      JSON.parse(stored);
+    const conversationIdsWithExpiry: ConversationIdWithExpiry[] = JSON.parse(stored);
     const now = Date.now();
 
     const validConversationIds = conversationIdsWithExpiry
@@ -220,7 +214,7 @@ function getConciergeConversationIdsFromStorage(): string[] | null {
       .map((item) => item.conversationId);
 
     return validConversationIds.length > 0 ? validConversationIds : null;
-  } catch (error) {
+  } catch (_error) {
     return null;
   }
 }
@@ -230,7 +224,7 @@ const setCartRedoEnabledAttribute = async ({
   fetcher,
   waitCartIdle,
   cartInfoToEnable,
-  enabled
+  enabled,
 }: {
   cart: CartReturn | CartWithActionsDocs | OptimisticCart | undefined;
   fetcher: FetcherWithComponents<unknown>;
@@ -240,15 +234,13 @@ const setCartRedoEnabledAttribute = async ({
 }) => {
   const redoCartAttribute = {
     key: cartInfoToEnable?.cartAttribute || DEFAULT_REDO_ENABLED_CART_ATTRIBUTE,
-    value: enabled.toString()
+    value: enabled.toString(),
   };
 
   const existingAttributes = cart?.attributes || [];
-  
-  const existingAttributesMap = new Map(
-    existingAttributes.map(attr => [attr.key, attr.value])
-  );
-  
+
+  const existingAttributesMap = new Map(existingAttributes.map((attr) => [attr.key, attr.value]));
+
   existingAttributesMap.set(redoCartAttribute.key, redoCartAttribute.value);
   const conciergeConversationIds = getConciergeConversationIdsFromStorage();
   if (conciergeConversationIds && conciergeConversationIds.length > 0) {
@@ -256,23 +248,23 @@ const setCartRedoEnabledAttribute = async ({
       CONCIERGE_ATTRIBUTION_CART_ATTRIBUTE_KEY,
       JSON.stringify({
         conciergeConversationIds: conciergeConversationIds,
-      })
+      }),
     );
   }
 
   const updatedAttributes = Array.from(existingAttributesMap.entries()).map(([key, value]) => ({
     key,
-    value: value ?? ""
+    value: value ?? "",
   }));
 
   const formInput = {
     action: CartForm.ACTIONS.AttributesUpdateInput,
     inputs: {
-      attributes: updatedAttributes
-    }
-  }
+      attributes: updatedAttributes,
+    },
+  };
 
-  if(cart && isCartWithActionsDocs(cart)) {
+  if (cart && isCartWithActionsDocs(cart)) {
     cart.cartAttributesUpdate(updatedAttributes);
     await waitCartIdle();
   } else {
@@ -280,49 +272,49 @@ const setCartRedoEnabledAttribute = async ({
       {
         [CartForm.INPUT_NAME]: JSON.stringify(formInput),
       },
-      {method: 'POST', action: '/cart'},
+      { method: "POST", action: "/cart" },
     );
   }
 };
 
-type FetcherData<T> = NonNullable<T | unknown> // FIXME: used to use SerializeFrom which is deprecated. Can this be better typed?
-type ResolveFunction<T> = (value: FetcherData<T>) => void
+type FetcherData<T> = NonNullable<T | unknown>; // FIXME: used to use SerializeFrom which is deprecated. Can this be better typed?
+type ResolveFunction<T> = (value: FetcherData<T>) => void;
 
 function useFetcherWithPromise<TData = AppData>(opts?: Parameters<typeof useFetcher>[0]) {
-  const fetcher = useFetcher<TData>(opts)
-  const resolveRef = React.useRef<ResolveFunction<TData>>(null)
-  const promiseRef = React.useRef<Promise<FetcherData<TData>>>(null)
+  const fetcher = useFetcher<TData>(opts);
+  const resolveRef = React.useRef<ResolveFunction<TData>>(null);
+  const promiseRef = React.useRef<Promise<FetcherData<TData>>>(null);
 
   if (!promiseRef.current) {
     promiseRef.current = new Promise<FetcherData<TData>>((resolve) => {
-      resolveRef.current = resolve
-    })
+      resolveRef.current = resolve;
+    });
   }
 
   const resetResolver = React.useCallback(() => {
     promiseRef.current = new Promise((resolve) => {
-      resolveRef.current = resolve
-    })
-  }, [promiseRef, resolveRef])
+      resolveRef.current = resolve;
+    });
+  }, [promiseRef, resolveRef]);
 
   const submit = React.useCallback(
     async (...args: Parameters<typeof fetcher.submit>) => {
       fetcher.submit(...args);
-      return promiseRef.current
+      return promiseRef.current;
     },
-    [fetcher, promiseRef]
-  )
+    [fetcher, promiseRef],
+  );
 
   React.useEffect(() => {
-    if (fetcher.state === 'idle') {
+    if (fetcher.state === "idle") {
       if (fetcher.data) {
-        resolveRef.current?.(fetcher.data)
+        resolveRef.current?.(fetcher.data);
       }
-      resetResolver()
+      resetResolver();
     }
-  }, [fetcher, resetResolver])
+  }, [fetcher, resetResolver]);
 
-  return { ...fetcher, submit }
+  return { ...fetcher, submit };
 }
 
 type WaitCartIdleCallback = () => Promise<CartReturn | CartWithActionsDocs | OptimisticCart>;
@@ -330,49 +322,46 @@ type WaitCartIdleCallback = () => Promise<CartReturn | CartWithActionsDocs | Opt
 // This function allows us to await a cart idle state without breaking React rules.
 // It returns a function, which returns a promise, which will resolve once the cart value passed in reaches an idle state.
 // Not intended for use with CartReturn, but will accept that value if passed in to avoid breaking rules of hooks
-const useWaitCartIdle = (cart: CartReturn | CartWithActionsDocs | OptimisticCart | undefined) => {
-  const resolveRef = useRef<any>(null)
-  const promiseRef = useRef<any>(null)
+type CartUnion = CartReturn | CartWithActionsDocs | OptimisticCart;
+
+const useWaitCartIdle = (cart: CartUnion | undefined) => {
+  const resolveRef = useRef<((value: CartUnion) => void) | null>(null);
+  const promiseRef = useRef<Promise<CartUnion>>(null!);
 
   if (!promiseRef.current) {
     promiseRef.current = new Promise<CartReturn | CartWithActionsDocs | OptimisticCart>((resolve) => {
-      resolveRef.current = resolve
-    })
+      resolveRef.current = resolve;
+    });
   }
 
   const resetResolver = useCallback(() => {
     promiseRef.current = new Promise((resolve) => {
-      resolveRef.current = resolve
-    })
+      resolveRef.current = resolve;
+    });
   }, [promiseRef, resolveRef]);
 
-  const waitCartIdle = useCallback(
-    async () => {
-      return promiseRef.current
-    },
-    [cart, promiseRef]
-  )
+  const waitCartIdle = useCallback(async () => {
+    return promiseRef.current;
+  }, [cart, promiseRef]);
 
   useEffect(() => {
-    if(!cart) {
+    if (!cart) {
       return;
     }
-    if(!isCartWithActionsDocs(cart)) {
+    if (!isCartWithActionsDocs(cart)) {
       // Wrong type of cart. Just resolve.
       resolveRef.current?.(cart);
       resetResolver();
-    } else if(cart.status === 'idle') {
-      resolveRef.current?.(cart)
+    } else if (cart.status === "idle") {
+      resolveRef.current?.(cart);
       resetResolver();
     }
   }, [cart, resetResolver]);
 
   return waitCartIdle;
-}
+};
 
-export type {
-  WaitCartIdleCallback
-}
+export type { WaitCartIdleCallback };
 
 export {
   DEFAULT_REDO_ENABLED_CART_ATTRIBUTE,
@@ -383,5 +372,6 @@ export {
   useWaitCartIdle,
   isCartWithActionsDocs,
   getCartLines,
-  isOptimisticCart
-};
+  getCartEligibilityPriceKey,
+  isOptimisticCart,
+};

package/src/utils/purple-dot.ts

@@ -0,0 +1,86 @@
+const DISABLED_ATTR = "data-redo-preorder-disabled";
+const ORIGINAL_DISABLED_ATTR = "data-redo-original-disabled";
+
+/**
+ * Finds add-to-cart buttons on the page
+ */
+function findAddToCartButtons(): HTMLButtonElement[] {
+  const buttons = document.querySelectorAll<HTMLButtonElement>(
+    'button[name="add"], button[type="submit"], .product-form__submit',
+  );
+
+  return Array.from(buttons).filter((button) => {
+    const text = button.textContent?.toLowerCase().trim() ?? "";
+    return text.includes("add to cart") || text.includes("add to bag");
+  });
+}
+
+/**
+ * Checks for Purple Dot preorder element and updates button states accordingly.
+ * Disables add-to-cart buttons when purple-dot-learn-more element is present.
+ * Re-enables them when the element is removed.
+ */
+export function updatePurpleDotButtons(): void {
+  const hasPurpleDot = document.querySelector("purple-dot-learn-more") !== null;
+  const addToCartButtons = findAddToCartButtons();
+
+  for (const button of addToCartButtons) {
+    if (hasPurpleDot) {
+      // Disable the button
+      if (!button.hasAttribute(DISABLED_ATTR)) {
+        // Preserve original disabled state
+        if (!button.hasAttribute(ORIGINAL_DISABLED_ATTR)) {
+          button.setAttribute(ORIGINAL_DISABLED_ATTR, String(button.disabled));
+        }
+
+        button.setAttribute(DISABLED_ATTR, "true");
+        button.disabled = true;
+        button.style.opacity = "0.5";
+        button.style.cursor = "not-allowed";
+        button.style.pointerEvents = "none";
+
+        // Add message if not already present
+        if (!button.parentElement?.querySelector(".redo-preorder-msg")) {
+          const msg = document.createElement("div");
+          msg.className = "redo-preorder-msg";
+          msg.textContent = "Preorder items cannot be added during exchanges";
+          msg.style.cssText = "color: #d63031; font-size: 12px; margin-top: 8px; font-weight: 500;";
+          button.parentElement?.insertBefore(msg, button.nextSibling);
+        }
+      }
+    } else {
+      // Re-enable the button if we disabled it
+      if (button.hasAttribute(DISABLED_ATTR)) {
+        const wasDisabled = button.getAttribute(ORIGINAL_DISABLED_ATTR) === "true";
+        button.removeAttribute(DISABLED_ATTR);
+        button.removeAttribute(ORIGINAL_DISABLED_ATTR);
+        button.disabled = wasDisabled;
+        button.style.opacity = "";
+        button.style.cursor = "";
+        button.style.pointerEvents = "";
+        button.parentElement?.querySelector(".redo-preorder-msg")?.remove();
+      }
+    }
+  }
+}
+
+/**
+ * Cleans up all disabled buttons (used on unmount).
+ * Restores original disabled state.
+ */
+export function cleanupPurpleDotButtons(): void {
+  const disabledButtons = Array.from(document.querySelectorAll<HTMLButtonElement>(`button[${DISABLED_ATTR}]`));
+
+  for (const button of disabledButtons) {
+    const wasDisabled = button.getAttribute(ORIGINAL_DISABLED_ATTR) === "true";
+    button.removeAttribute(DISABLED_ATTR);
+    button.removeAttribute(ORIGINAL_DISABLED_ATTR);
+    button.disabled = wasDisabled;
+    button.style.opacity = "";
+    button.style.cursor = "";
+    button.style.pointerEvents = "";
+  }
+
+  // Remove all messages
+  document.querySelectorAll(".redo-preorder-msg").forEach((msg) => msg.remove());
+}

package/src/utils/react-utils.ts

@@ -1,17 +1,11 @@
-import {
-  DependencyList,
-  useCallback,
-  useEffect,
-  useRef,
-  useState,
-} from "react";
+import { DependencyList, useEffect, useState } from "react";
 
 export interface Loader<T> {
   (abort: AbortSignal): Promise<T>;
 }
 
 export interface LoadState<T> {
-  error?: any;
+  error?: unknown;
   pending: boolean;
   value?: T;
 }
@@ -24,12 +18,14 @@ export function useLoad<T>(fn: Loader<T>, deps: DependencyList): LoadState<T> {
     setState((state) => ({ ...state, pending: true }));
     fn(abortController.signal).then(
       (value) => setState({ pending: false, value }),
-      (error) => {
+      (error: unknown) => {
+        const message = error instanceof Error ? error.message : "";
+        const code = (error as Record<string, unknown>)?.code;
         if (
           !(
-            error.message.includes("Request aborted for RPC method") ||
-            error.code === "ERR_CANCELED" ||
-            error.message === "Another request is in flight"
+            message.includes("Request aborted for RPC method") ||
+            code === "ERR_CANCELED" ||
+            message === "Another request is in flight"
           )
         ) {
           setState({ pending: false, error });
@@ -43,8 +39,7 @@ export function useLoad<T>(fn: Loader<T>, deps: DependencyList): LoadState<T> {
     // The way useLoad() is designed, we have no choice but to trust that the user gave us the correct deps for fn().
     // We could fix this by marking useLoad() as a custom hook, and then exhaustive-deps would enforce that for us.
     // https://www.npmjs.com/package/eslint-plugin-react-hooks#advanced-configuration
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, deps);
 
   return state;
-}
+}

package/src/utils/security.ts

@@ -1,10 +1,5 @@
-const REDO_PUBLIC_API_HOSTNAME = 'api.getredo.com';
+const REDO_PUBLIC_API_HOSTNAME = "api.getredo.com";
 
-const REDO_REQUIRED_HOSTNAMES = [
-  REDO_PUBLIC_API_HOSTNAME
-];
+const REDO_REQUIRED_HOSTNAMES = [REDO_PUBLIC_API_HOSTNAME];
 
-export {
-  REDO_REQUIRED_HOSTNAMES,
-  REDO_PUBLIC_API_HOSTNAME
-};
+export { REDO_REQUIRED_HOSTNAMES, REDO_PUBLIC_API_HOSTNAME };

package/src/utils/timeout.ts

@@ -3,10 +3,5 @@ export async function executeWithTimeout<T, E extends Error>(
   timeoutMs: number,
   error: E = new Error("timeout") as E,
 ): Promise<T> {
-  return Promise.race([
-    promise,
-    new Promise<never>((_, reject) =>
-      setTimeout(() => reject(error), timeoutMs),
-    ),
-  ]);
+  return Promise.race([promise, new Promise<never>((_, reject) => setTimeout(() => reject(error), timeoutMs))]);
 }