@app-brew/brewery 1.0.0

package/src/state/src/lib/cart.ts

@@ -0,0 +1,1779 @@
+import {
+  AddressItem,
+  AnalyticsEvent,
+  AsyncData,
+  Country,
+  Currency,
+  GiftItem,
+  GiftLineItem,
+  GiftsProvider,
+  ICartProvider,
+  ItemEvent,
+  LineItem,
+  LineItemToAdd,
+  ProductVariantId,
+  ResponseData,
+} from '@gauntlet/types'
+import { AddressSlice } from './address'
+import { ConfigSlice } from './config'
+import { LocalStorage } from '@gauntlet/local-storage'
+import { ModuleSlice } from './modules'
+import { StoreSlice } from './types'
+import { UserSlice } from './user'
+import { ProductSlice } from './products'
+import { AnalyticsSlice } from './analytics'
+import { getAnalyticsProvider } from './integrations/analytics'
+import { useAppStore } from './store'
+import {
+  Cart,
+  MailingAddress,
+  Maybe,
+  AttributeInput,
+  DiscountAllocationBase,
+} from '@gauntlet/shopify-types'
+import { LocalisationUserInfo, LocalizationSlice } from './localization'
+import { CheckoutSlice } from './checkout'
+import { DiscountSlice } from './discounts'
+import { DiscountV2 } from '@gauntlet/shopify-types'
+
+export interface CartState {
+  data: {
+    lineItems: LineItem[]
+    count: number
+    webUrl?: string
+    id: string | number
+    payment?: Cart['payment']
+    discount?: any
+    note?: string
+    eligibleGiftItems: GiftItem[][] // items to be shown in modal eigible for to be added as gift
+    giftItemsInCart: GiftLineItem[] // items added in cart as a gift
+    discountV2: DiscountV2
+    lineItemsV2: LineItemV2
+    discountCodes: { applicable: boolean; code: string }[]
+    updatedAt?: number
+    groupRestrictionsToQuantity: Map<string, number>
+    cartAttributes?: Record<string, string>
+    discountCodes?: string[]
+  }
+  status: 'init' | 'idle' | 'loading' | 'error'
+}
+
+export interface CartActions {
+  get: () => Promise<boolean>
+  addItemsToCart: (
+    lineItems: LineItemToAdd[]
+  ) => Promise<ResponseData<Cart> | undefined>
+  createIsolatedCartForCheckout: (
+    lineItems: LineItemToAdd[]
+  ) => Promise<Cart | undefined>
+  updateQuantityForLineItem: (
+    variantId: string | number,
+    quantity: number
+  ) => void
+  syncCartPrices: () => Promise<Cart | undefined>
+  updateVariantForLineItem: (
+    variantId: ProductVariantId,
+    lineItem: LineItem
+  ) => Promise<any>
+  updateQuantityForLineItems: (
+    lineItems: Array<{ id: string | number; quantity: number }>,
+    giftItemsInCart?: GiftLineItem[]
+  ) => Promise<any>
+  fetchCart: (props?: { refresh?: boolean }) => Promise<Cart | undefined>
+  applyDiscountCode: (code: string) => Promise<Cart | undefined>
+  applyDiscountCodeV2: (code: string) => Promise<Cart | undefined>
+  removeDiscountCodeV2: (code: string) => Promise<Cart>
+  removeDiscountCode: (discountCodes?: string[]) => Promise<Cart>
+  removeItemsFromCart: (
+    lineItemIds: string[],
+    analyticsParams?: ItemEvent,
+    giftItemsInCart?: GiftLineItem[]
+  ) => Promise<Cart | undefined>
+  updateShippingAddress: () => Promise<void>
+
+  getItemCount: () => number
+  updateCart: (cart: Cart, checkForGift: boolean) => void
+  applyFreeGifts: (
+    cart: Cart,
+    couponCode?: string
+  ) => Promise<{ isGiftAdded: boolean } | undefined>
+  resetCart: () => undefined
+  getDiscountCodes: () => Promise<any>
+  addGiftItems: (
+    newEligibleGiftItemsList: GiftItem[][],
+    cart?: Cart
+  ) => Promise<void>
+  removeGiftItems: (
+    cart: Cart,
+    existingGiftItemsToRemove: GiftItem[]
+  ) => Promise<void>
+  removeGiftItemsV2: (
+    cart: Cart,
+    existingGiftItemsToRemove: GiftItem[]
+  ) => Promise<void>
+  clearGiftItems: () => void
+  setCartStatus: (status: 'init' | 'idle' | 'loading' | 'error') => void
+  updateBuyerIdentity: (buyerIdentity: {
+    customerAccessToken: string
+    email: string
+  }) => Promise<void>
+  updateCartAttributes: (
+    attributes: AttributeInput[]
+  ) => Promise<ResponseData<Cart>>
+  applyAutoCoupon: (cart: Cart, lastAddedProduct: LineItemToAdd) => void
+  updateDummyProductToCart: (lineItems: LineItemToAdd[]) => void
+  updateCustomAttributesForLineItems: (
+    lineItems: Array<{ id: string; customAttributes: Record<string, string> }>
+  ) => Promise<void>
+  updateNoteOnCart: (note: string) => Promise<void>
+}
+export interface CartSlice {
+  cart: CartState & CartActions
+}
+
+const localStorage = LocalStorage.getInstance()
+
+export const createCartSlice: StoreSlice<
+  CartSlice,
+  CartSlice &
+    ConfigSlice &
+    AddressSlice &
+    ModuleSlice &
+    UserSlice &
+    ProductSlice &
+    AnalyticsSlice &
+    LocalizationSlice &
+    CheckoutSlice &
+    DiscountSlice &
+    ConfigSlice &
+    AddressSlice &
+    ModuleSlice &
+    UserSlice &
+    ProductSlice &
+    AnalyticsSlice &
+    LocalizationSlice &
+    CheckoutSlice &
+    DiscountSlice
+> = (set, get) => ({
+  cart: {
+    status: 'init',
+    data: {
+      lineItems: [],
+      count: 0,
+      id: '',
+      eligibleGiftItems: [],
+      giftItemsInCart: [],
+      discountV2: [],
+      discountCodes: [],
+      lineItemsV2: [],
+      groupRestrictionsToQuantity: new Map(),
+    },
+    get: async () => {
+      return true
+    },
+    addItemsToCart: async (lineItems: LineItemToAdd[]) => {
+      try {
+        set((store) => {
+          store.cart.status = 'loading'
+        })
+        const customerAccessToken = get().user.getCustomerAccessToken()
+        const email = get().user.data.userDetails?.data?.email?.toLowerCase()
+        const cartModule = get().modules.getModule<ICartProvider>('cart')
+        const cartId =
+          (get().cart.data.id as string) ||
+          (localStorage.getJson<{ id: string }>('cart')?.id as string)
+
+        let cartAttributes: AttributeInput[] = [
+          {
+            key: APPBREW_INSTANCE_ID,
+            value: get().analytics.getInstanceId(),
+          },
+        ]
+
+        const enableUtmAsCartAttributes =
+          get().config.data?.settings?.global?.enableUtmAsCartAttributes
+        if (enableUtmAsCartAttributes) {
+          try {
+            const utmParams = await get().analytics.getEventSourceUtmParams()
+            if (utmParams) {
+              const utmAttributes = Object.entries(utmParams).map(
+                ([key, value]) => ({
+                  key,
+                  value: String(value), // Ensure value is a string
+                })
+              )
+              cartAttributes = cartAttributes.concat(utmAttributes)
+            }
+          } catch (error) {
+            console.error('Error getting UTM parameters:', error)
+          }
+        }
+
+        setUserAddressFromLocalization()
+        const selectedAddress = get().address.selectedAddress
+
+        const buyerIdentityCountryCode: {
+          isoCode?: string
+          name?: string
+          currency?: Currency
+        } = {}
+
+        const localizationCountry = get().localization.data.selectedCountry
+
+        if (localizationCountry) {
+          buyerIdentityCountryCode.isoCode = localizationCountry.isoCode
+          buyerIdentityCountryCode.name = localizationCountry.name
+          buyerIdentityCountryCode.currency = localizationCountry.currency
+        }
+
+        let deliveryAddressPreferences = null
+        const buyerIdentity = {
+          email,
+          customerAccessToken,
+          countryCode: buyerIdentityCountryCode.isoCode,
+        }
+        const defaultAddress = get().user.data.userDetails.data?.defaultAddress
+
+        let addressInput = {
+          firstName: defaultAddress?.firstName,
+          lastName: defaultAddress?.lastName,
+          zip: '',
+          city: '',
+          province: '',
+          address1: '',
+          address2: '',
+          country: localizationCountry?.name,
+          phone: '',
+        }
+
+        if (selectedAddress && selectedAddress?.country) {
+          addressInput = {
+            firstName: selectedAddress.firstName,
+            lastName: selectedAddress.lastName,
+            zip: selectedAddress.zip,
+            city: selectedAddress.city,
+            province: selectedAddress.province,
+            address1: selectedAddress.address1,
+            address2: selectedAddress.address2,
+            country: selectedAddress.country,
+            phone: selectedAddress.phone,
+          }
+        }
+        deliveryAddressPreferences = [
+          {
+            deliveryAddress: addressInput,
+          },
+        ]
+
+        if (deliveryAddressPreferences) {
+          buyerIdentity['deliveryAddressPreferences'] =
+            deliveryAddressPreferences
+        }
+
+        const res = cartId
+          ? await cartModule.addItemsToCart(cartId, lineItems)
+          : await cartModule.createEmptyCart(
+              lineItems,
+              buyerIdentity,
+              {},
+              cartAttributes
+            )
+        const { status, data, error, warning } = res
+
+        if (status === 'success') {
+          get().analytics.sendCartEvent(
+            lineItems.map((item) => {
+              const product = data?.lineItems.find(
+                (lineItem) => lineItem.variantId === item.variantId
+              )
+              return {
+                productHandle: product?.productHandle,
+                quantity: item.quantity,
+                variantId: item.variantId,
+              }
+            }),
+            AnalyticsEvent.ADD_TO_CART
+          )
+          const updateCart = get().cart.updateCart
+          updateCart(data, true)
+          get().cart.applyAutoCoupon(data, lineItems[lineItems.length - 1])
+        } else {
+          set((store) => {
+            store.cart.status = 'idle'
+          })
+          console.log('error', { status, error })
+          return
+        }
+        if (warning) {
+          return { ...data, warning }
+        }
+        return data
+      } catch (e) {
+        console.error(e)
+        set((store) => {
+          store.cart.status = 'idle'
+        })
+        return get().cart.fetchCart({ refresh: true })
+      }
+    },
+    createIsolatedCartForCheckout: async (lineItems: LineItemToAdd[]) => {
+      try {
+        const customerAccessToken = get().user.getCustomerAccessToken()
+        const email = get().user.data.userDetails?.data?.email?.toLowerCase()
+        const cartModule = get().modules.getModule<ICartProvider>('cart')
+
+        let cartAttributes: AttributeInput[] = [
+          {
+            key: APPBREW_INSTANCE_ID,
+            value: get().analytics.getInstanceId(),
+          },
+        ]
+
+        const enableUtmAsCartAttributes =
+          get().config.data?.settings?.global?.enableUtmAsCartAttributes
+        if (enableUtmAsCartAttributes) {
+          try {
+            const utmParams = await get().analytics.getEventSourceUtmParams()
+            if (utmParams) {
+              const utmAttributes = Object.entries(utmParams).map(
+                ([key, value]) => ({
+                  key,
+                  value: String(value),
+                })
+              )
+              cartAttributes = cartAttributes.concat(utmAttributes)
+            }
+          } catch (error) {
+            console.error('Error getting UTM parameters:', error)
+          }
+        }
+
+        setUserAddressFromLocalization()
+        const selectedAddress = get().address.selectedAddress
+
+        const buyerIdentityCountryCode: {
+          isoCode?: string
+          name?: string
+          currency?: Currency
+        } = {}
+
+        const localizationCountry = get().localization.data.selectedCountry
+
+        if (localizationCountry) {
+          buyerIdentityCountryCode.isoCode = localizationCountry.isoCode
+          buyerIdentityCountryCode.name = localizationCountry.name
+          buyerIdentityCountryCode.currency = localizationCountry.currency
+        }
+
+        let deliveryAddressPreferences = null
+        const buyerIdentity: Record<string, any> = {
+          email,
+          customerAccessToken,
+          countryCode: buyerIdentityCountryCode.isoCode,
+        }
+        const defaultAddress = get().user.data.userDetails.data?.defaultAddress
+
+        let addressInput = {
+          firstName: defaultAddress?.firstName,
+          lastName: defaultAddress?.lastName,
+          zip: '',
+          city: '',
+          province: '',
+          address1: '',
+          address2: '',
+          country: localizationCountry?.name,
+          phone: '',
+        }
+
+        if (selectedAddress && selectedAddress?.country) {
+          addressInput = {
+            firstName: selectedAddress.firstName,
+            lastName: selectedAddress.lastName,
+            zip: selectedAddress.zip,
+            city: selectedAddress.city,
+            province: selectedAddress.province,
+            address1: selectedAddress.address1,
+            address2: selectedAddress.address2,
+            country: selectedAddress.country,
+            phone: selectedAddress.phone,
+          }
+        }
+        deliveryAddressPreferences = [
+          {
+            deliveryAddress: addressInput,
+          },
+        ]
+
+        if (deliveryAddressPreferences) {
+          buyerIdentity['deliveryAddressPreferences'] =
+            deliveryAddressPreferences
+        }
+
+        const res = await cartModule.createEmptyCart(
+          lineItems,
+          buyerIdentity as any,
+          {},
+          cartAttributes as any
+        )
+
+        const { status, data, error } = res
+        if (status === 'success') {
+          get().analytics.sendCartEvent(
+            lineItems.map((item) => {
+              const product = data?.lineItems.find(
+                (lineItem) => lineItem.variantId === item.variantId
+              )
+              return {
+                productHandle: product?.productHandle,
+                quantity: item.quantity,
+                variantId: item.variantId,
+              }
+            }),
+            AnalyticsEvent.ADD_TO_CART
+          )
+          return data
+        } else {
+          console.log('error', { status, error })
+          return undefined
+        }
+      } catch (e) {
+        console.error(e)
+        return undefined
+      }
+    },
+    applyAutoCoupon: async (cart, lastAddedProduct) => {
+      const discount = get().discounts.getUpsellDiscount()
+      if (!discount) return
+      const {
+        appliesToProducts,
+        appliesToProductVariants,
+        appliesToCollections,
+      } = discount.customerGets
+      const discountCode = discount.discountCode
+      const lastProductInCart = cart.lineItems.find(
+        (item) => item.variantId === lastAddedProduct.variantId
+      )
+      if (
+        lastProductInCart &&
+        (appliesToProductVariants.includes(lastProductInCart.variant.id) ||
+          appliesToProducts.includes(lastProductInCart.productId) ||
+          // temporary code for aembr
+          (discount.enableDiscountV1 &&
+            appliesToProducts.includes(lastProductInCart.productHandle)) ||
+          appliesToCollections.some((collection) =>
+            lastProductInCart.collectionIds.has(collection)
+          ))
+      ) {
+        get().cart.applyDiscountCode(discountCode)
+      }
+    },
+    removeItemsFromCart: async (
+      lineItemIds: string[],
+      analyticsParams?: ItemEvent,
+      giftItemsInCart?: GiftLineItem[]
+    ) => {
+      set((store) => {
+        store.cart.status = 'loading'
+      })
+      try {
+        /**
+         * 1. build a lineItemId to lineItem Map
+         * 2. iterate the map and build replaceCartCallParams and removeCartCallParams
+         * 3. determine if replace or remove is to be done.
+         * 4. make network call and update cart
+         */
+        const cartModule = get().modules.getModule<ICartProvider>('cart')
+        let isReplaceRequired = false
+        const replaceParams = {
+          id: get().cart.data.id,
+          lines: [] as Array<Record<string, any>>,
+        }
+        const lineIds = lineItemIds.filter((lineItemId) => {
+          for (const lineItem of get().cart.data.lineItems) {
+            if (lineItem.id === lineItemId) {
+              return true
+            }
+          }
+          return false
+        })
+        for (const lineItemId of lineItemIds) {
+          const item = get().cart.data.lineItems.find(
+            (item) => item.id === lineItemId
+          )
+          /**
+           * if item is a child item
+           * TODO: what if parent quantity is more than 1 ??
+           */
+          if (item?.customAttributes && item?.customAttributes?.['_parentId']) {
+            const parentId = item?.customAttributes?.['_parentId']
+
+            const parentLineItemId = get().cart.data.lineItems.find((item) => {
+              return item?.customAttributes?.['_id'] === parentId
+            })?.id
+
+            // if parent id exists and it is not in the list of items to be removed then we replace the parent item with updated custom attributes
+            if (parentLineItemId && !lineIds.includes(parentLineItemId))
+              isReplaceRequired = true
+
+            /**
+             * To build lineItems param for replace call
+             * 1. map through all line items in cart
+             * 2. if the line item is not the one that needs to be removed
+             * 3. build a new object with updated custom attributes
+             * 4. while looping through, if the line item is a parent item, remove the custom attribute of the itemToBeRemoved from parent
+             *
+             */
+            const param = get()
+              .cart.data.lineItems.map((lineItem) => {
+                if (
+                  lineItem.customAttributes?.['_id'] !==
+                  item?.customAttributes?.['_id']
+                ) {
+                  const obj: Record<string, any> = {}
+                  obj['quantity'] = lineItem.quantity
+                  obj['variantId'] = lineItem.variantId
+                  obj['id'] = lineItem.id
+
+                  if (
+                    item?.customAttributes?.['_parentId'] !==
+                    lineItem.customAttributes?.['_id']
+                  ) {
+                    obj['customAttributes'] = transformCustomAttributesInput(
+                      lineItem.customAttributes
+                    )
+                  } else {
+                    const keyToBeRemovedFromParentCustomAttr =
+                      item?.customAttributes?.['_parentAttr']
+                    const newParentCustomAttributes: Record<string, string> = {}
+                    if (lineItem.customAttributes) {
+                      Object.entries(lineItem.customAttributes).forEach(
+                        ([key, value]) => {
+                          if (key !== keyToBeRemovedFromParentCustomAttr) {
+                            newParentCustomAttributes[key] = value
+                          }
+                        }
+                      )
+                    }
+
+                    obj['customAttributes'] = transformCustomAttributesInput(
+                      newParentCustomAttributes
+                    )
+                  }
+                  return obj
+                }
+              })
+              .filter((i): i is Record<string, any> => !!i)
+            replaceParams.lines = param
+          } else {
+            // if its a parent item, remove all child items
+            const parentId = item?.customAttributes?.['_id']
+            if (parentId) {
+              for (const lineItem of get().cart.data.lineItems) {
+                if (lineItem.customAttributes?.['_parentId'] === parentId) {
+                  lineIds.push(lineItem.id)
+                }
+              }
+            }
+          }
+        }
+
+        const {
+          status,
+          data: cart,
+          error,
+        } = isReplaceRequired
+          ? await cartModule.replaceCheckoutLineItems(
+              replaceParams.id,
+              replaceParams.lines,
+              get().cart.data.lineItems
+            )
+          : await cartModule.removeItemsFromCart(
+              get().cart.data.id as string,
+              lineIds
+            )
+        if (status !== 'success') {
+          set((store) => {
+            store.cart.status = 'idle'
+          })
+          return
+        }
+        get().analytics.sendCartEvent(
+          lineItemIds.map((lineItemId) => {
+            const product: any = get().cart.data.lineItems.find(
+              (lineItem) => lineItem.id === lineItemId
+            )
+            return {
+              productHandle: product?.productHandle,
+              quantity: product?.quantity,
+              variantId: product?.variantId,
+            }
+          }),
+          AnalyticsEvent.REMOVE_FROM_CART
+        )
+        if (giftItemsInCart) {
+          cart.giftItemsInCart = giftItemsInCart
+        }
+        if (!cart.lineItems || cart.lineItems.length === 0)
+          return get().cart.resetCart()
+        const updateCart = get().cart.updateCart
+        updateCart(cart, true)
+        return cart
+      } catch (e) {
+        console.error(e)
+        return get().cart.fetchCart({ refresh: true })
+      }
+    },
+    fetchCart: async ({ refresh }) => {
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      const cartId =
+        (get().cart.data.id as string) ||
+        localStorage.getJson<{ id: string }>('cart')?.id
+
+      if (cartId === undefined || cartId === '') {
+        if (get().cart.status !== 'idle') {
+          set((store) => {
+            store.cart.status = 'idle'
+          })
+        }
+        return undefined
+      } else if (!refresh && get().cart.status === 'idle' && get().cart.data) {
+        return undefined
+      } else {
+        set((store) => {
+          store.cart.status = 'loading'
+        })
+
+        try {
+          const {
+            status,
+            data: cart,
+            error,
+          } = await cartModule.fetchCart(cartId)
+          if (status !== 'success') return
+          if (cart?.completedAt) {
+            get().cart.resetCart()
+            return cart
+          }
+
+          cart.giftItemsInCart =
+            localStorage.getJson('cart')?.giftItemsInCart || []
+          const updateCart = get().cart.updateCart
+          updateCart(cart, false)
+          return cart
+        } catch (e) {
+          return get().cart.resetCart()
+        }
+      }
+    },
+    syncCartPrices: async () => {
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      const cartId =
+        (get().cart.data.id as string) ||
+        localStorage.getJson<{ id: string }>('cart')?.id
+
+      if (cartId === undefined || cartId === '') {
+        if (get().cart.status !== 'idle') {
+          set((store) => {
+            store.cart.status = 'idle'
+          })
+        }
+        return undefined
+      } else {
+        set((store) => {
+          store.cart.status = 'loading'
+        })
+        try {
+          const cartData = useAppStore.getState().cart.data
+
+          const lineItemsToUpdate: string[] = []
+
+          for (const lineItem of cartData.lineItemsV2) {
+            const variantId = lineItem.merchandise.id
+            const price = lineItem?.cost?.amountPerQuantity?.amount
+            const merchandisePrice = lineItem?.merchandise?.price?.amount
+
+            if (price !== merchandisePrice) {
+              lineItemsToUpdate.push(variantId)
+            }
+          }
+          const itemsToUpdate = cartData?.lineItems
+            ?.filter((item) => lineItemsToUpdate.includes(item.variantId))
+            .map((item) => {
+              const customAttributes = item?.customAttributes
+                ? {
+                    ...item.customAttributes,
+                    _priceChange: item.price,
+                  }
+                : { _priceChange: item.price }
+              return {
+                id: item.id,
+                merchandiseId: item.variantId,
+                quantity: item.quantity,
+                sellingPlanId: item?.sellingPlanId,
+                attributes: transformCustomAttributesInput(customAttributes),
+              }
+            })
+
+          if (!itemsToUpdate.length) {
+            set((store) => {
+              store.cart.status = 'idle'
+            })
+            return undefined
+          }
+
+          const {
+            status,
+            data: cart,
+            error,
+          } = await cartModule.syncCartPrices(cartId, itemsToUpdate)
+
+          if (status !== 'success') {
+            set((store) => {
+              store.cart.status = 'idle'
+            })
+            return { status, error }
+          }
+
+          const updateCart = get().cart.updateCart
+          updateCart(cart, true)
+
+          set((store) => {
+            store.cart.status = 'idle'
+          })
+          return cart
+        } catch (e) {
+          return get().cart.resetCart()
+        }
+      }
+    },
+
+    updateQuantityForLineItem: async (
+      lineItemId: string | number,
+      quantity: number
+    ) => {
+      const lineItem = get().cart.data.lineItems.find(
+        (lineItem) => lineItem.id === lineItemId
+      )
+      const updateItemsInCartParams = [{ id: lineItemId, quantity }]
+
+      /**
+       * Update quantity is called only for parent items
+       * if id is defined it indicates a parent/child item
+       * increasing quantity of parent should sync quantity for
+       * child as well
+       */
+      const id = lineItem?.customAttributes?.['_id']
+      if (id) {
+        const lineItems = get().cart.data.lineItems
+        for (const lineItem of lineItems) {
+          if (lineItem.customAttributes?.['_parentId'] === id) {
+            updateItemsInCartParams.push({ id: lineItem.id, quantity })
+          }
+        }
+      }
+
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      set((store) => {
+        store.cart.status = 'loading'
+      })
+      const cartId = get().cart.data.id as string
+      const {
+        status,
+        data: cart,
+        error,
+        warning,
+      } = await cartModule.updateItemsInCart(cartId, updateItemsInCartParams)
+      if (status !== 'success') {
+        set((store) => {
+          store.cart.status = 'idle'
+        })
+        console.log({ status, error })
+        return { status, error }
+      }
+      const product: any = get().cart.data.lineItems.find(
+        (lineItem) => lineItem.id === lineItemId
+      )
+      const quantityChange = quantity - product?.quantity
+      get().analytics.sendCartEvent(
+        [
+          {
+            productHandle: product?.productHandle,
+            quantity: Math.abs(quantityChange),
+            variantId: product?.variantId,
+          },
+        ],
+        quantityChange > 0
+          ? AnalyticsEvent.ADD_TO_CART
+          : AnalyticsEvent.REMOVE_FROM_CART
+      )
+      const updateCart = get().cart.updateCart
+      updateCart(cart, true)
+      set((store) => {
+        store.cart.status = 'idle'
+      })
+      if (warning) {
+        return { status, warning }
+      }
+      return cart
+    },
+    updateVariantForLineItem: async (
+      variantId: ProductVariantId,
+      lineItem: LineItem
+    ) => {
+      const lineItemId = lineItem.id
+      const quantity = lineItem.quantity
+      const customAttributes = lineItem.customAttributes
+      const updateItemsInCartParams = [
+        {
+          id: lineItemId,
+          merchandiseId: variantId,
+          quantity,
+          attributes: transformCustomAttributesInput(customAttributes),
+        },
+      ]
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      set((store) => {
+        store.cart.status = 'loading'
+      })
+      const cartId = get().cart.data.id as string
+      const {
+        status,
+        data: cart,
+        error,
+        warning,
+      } = await cartModule.updateItemsInCart(cartId, updateItemsInCartParams)
+      if (status !== 'success') {
+        console.log({ status, error })
+
+        set((store) => {
+          store.cart.status = 'idle'
+        })
+        return { status, error }
+      }
+
+      const updateCart = get().cart.updateCart
+      updateCart(cart, true)
+      set((store) => {
+        store.cart.status = 'idle'
+      })
+
+      return {
+        status,
+        data: cart,
+        warning,
+      }
+    },
+    updateQuantityForLineItems: async (
+      lineItems: Array<{ id: string | number; quantity: number }>,
+      giftItemsInCart?: GiftLineItem[]
+    ) => {
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      set((store) => {
+        store.cart.status = 'loading'
+      })
+      const cartId = get().cart.data.id as string
+      const {
+        status,
+        data: cart,
+        error,
+        warning,
+      } = await cartModule.updateItemsInCart(cartId, lineItems)
+      if (status !== 'success') {
+        set((store) => {
+          store.cart.status = 'idle'
+        })
+        console.error(error)
+        return
+      }
+      // const product: any = get().cart.data.lineItems.find(
+      //   (lineItem) => lineItem.id === variantId
+      // )
+      // const quantityChange = quantity - product?.quantity
+      // get().analytics.sendCartEvent(
+      //   [
+      //     {
+      //       productHandle: product?.productHandle,
+      //       quantity: Math.abs(quantityChange),
+      //       variantId: product?.variantId,
+      //     },
+      //   ],
+      //   quantityChange > 0
+      //     ? AnalyticsEvent.ADD_TO_CART
+      //     : AnalyticsEvent.REMOVE_FROM_CART
+      // )
+      if (giftItemsInCart) {
+        cart.giftItemsInCart = giftItemsInCart
+      }
+      const updateCart = get().cart.updateCart
+      updateCart(cart, true)
+      set((store) => {
+        store.cart.status = 'idle'
+      })
+      if (warning) {
+        return { status, warning }
+      }
+      return cart
+    },
+    updateCustomAttributesForLineItems: async (
+      lineItems: Array<{ id: string; customAttributes: Record<string, string> }>
+    ) => {
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      set((store) => {
+        store.cart.status = 'loading'
+      })
+      const lineItemParams = lineItems.map((lineItem) => ({
+        id: lineItem.id,
+        attributes: transformCustomAttributesInput(lineItem.customAttributes),
+      }))
+      const cartId = get().cart.data.id as string
+      const {
+        status,
+        data: cart,
+        error,
+        warning,
+      } = await cartModule.updateItemsInCart(cartId, lineItemParams)
+      if (status !== 'success') {
+        set((store) => {
+          store.cart.status = 'idle'
+        })
+        console.error(error)
+        return { status: 'error', data: null, error }
+      }
+      const updateCart = get().cart.updateCart
+      updateCart(cart, true)
+      set((store) => {
+        store.cart.status = 'idle'
+      })
+      return { status: 'success', data: cart, warning }
+    },
+    applyDiscountCode: async (code: string) => {
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      let cartId = get().cart.data.id
+      //this is added for coupon auto apply scenario
+      if (!cartId) {
+        const { data: c, status, error } = await cartModule.createEmptyCart([])
+        if (status !== 'success') return
+        set((store) => {
+          store.cart.data.id = c.id
+        })
+        cartId = c.id
+      }
+
+      set((store) => {
+        store.cart.status = 'loading'
+      })
+
+      try {
+        //  adding free gift items to cart first and then applying discount code
+        const applyFreeGifts = get().cart.applyFreeGifts
+        const initialCart = get().cart.data
+
+        await applyFreeGifts(initialCart, code)
+      } catch (e) {
+        console.error('Error while applying free gifts', e)
+      }
+      try {
+        const alreadyAppliedCodes = get()
+          .cart.data.discountCodes.filter(
+            (discount) => discount.applicable && discount.code
+          )
+          .map((discount) => discount.code)
+        const codes = [code, ...alreadyAppliedCodes]
+
+        const enableApplyDiscountV2 =
+          get().config.data?.settings?.['global']?.['enableApplyCouponsV2'] ??
+          false
+
+        const {
+          status,
+          data: cart,
+          error,
+        } = enableApplyDiscountV2
+          ? await cartModule.applyDiscountCodeV2(cartId as string, codes)
+          : await cartModule.applyDiscountCode(cartId as string, [code])
+        if (status !== 'success') {
+          set((store) => {
+            store.cart.status = 'idle'
+          })
+          return
+        }
+
+        const analytics = getAnalyticsProvider(() => useAppStore.getState())
+        analytics.sendEvent(AnalyticsEvent.APPLY_COUPON, {
+          coupon: cart?.discount?.code,
+          isApplicable: cart?.discount?.isApplicable,
+        })
+
+        const updateCart = get().cart.updateCart
+        updateCart(cart, true)
+
+        return cart
+      } catch (e) {
+        set((store) => {
+          store.cart.status = 'idle'
+        })
+        return undefined
+      }
+    },
+    applyDiscountCodeV2: async (code: string) => {
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      let cartId = get().cart.data.id
+      //this is added for coupon auto apply scenario
+      if (!cartId) {
+        const { data: c, status, error } = await cartModule.createEmptyCart([])
+        if (status !== 'success') return
+        set((store) => {
+          store.cart.data.id = c.id
+        })
+        cartId = c.id
+      }
+      set((store) => {
+        store.cart.status = 'loading'
+      })
+
+      try {
+        //  adding free gift items to cart first and then applying discount code
+        const applyFreeGifts = get().cart.applyFreeGifts
+        const initialCart = get().cart.data
+
+        await applyFreeGifts(initialCart, code)
+      } catch (e) {
+        console.error('Error while applying free gifts', e)
+      }
+      try {
+        const alreadyAppliedCodes = get()
+          .cart.data.discountCodes.filter(
+            (discount) => discount.applicable && discount.code
+          )
+          .map((discount) => discount.code)
+        const codes = [code, ...alreadyAppliedCodes]
+        const {
+          status,
+          data: cart,
+          error,
+        } = await cartModule.applyDiscountCodeV2(cartId as string, codes)
+
+        if (status !== 'success') return
+
+        //this needs fix for multi coupons
+        const analytics = getAnalyticsProvider(() => useAppStore.getState())
+        analytics.sendEvent(AnalyticsEvent.APPLY_COUPON, {
+          coupon: cart?.discount?.code,
+          isApplicable: cart?.discount?.isApplicable,
+        })
+
+        const updateCart = get().cart.updateCart
+        updateCart(cart, true)
+
+        return cart
+      } catch (e) {
+        set((store) => {
+          store.cart.status = 'idle'
+        })
+        return undefined
+      }
+    },
+    removeDiscountCode: async (discountCodes?: string[]) => {
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      set((store) => {
+        store.cart.status = 'loading'
+      })
+      const {
+        status,
+        data: cart,
+        error,
+      } = await cartModule.removeDiscountCode(
+        get().cart.data.id as string,
+        discountCodes
+      )
+      if (status !== 'success') {
+        set((store) => {
+          store.cart.status = 'idle'
+        })
+        console.error('error in remove discount code', error)
+        return
+      }
+      const analytics = getAnalyticsProvider(() => useAppStore.getState())
+      analytics.sendEvent(AnalyticsEvent.REMOVE_COUPON, {
+        coupon: get().cart?.data?.discount?.code,
+      })
+      const updateCart = get().cart.updateCart
+      updateCart(cart, true)
+      return cart
+    },
+    removeDiscountCodeV2: async (code: string) => {
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      set((store) => {
+        store.cart.status = 'loading'
+      })
+      const codesToRetain = get()
+        .cart.data.discountCodes.filter(
+          (discount) =>
+            discount.applicable &&
+            discount.code &&
+            discount.code.toLowerCase() !== code.toLowerCase()
+        )
+        .map((discount) => discount.code)
+
+      const {
+        status,
+        data: cart,
+        error,
+      } = await cartModule.removeDiscountCodeV2(
+        get().cart.data.id as string,
+        codesToRetain
+      )
+      if (status !== 'success') return
+      const analytics = getAnalyticsProvider(() => useAppStore.getState())
+      analytics.sendEvent(AnalyticsEvent.REMOVE_COUPON, {
+        coupon: get().cart?.data?.discount?.code,
+      })
+      const updateCart = get().cart.updateCart
+      updateCart(cart, true)
+      return cart
+    },
+    updateShippingAddress: async () => {
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      // formData is the selected address data
+      const address = get().address.getFormData()
+
+      const addressReq = {
+        ...address,
+        country: address?.country?.countryName,
+      }
+      const cartId = get().cart.data.id as string
+      const accessToken = localStorage.getJson<{ accessToken: string }>(
+        'customerAccessToken'
+      )?.accessToken
+
+      if (!cartId) return
+      const {
+        status,
+        data: cart,
+        error,
+      } = await cartModule.updateShippingAddress(addressReq, cartId, {
+        accessToken,
+        countryCode: address?.country?.countryCode,
+      })
+
+      if (status === 'error') {
+        return {
+          status,
+          error,
+        }
+      }
+
+      if (status !== 'success') return
+      if (cart) {
+        get().cart.updateCart(cart, true)
+        const analytics = getAnalyticsProvider(() => useAppStore.getState())
+        await analytics?.sendEvent(AnalyticsEvent.ADD_SHIPPING_INFO)
+      }
+    },
+
+    getItemCount: () => {
+      const items = get().cart.data.lineItems ?? []
+      return calculateItemCount(items)
+    },
+    addGiftItems: async (
+      newEligibleGiftItemsList: GiftItem[][],
+      cart?: Cart
+    ) => {
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      const { id, giftItemsInCart } = cart || get().cart.data
+      const updateCart = get().cart.updateCart
+      const itemsToBeAddedToCart: GiftItem[] = []
+      const eligibleGiftItems: GiftItem[][] = []
+      newEligibleGiftItemsList.forEach((newEligibleGiftItems) => {
+        if (newEligibleGiftItems.length == 1) {
+          itemsToBeAddedToCart.push(newEligibleGiftItems[0])
+        } else {
+          eligibleGiftItems.push([...newEligibleGiftItems])
+        }
+      })
+      const { data: updatedCart, status } = await cartModule.addItemsToCart(
+        `${id}`,
+        itemsToBeAddedToCart.map((item) => {
+          return {
+            variantId: item.variantId,
+            quantity: 1,
+          }
+        })
+      )
+      updatedCart.giftItemsInCart = giftItemsInCart.concat(
+        updatedCart.lineItems.reduce(
+          (filtered: GiftLineItem[], lineItem: LineItem) => {
+            for (let index = 0; index < itemsToBeAddedToCart.length; index++) {
+              if (
+                lineItem.variantId === itemsToBeAddedToCart[index].variantId
+              ) {
+                filtered.push({
+                  ...lineItem,
+                  ruleId: itemsToBeAddedToCart[index].ruleId,
+                })
+                itemsToBeAddedToCart.splice(index, 1)
+                break
+              }
+            }
+            return filtered
+          },
+          []
+        )
+      )
+      updatedCart.eligibleGiftItems = eligibleGiftItems
+      updateCart(updatedCart, false)
+    },
+
+    updateNoteOnCart: async (note: string) => {
+      const cartId = get().cart.data.id as string
+      set((store) => {
+        store.cart.status = 'loading'
+      })
+      try {
+        const appConfig = useAppStore.getState().config.data
+
+        const cartProvider = get().modules.getModule<ICartProvider>('cart')
+
+        const {
+          status,
+          data: cart,
+          error,
+        } = await cartProvider.updateNoteOnCart(cartId, note)
+        if (status === 'success') {
+          get().cart.updateCart(cart, false)
+        } else {
+          set((store) => {
+            store.cart.status = 'idle'
+          })
+          console.error('Failed to update note on cart', error)
+        }
+      } catch (e) {
+        set((store) => {
+          store.cart.status = 'idle'
+        })
+        console.error('Error updating note on cart', e)
+      }
+    },
+    removeGiftItems: async (cart, existingGiftItemsToRemove) => {
+      const removeItemsFromCart = get().cart.removeItemsFromCart
+      const lineItemsToRemove: string[] = []
+      const giftItemsInCart = [...cart.giftItemsInCart]
+      existingGiftItemsToRemove.forEach((existingGiftItem) => {
+        for (let index = 0; index < giftItemsInCart.length; index++) {
+          const giftItemInCart = giftItemsInCart[index]
+          if (existingGiftItem.variantId === giftItemInCart.variantId) {
+            lineItemsToRemove.push(giftItemInCart.id)
+            giftItemsInCart.splice(index, 1)
+            return
+          }
+        }
+      })
+      removeItemsFromCart(lineItemsToRemove, undefined, giftItemsInCart)
+    },
+    // removeGiftItemsV2 allows us to decrease quantity of gift items in cart if the quantity is more than 1
+    // It also allows to remove gift items from cart even if the free gift cart line id does not match with the cart line id
+    removeGiftItemsV2: async (cart, existingGiftItemsToRemove) => {
+      const { removeItemsFromCart, updateQuantityForLineItems, updateCart } =
+        get().cart
+
+      // Create a copy of giftItemsInCart to work with
+      const updatedGiftItemsInCart = cart.giftItemsInCart.slice()
+
+      // Arrays to keep track of items to remove or update
+      const itemsToRemoveFromCart = []
+      const itemsToDecreaseQuantity = []
+
+      // Loop through the list of gift items to remove
+      for (const giftItemToRemove of existingGiftItemsToRemove) {
+        // Find the index of the gift item in the cart
+        const giftItemIndex = updatedGiftItemsInCart.findIndex(
+          (giftItem) => giftItem.variantId === giftItemToRemove.variantId
+        )
+
+        // Skip if the gift item is not found in the cart
+        if (giftItemIndex === -1) continue
+
+        // Remove the gift item from the cart
+        updatedGiftItemsInCart.splice(giftItemIndex, 1)
+
+        // Find the corresponding line item in the cart
+        const lineItem = cart.lineItems?.find(
+          (item) => item.variantId === giftItemToRemove.variantId
+        )
+
+        // Skip if the line item is not found
+        if (!lineItem) continue
+
+        // Determine whether to decrease quantity or remove the line item
+        if (lineItem.quantity > 1) {
+          itemsToDecreaseQuantity.push({
+            id: lineItem.id,
+            quantity: lineItem.quantity - 1,
+          })
+        } else {
+          itemsToRemoveFromCart.push(lineItem.id)
+        }
+      }
+
+      // If there are items to remove, call removeItemsFromCart
+      if (itemsToRemoveFromCart.length > 0) {
+        await removeItemsFromCart(
+          itemsToRemoveFromCart,
+          undefined,
+          updatedGiftItemsInCart
+        )
+        return
+      }
+
+      // If there are items to decrease quantity, call updateQuantityForLineItems
+      if (itemsToDecreaseQuantity.length > 0) {
+        await updateQuantityForLineItems(
+          itemsToDecreaseQuantity,
+          updatedGiftItemsInCart
+        )
+        return
+      }
+
+      // Update the cart with the modified gift items
+      cart.giftItemsInCart = updatedGiftItemsInCart
+      await updateCart(cart, true)
+    },
+    updateCart: (cart: CartData, checkForGift: boolean) => {
+      const globalSettings = get().config.data?.settings?.['global']
+      const enableGroupQuantityRestriction =
+        globalSettings?.enableGroupQuantityRestriction
+      const groupQuantityRestrictions = globalSettings?.groupQuantityRestriction
+
+      cart.giftItemsInCart =
+        cart.giftItemsInCart ?? get().cart.data.giftItemsInCart
+      cart.eligibleGiftItems =
+        cart.eligibleGiftItems ?? get().cart.data.eligibleGiftItems
+
+      // remove gift items from cart which is not present in the cart line items
+      const giftItemsInCart = cart.giftItemsInCart?.filter((giftItem) => {
+        return cart.lineItems?.find(
+          (lineItem) => lineItem.variantId === giftItem.variantId
+        )
+      })
+
+      set((store) => {
+        store.cart.status = 'idle'
+        store.cart.data.lineItems = cart.lineItems
+        store.cart.data.webUrl = cart.webUrl
+        store.cart.data.count = calculateItemCount(cart.lineItems)
+        store.cart.data.id = cart.id
+        store.cart.data.payment = cart.payment
+        store.cart.data.discount = cart.discount
+        store.cart.data.discountCodes = cart.discountCodes || []
+        store.cart.data.eligibleGiftItems = cart.eligibleGiftItems
+        store.cart.data.updatedAt = new Date().getTime()
+        store.cart.data.giftItemsInCart = giftItemsInCart
+        store.cart.data.discountV2 = cart.discountV2
+        store.cart.data.discountCodes = cart.discountCodes
+        store.cart.data.lineItemsV2 = cart.lineItemsV2
+        store.cart.data.note = cart.note
+        store.cart.data.cartAttributes = cart.attributes
+        if (enableGroupQuantityRestriction && groupQuantityRestrictions) {
+          const map = getGroupRestrictionToQuantityMap(
+            cart,
+            groupQuantityRestrictions
+          )
+          store.cart.data.groupRestrictionsToQuantity = map
+        }
+      })
+      for (const lineItem of cart.lineItems) {
+        if (lineItem?.variant?.quantityAvailable) {
+          get().products.updateVariantIdToQuantityAvailable(
+            lineItem.variantId,
+            lineItem.variant.quantityAvailable
+          )
+        }
+      }
+
+      localStorage.set('cart', {
+        id: cart.id,
+        giftItemsInCart: giftItemsInCart,
+      })
+
+      if (checkForGift) {
+        return get().cart.applyFreeGifts(cart)
+      }
+    },
+    applyFreeGifts: async (cart: Cart, couponCode?: string) => {
+      const giftProvider = get().modules.getModule('gift') as GiftsProvider
+
+      cart.giftItemsInCart =
+        cart.giftItemsInCart ?? get().cart.data.giftItemsInCart
+      cart.eligibleGiftItems =
+        cart.eligibleGiftItems ?? get().cart.data.eligibleGiftItems
+
+      if (giftProvider) {
+        const { newEligibleGiftItemsList, existingGiftItemsToRemove } =
+          giftProvider.applyGift(cart, couponCode)
+        if (existingGiftItemsToRemove.length > 0) {
+          if (giftProvider.useGiftV2CartFunctions) {
+            await get().cart.removeGiftItemsV2(cart, existingGiftItemsToRemove)
+          } else {
+            await get().cart.removeGiftItems(cart, existingGiftItemsToRemove)
+          }
+          return
+        }
+        if (newEligibleGiftItemsList.length > 0) {
+          await get().cart.addGiftItems(newEligibleGiftItemsList, cart)
+          return { isGiftAdded: true }
+        }
+      }
+    },
+    resetCart: () => {
+      set((store) => {
+        store.cart.status = 'idle'
+        store.cart.data.lineItems = []
+        store.cart.data.webUrl = ''
+        store.cart.data.count = 0
+        store.cart.data.id = ''
+        store.cart.data.payment = undefined
+        store.cart.data.discount = undefined
+        store.cart.data.eligibleGiftItems = []
+        store.cart.data.giftItemsInCart = []
+        store.cart.data.discountV2 = []
+        store.cart.data.discountCodes = []
+        store.cart.data.lineItemsV2 = []
+        store.cart.data.updatedAt = undefined
+        store.cart.data.groupRestrictionsToQuantity = new Map()
+        store.cart.data.cartAttributes = {}
+        localStorage.set('cart', { id: '' })
+      })
+    },
+    updateCartAttributes: async (attributes) => {
+      const cartId = get().cart.data.id as string
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      set((s) => {
+        s.cart.status = 'loading'
+      })
+      const res = await cartModule.updateCartAttributes(cartId, attributes)
+      set((s) => {
+        s.cart.status = 'idle'
+      })
+      if (res.status === 'success') {
+        const updateCart = get().cart.updateCart
+        updateCart(res.data, false)
+      }
+      return res
+    },
+    clearGiftItems: () => {
+      set((store) => {
+        store.cart.data.eligibleGiftItems = []
+      })
+    },
+    setCartStatus: (status) => {
+      set((store) => {
+        store.cart.status = status
+      })
+    },
+    updateBuyerIdentity: async (buyerIdentity) => {
+      const cartModule = get().modules.getModule<ICartProvider>('cart')
+      const cartId =
+        (get().cart.data.id as string) ||
+        (localStorage.getJson<{ id: string }>('cart')?.id as string)
+
+      if (!cartId) return
+      const res = await cartModule.updateBuyerIdentity(cartId, {
+        ...buyerIdentity,
+        email: buyerIdentity.email?.toLowerCase(),
+        customerAccessToken: buyerIdentity.customerAccessToken,
+      })
+      if (res.status === 'success') get().cart.updateCart(res.data, false)
+      if (res.status === 'success') {
+        get().cart.updateCart(res.data, false)
+      }
+    },
+    updateDummyProductToCart: (lineItems: LineItemToAdd[]) => {
+      if (!lineItems.length) return
+      set((store) => {
+        store.cart.status = 'idle'
+        store.cart.data.lineItems = lineItems
+        store.cart.data.webUrl = ''
+        store.cart.data.count = 1
+        store.cart.data.id = ''
+        store.cart.data.payment = {
+          lineItemsSubTotal: lineItems[0].price,
+          subTotal: lineItems[0].price,
+          taxes: '0',
+          total: lineItems[0].price,
+          currencyCode: lineItems[0].currencyCode,
+          taxesIncluded: true,
+        }
+        store.cart.data.discount = undefined
+        store.cart.data.eligibleGiftItems = []
+        store.cart.data.giftItemsInCart = []
+        store.cart.data.updatedAt = undefined
+        store.cart.data.groupRestrictionsToQuantity = new Map()
+        localStorage.set('cart', { id: '' })
+      })
+    },
+  },
+})
+
+const APPBREW_INSTANCE_ID = 'appbrew-instance-id'
+function calculateItemCount(items: LineItem[]) {
+  let count = 0
+  for (const item of items) {
+    count = count + item.quantity
+  }
+  return count
+}
+
+interface GetShippingAddressInputParams {
+  selectedCountry: Country | null
+  configDefaultAddress: {
+    country: string
+    city: string
+    province: string
+  }
+  localisationAddress: AsyncData<LocalisationUserInfo>
+  userDefaultAddress: Maybe<MailingAddress>
+}
+function getShippingAddress({
+  selectedCountry,
+  configDefaultAddress,
+  localisationAddress,
+  userDefaultAddress,
+}: GetShippingAddressInputParams): {
+  country: string
+  city: string
+  province: string
+} {
+  const defaultValues = {
+    country: 'India',
+    city: '',
+    province: '',
+  }
+  const address = {
+    country: selectedCountry?.name ?? defaultValues.country,
+    city: configDefaultAddress?.city ?? defaultValues.city,
+    province: configDefaultAddress?.province ?? defaultValues.province,
+  }
+
+  // if (localisationAddress.status === 'idle') {
+  //   address.city = 'abcd' //localisationAddress.data.city
+  //   address.province = 'efgh' //localisationAddress.data.province
+  //   address.country = '' //localisationAddress.data.country
+  // }
+  if (userDefaultAddress) {
+    if (userDefaultAddress.city) address.city = userDefaultAddress.city
+    if (userDefaultAddress.province)
+      address.province = userDefaultAddress.province
+    if (userDefaultAddress.country) address.country = userDefaultAddress.country
+  }
+  return address
+}
+
+function transformCustomAttributesInput(attributes: any) {
+  if (Array.isArray(attributes)) {
+    return attributes
+  } else if (attributes) {
+    return Object.keys(attributes).map((key) => {
+      return {
+        key,
+        value: attributes[key],
+      }
+    })
+  } else {
+    return []
+  }
+}
+
+function getGroupRestrictionToQuantityMap(
+  cartData: CartData,
+  groupRestrictions: Record<string, number>
+): Map<string, number> {
+  const map = new Map()
+  if (!cartData) return map
+  if (!cartData.lineItems) return map
+  if (cartData.lineItems.length === 0) return map
+
+  cartData.lineItems.forEach((item) => {
+    item.tags.forEach((tag) => {
+      if (Object.prototype.hasOwnProperty.call(groupRestrictions, tag)) {
+        const currentQuantity = map.get(tag) || 0
+        map.set(tag, currentQuantity + item.quantity)
+      }
+    })
+  })
+  return map
+}
+
+type Image = {
+  id: string
+  height?: number
+  width?: number
+  url: string
+}
+type CustomAttribute = {
+  key: string
+  value: string
+}
+type Price = {
+  amount: number
+  currencyCode: string
+}
+type CartLineCost = {
+  amountPerQuantity: Price
+  compareAtAmountPerQuantity: Price
+  subtotalAmount: Price
+  totalAmount: Price
+}
+type QuantityRule = {
+  increment: number
+  maximum: number | null
+  minimum: number
+}
+type SellingPlanAllocationPriceAdjustment = {
+  compareAtPrice: Price
+  perDeliveryPrice: Price
+  price: Price
+  unitPrice: Price
+}
+type SellingPlan = {
+  checkoutCharge: {
+    type: 'PERCENTAGE' | 'PRICE'
+    value: Price | { percentage: number }
+  }
+  description: string
+  id: string
+  name: string
+  options: Array<{ name: string; value: string }>
+  priceAdjustments: Array<{
+    adjustmentValue:
+      | { adjustmentAmount: Price }
+      | { price: Price }
+      | { adjustmentPercentage: number }
+    orderCount: number
+  }>
+  recurringDeliveries: boolean
+}
+type SellingPlanAllocation = {
+  checkoutChargeAmount: Price
+  priceAdjustments: Array<SellingPlanAllocationPriceAdjustment>
+  remainingBalanceChargeAmount: Price
+  sellingPlan: Array<SellingPlan>
+}
+
+export type BaseLineItemV2 = {
+  type: 'BASE' | 'FREE_GIFT' | 'SUBSCRIPTION'
+  id: string
+  attributes: Array<CustomAttribute>
+  cost: CartLineCost
+  discountAllocations: Array<DiscountAllocationBase>
+  quantity: number
+  merchandise: {
+    id: ProductVariantId
+    title: string
+    image: Image
+    availableForSale: boolean
+    currentlyNotInStock: boolean
+    quantityAvailable: number
+    quantityRule: QuantityRule
+    requiresShipping: boolean
+    selectedOptions: Array<{ name: string; value: string }>
+    sku: string
+    taxable: string
+    price: Price
+    compareAtPrice: Price
+    product: {
+      id: string
+      title: string
+      handle: string
+      tags: Set<string>
+    }
+  }
+  sellingPlanAllocations: Array<SellingPlanAllocation> | null
+}
+export type LineItemV2 = BaseLineItemV2[] | []
+
+//Cart type as received by updateCart
+
+type SelectedOption = {
+  name: string
+  value: string
+  __typename: string
+}
+
+type Variant = {
+  id: string
+  selectedOptions: SelectedOption[]
+  quantityAvailable?: number
+}
+
+type LineItem = {
+  currencyCode: string
+  id: string
+  productId: string
+  productHandle: string
+  tags: string[]
+  image: string
+  price: string
+  priceAfterDiscount: string
+  quantity: number
+  title: string
+  variantId: string
+  originalPrice: string
+  customAttributes: Record<string, unknown>
+  variant: Variant
+}
+
+type Payment = {
+  lineItemsSubTotal: string
+  subTotal: string
+  taxes: string
+  total: string
+  currencyCode: string
+  taxesIncluded: boolean
+}
+
+type CartData = {
+  id: string
+  completedAt: string | null
+  order: unknown | null
+  lineItems: LineItem[]
+  webUrl: string
+  payment: Payment
+  discount: Record<string, unknown>
+  giftItemsInCart: unknown[]
+  eligibleGiftItems: unknown[]
+  discountCodes: string[]
+}
+
+function setUserAddressFromLocalization() {
+  const state = useAppStore.getState()
+  const addressSlice = state.address
+  const userDetails = state.user.data.userDetails
+  const isMultiCurrencyEnabled =
+    state.config.data?.settings?.['global']?.enableMultiCurrencyV4
+  if (!isMultiCurrencyEnabled) return
+  if (userDetails.status !== 'idle') return
+
+  const country = state.localization.data.selectedCountry
+
+  const addressList = userDetails.data.addresses
+  let localeCountryNotInAddressList = true
+
+  if (country?.name && addressList?.edges?.length) {
+    for (const address of addressList.edges) {
+      if (address.node && address.node.countryCodeV2 === country.isoCode) {
+        localeCountryNotInAddressList = false
+        addressSlice.changeAddress(
+          address.node.id,
+          address.node as Partial<AddressItem>
+        )
+
+        // first match
+        break
+      }
+    }
+  }
+
+  if (localeCountryNotInAddressList) {
+    addressSlice.changeAddress('', undefined)
+  }
+}