@abra-promotions/webhooks-for-tapcart 1.0.1

package/dist/index.esm.js

@@ -0,0 +1,3145 @@
+import * as React from 'react';
+import React__default, { useState, useEffect } from 'react';
+import { productGidFromId, getIdFromGid } from '@tapcart/mobile-components';
+
+function useAbra({ useTapcart, tapcartData }) {
+  const Tapcart = useTapcart();
+  const [activePromotion, setActivePromotion] = React__default.useState(undefined);
+  const renderCountRef = React__default.useRef(0);
+  const logRef = React__default.useRef([]);
+  const actions = Tapcart.actions;
+  const variables = Tapcart.variables;
+  const { storeFrontAccessToken, storeUrl } =
+    tapcartData?.integrations?.find((x) => x.name === "abra-promotions") ?? {};
+
+  // Stable GraphQL fragment and functions
+  const PRODUCT_FRAGMENT = React__default.useMemo(
+    () => `
+    id
+    handle
+    variants(first: 100) {
+      edges {
+        node {
+          id
+          handle: title
+          price {
+            amount
+            currencyCode
+          }
+        }
+      }
+    }
+  `,
+    [],
+  );
+
+  const generateProductsQuery = React__default.useCallback(
+    (ids) => {
+      const productQueries = ids
+        .map(
+          (id, index) =>
+            `product_${index}: product(id: "${productGidFromId(id)}") {
+        ${PRODUCT_FRAGMENT}
+      }`,
+        )
+        .join("\n  ");
+
+      return `
+      query Products {
+        ${productQueries}
+      }
+    `;
+    },
+    [PRODUCT_FRAGMENT],
+  );
+
+  const graphqlDefaultBody = React__default.useCallback(
+    (query, variables, storefrontAccessToken) => {
+      return {
+        async: true,
+        crossDomain: true,
+        method: "POST",
+        headers: {
+          "X-Shopify-Storefront-Access-Token": storefrontAccessToken,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          query,
+          variables,
+        }),
+      };
+    },
+    [],
+  );
+
+  const fetchProducts = React__default.useCallback(
+    async (ids, storeUrl, storefrontAccessToken) => {
+      if (!storeUrl || !storefrontAccessToken) {
+        return { error: "Missing required configuration" };
+      }
+
+      if (!ids || ids.length === 0) {
+        return { data: [], error: "No ids" };
+      }
+
+      const GRAPHQL_URL = `https://${storeUrl}/api/2024-04/graphql.json`;
+      const query = generateProductsQuery(ids);
+
+      try {
+        const response = await fetch(
+          GRAPHQL_URL,
+          graphqlDefaultBody(query, {}, storefrontAccessToken),
+        );
+
+        if (response?.ok) {
+          const responseBody = await response.json();
+          const data = responseBody?.data;
+
+          if (!data) {
+            return { data: [], error: "No data" };
+          }
+
+          const products = Object.values(data).filter((item) => item !== null);
+
+          return {
+            data: products,
+            error: null,
+          };
+        }
+
+        const error = await response.text();
+        return { data: [], error: error };
+      } catch (err) {
+        return { data: [], error: err.message };
+      }
+    },
+    [generateProductsQuery, graphqlDefaultBody],
+  );
+
+  const useProductsCustom = React__default.useCallback(
+    ({ ids, storeUrl, storeFrontAccessToken }) => {
+      const [products, setProducts] = React__default.useState([]);
+      const [loading, setLoading] = React__default.useState(true);
+      const [error, setError] = React__default.useState(null);
+
+      React__default.useEffect(() => {
+        const fetchData = async () => {
+          if (!storeUrl || !storeFrontAccessToken) {
+            if (!storeUrl) {
+              setError("no store url");
+            }
+            if (!storeFrontAccessToken) {
+              setError("no store front access token");
+            }
+            setProducts([]);
+            setLoading(false);
+            return;
+          }
+
+          if (!ids || ids.length === 0) {
+            setProducts([]);
+            setLoading(false);
+            return;
+          }
+
+          const result = await fetchProducts(
+            ids,
+            storeUrl,
+            storeFrontAccessToken,
+          );
+
+          try {
+            if (result.data && result.data.length > 0) {
+              const formattedProducts = result?.data?.map((product) => ({
+                id: getIdFromGid(product.id),
+                handle: product?.handle,
+                variants: product?.variants?.edges?.map((variant) => ({
+                  id: getIdFromGid(variant?.node?.id),
+                  handle: variant?.node?.handle,
+                  price: variant?.node?.price,
+                })),
+              }));
+              setProducts(formattedProducts);
+              setError(result.error);
+            } else {
+              setProducts([]);
+              setError(result.error);
+            }
+          } catch (error) {
+            setError(error.message);
+          }
+
+          setLoading(false);
+        };
+
+        fetchData();
+      }, [ids, storeUrl, storeFrontAccessToken, fetchProducts]);
+
+      return { products, loading, error };
+    },
+    [fetchProducts],
+  );
+
+  // Stable logging function that doesn't cause re-renders
+  const log = React__default.useCallback((message, data = null) => {
+    const timestamp = new Date().toISOString();
+    const logEntry = {
+      timestamp,
+      message,
+      data: data ? JSON.parse(JSON.stringify(data)) : null,
+      renderCount: renderCountRef.current,
+    };
+    logRef.current.push(logEntry);
+
+    // Keep only last 50 logs to prevent memory issues
+    if (logRef.current.length > 50) {
+      logRef.current = logRef.current.slice(-50);
+    }
+  }, []);
+
+  // Create stable cart items reference to prevent infinite recreations
+  const stableCartItems = React__default.useMemo(() => {
+    const currentCartItems = variables?.cart?.items ?? [];
+
+    if (!currentCartItems || currentCartItems.length === 0) {
+      return [];
+    }
+
+    const mappedItems = currentCartItems.map((item) => ({
+      productId: item.productId,
+      variantId: item.variantId,
+      quantity: item.quantity,
+    }));
+
+    return mappedItems;
+  }, [
+    (variables?.cart?.items || [])
+      ?.map((item) => `${item.productId}-${item.variantId}-${item.quantity}`)
+      ?.join(","),
+  ]);
+
+  const ids = React__default.useMemo(
+    () => (stableCartItems ?? []).map((item) => item.productId),
+    [stableCartItems],
+  );
+
+  const { products: cartItems } = useProductsCustom({
+    ids,
+    storeUrl: storeUrl,
+    storeFrontAccessToken: storeFrontAccessToken,
+  });
+
+  // Render limiter to prevent infinite recreations
+  renderCountRef.current += 1;
+
+  // Create stable cart reference to prevent infinite recreations
+  const stableCart = React__default.useMemo(() => {
+    if (!variables?.cart) {
+      return null;
+    }
+
+    if (!cartItems || cartItems.length === 0) {
+      return variables.cart;
+    }
+
+    const processedItems = (stableCartItems || []).map((item) => {
+      const _cartItem = cartItems?.find(
+        (cartItem) => getIdFromGid(cartItem?.id) === item.productId,
+      );
+      if (!_cartItem) {
+        return item;
+      }
+      const _variant = _cartItem?.variants?.find(
+        (variant) => getIdFromGid(variant?.id) === item?.variantId,
+      );
+      if (!_variant) {
+        return item;
+      }
+
+      const processedItem = {
+        ...item,
+        handle: _cartItem?.handle,
+        price: _variant?.price,
+      };
+
+      return processedItem;
+    });
+
+    const result = {
+      ...variables.cart,
+      items: processedItems,
+    };
+
+    return result;
+  }, [stableCartItems, cartItems]);
+
+  const getDiscountForProductDiscount = ({
+    targetDiscount,
+    handle,
+    variantId,
+    selectedVariant,
+  }) => {
+    const isProductEntitledForProductDiscount = () => {
+      if (targetDiscount.entitled?.all) {
+        return true;
+      }
+
+      if (targetDiscount.entitled?.variants) {
+        if (variantId && targetDiscount.entitled.variants.includes(variantId)) {
+          return true;
+        }
+      }
+
+      if (targetDiscount.entitled?.products) {
+        if (handle && targetDiscount.entitled.products.includes(handle)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    if (!isProductEntitledForProductDiscount()) return 0;
+
+    if (targetDiscount.discountValue?.type === "DiscountAmount") {
+      return targetDiscount.discountValue.discountAmount.cents / 100;
+    } else if (targetDiscount.discountValue?.type === "DiscountPercentage") {
+      return (
+        parseFloat(selectedVariant.price.amount) *
+        targetDiscount.discountValue.percentage
+      );
+    }
+  };
+
+  const getDiscountForMultiValueCollection = ({
+    targetDiscount,
+    handle,
+    selectedVariant,
+  }) => {
+    if (
+      !targetDiscount?.discountValue?.productDiscounts ||
+      targetDiscount.discountValue.productDiscounts.length === 0
+    )
+      return 0;
+
+    const entitledProductDiscounts =
+      targetDiscount.discountValue.productDiscounts.filter((discount) =>
+        (discount.products ?? []).includes(handle),
+      ) || [];
+
+    return entitledProductDiscounts.reduce((max, discountValue) => {
+      let discountAmount = 0;
+
+      if (discountValue.value.type === "DiscountAmount") {
+        discountAmount = discountValue.value.discountAmount.cents / 100;
+      } else if (discountValue.value.type === "DiscountPercentage") {
+        discountAmount =
+          parseFloat(selectedVariant.price.amount) *
+          (discountValue.value.percentage / 100);
+      }
+
+      return Math.max(max, discountAmount);
+    }, 0);
+  };
+
+  const getDiscountForMultiValueProduct = ({
+    targetDiscount,
+    variantId,
+    selectedVariant,
+  }) => {
+    if (!variantId) return 0;
+    if (
+      !targetDiscount?.discountValue?.variantDiscounts ||
+      targetDiscount?.discountValue?.variantDiscounts.length === 0
+    )
+      return 0;
+
+    const entitledVariantDiscounts =
+      targetDiscount.discountValue.variantDiscounts.filter((discount) =>
+        (discount.variants ?? []).includes(variantId),
+      ) ?? [];
+
+    return entitledVariantDiscounts.reduce((max, discountValue) => {
+      let discountAmount = 0;
+
+      if (discountValue.value.type === "DiscountAmount") {
+        discountAmount = discountValue.value.discountAmount.cents / 100;
+      } else if (discountValue.value.type === "DiscountPercentage") {
+        discountAmount =
+          parseFloat(selectedVariant.price.amount) *
+          (discountValue.value.percentage / 100);
+      }
+
+      return Math.max(max, discountAmount);
+    }, 0);
+  };
+
+  const getDiscountForTierDiscount = ({
+    targetDiscount,
+    handle,
+    variantId,
+    product,
+    selectedVariant,
+    cart,
+  }) => {
+    if (!targetDiscount.discountValue?.tiers) return 0;
+    if (targetDiscount.discountValue?.tiersType === "FREE_GIFT") return 0;
+
+    const currentCollectionHandle = product.sourceCollection?.handle;
+    const isProductEntitledToTierDiscount = () => {
+      if (targetDiscount.discountValue?.entitled?.all) {
+        return true;
+      }
+
+      if (targetDiscount.discountValue?.entitled?.collections) {
+        if (
+          currentCollectionHandle &&
+          targetDiscount.discountValue?.entitled?.collections.includes(
+            currentCollectionHandle,
+          )
+        ) {
+          return true;
+        }
+      }
+
+      if (targetDiscount.discountValue?.entitled?.products) {
+        if (
+          handle &&
+          targetDiscount.discountValue?.entitled?.products.includes(handle)
+        ) {
+          return true;
+        }
+      }
+
+      if (targetDiscount.discountValue?.entitled?.variants) {
+        if (
+          variantId &&
+          targetDiscount.discountValue?.entitled?.variants.includes(variantId)
+        ) {
+          return true;
+        }
+      }
+
+      return false;
+    };
+    if (!isProductEntitledToTierDiscount()) return 0;
+
+    const getBiggestEligibleTier = () => {
+      const isItemEligibleWithSelectedPurchaseType = (item, discount) => {
+        if (
+          discount.appliesOnSubscription &&
+          !discount.appliesOnOneTimePurchase
+        ) {
+          return item.sellingPlanAllocation; //TODO Verify correct structure of selling plan
+        } else if (
+          !discount.appliesOnSubscription &&
+          discount.appliesOnOneTimePurchase
+        ) {
+          return !item.sellingPlanAllocation?.name;
+        } else {
+          return true;
+        }
+      };
+      const isCartItemEntitledToGiveDiscount = (item) => {
+        if (!targetDiscount || !targetDiscount.entitled) {
+          return false;
+        }
+
+        if (targetDiscount.entitled.all) {
+          return isItemEligibleWithSelectedPurchaseType(item, targetDiscount);
+        }
+
+        if (targetDiscount.entitled.variants) {
+          if (
+            targetDiscount.entitled.variants?.includes(
+              item.variantId.toString(),
+            )
+          ) {
+            return isItemEligibleWithSelectedPurchaseType(item, targetDiscount);
+          }
+        }
+
+        if (targetDiscount.entitled.products) {
+          if (targetDiscount.entitled.products?.includes(item.handle)) {
+            return isItemEligibleWithSelectedPurchaseType(item, targetDiscount);
+          }
+        }
+
+        return false;
+      };
+
+      const getEntitledQuantityAndTotal = () => {
+        const entitledItems = (cart?.items || []).filter((item) => {
+          return isCartItemEntitledToGiveDiscount(item);
+        });
+
+        const { entitledQuantity, entitledTotal } = entitledItems.reduce(
+          (acc, item) => {
+            acc.entitledQuantity += item.quantity;
+            acc.entitledTotal +=
+              parseFloat((item.price?.amount ?? 0) * 100) * item.quantity;
+
+            return acc;
+          },
+          { entitledQuantity: 0, entitledTotal: 0 },
+        );
+
+        return { entitledQuantity, entitledTotal };
+      };
+
+      const isPrerequisiteValid = (prerequisite, quantity, subtotal) => {
+        if (prerequisite?.minimumRequirement?.greaterThanOrEqualToQuantity) {
+          if (
+            Number(quantity) <
+            Number(prerequisite.minimumRequirement.greaterThanOrEqualToQuantity)
+          ) {
+            return false;
+          }
+        }
+
+        if (prerequisite?.minimumRequirement?.greaterThanOrEqualToSubtotal) {
+          if (
+            subtotal <
+            prerequisite.minimumRequirement.greaterThanOrEqualToSubtotal.cents
+          ) {
+            return false;
+          }
+        }
+
+        return true;
+      };
+
+      const { entitledQuantity, entitledTotal } = getEntitledQuantityAndTotal();
+
+      let currentBiggestTierIndex = -1;
+      for (let i = 0; i < targetDiscount.discountValue?.tiers?.length; i++) {
+        const currentTier = targetDiscount.discountValue.tiers[i];
+        if (
+          isPrerequisiteValid(
+            currentTier.prerequisite,
+            entitledQuantity,
+            entitledTotal,
+          )
+        ) {
+          currentBiggestTierIndex = i;
+        } else {
+          break;
+        }
+      }
+      return currentBiggestTierIndex;
+    };
+    const biggestEligibleTierIndex = getBiggestEligibleTier();
+
+    if (biggestEligibleTierIndex < 0) return 0;
+
+    const biggestEligibleTier =
+      targetDiscount.discountValue.tiers[biggestEligibleTierIndex];
+    if (!biggestEligibleTier || !biggestEligibleTier.value) return 0;
+
+    if (
+      biggestEligibleTier.value.type === "DiscountPercentage" &&
+      biggestEligibleTier.value.percentage
+    ) {
+      const discountAmount =
+        parseFloat(selectedVariant.price.amount) *
+        (biggestEligibleTier.value.percentage / 100);
+
+      return discountAmount;
+    }
+  };
+
+  const getDiscountForVolumeDiscount = ({
+    targetDiscount,
+    handle,
+    variantId,
+    product,
+    selectedVariant,
+    cart,
+  }) => {
+    if (!targetDiscount.discountValue?.tiers) return 0;
+    if (targetDiscount.discountValue?.tiersType === "FREE_GIFT") return 0;
+
+    const currentCollectionHandle = product.sourceCollection?.handle;
+    const isProductEntitledToVolumeDiscount = () => {
+      if (targetDiscount.discountValue?.entitled?.all) {
+        return true;
+      }
+
+      if (targetDiscount.discountValue?.entitled?.collections) {
+        if (
+          currentCollectionHandle &&
+          targetDiscount.discountValue?.entitled?.collections.includes(
+            currentCollectionHandle,
+          )
+        ) {
+          return true;
+        }
+      }
+
+      if (targetDiscount?.entitled?.products) {
+        if (handle && targetDiscount?.entitled?.products.includes(handle)) {
+          return true;
+        }
+      }
+
+      if (targetDiscount?.entitled?.variants) {
+        if (
+          variantId &&
+          targetDiscount?.entitled?.variants.includes(variantId)
+        ) {
+          return true;
+        }
+      }
+
+      return false;
+    };
+    if (!isProductEntitledToVolumeDiscount()) return 0;
+
+    const getBiggestEligibleTier = () => {
+      const isItemEligibleWithSelectedPurchaseType = (item, discount) => {
+        if (
+          discount.appliesOnSubscription &&
+          !discount.appliesOnOneTimePurchase
+        ) {
+          return item.sellingPlanAllocation; //TODO Verify correct structure of selling plan
+        } else if (
+          !discount.appliesOnSubscription &&
+          discount.appliesOnOneTimePurchase
+        ) {
+          return !item.sellingPlanAllocation?.name;
+        } else {
+          return true;
+        }
+      };
+      const isCartItemEntitledToGiveDiscount = (item) => {
+        if (!targetDiscount || !targetDiscount.entitled) {
+          return false;
+        }
+
+        if (targetDiscount.entitled.all) {
+          return isItemEligibleWithSelectedPurchaseType(item, targetDiscount);
+        }
+
+        if (targetDiscount.entitled.variants) {
+          if (
+            targetDiscount.entitled.variants?.includes(
+              item.variantId.toString(),
+            )
+          ) {
+            return isItemEligibleWithSelectedPurchaseType(item, targetDiscount);
+          }
+        }
+
+        if (targetDiscount.entitled.products) {
+          if (targetDiscount.entitled.products?.includes(item.handle)) {
+            return isItemEligibleWithSelectedPurchaseType(item, targetDiscount);
+          }
+        }
+
+        return false;
+      };
+
+      const getEntitledQuantityAndTotal = () => {
+        const entitledItems = (cart?.items || []).filter((item) => {
+          return isCartItemEntitledToGiveDiscount(item);
+        });
+
+        const { entitledQuantity, entitledTotal } = entitledItems.reduce(
+          (acc, item) => {
+            acc.entitledQuantity += item.quantity;
+            acc.entitledTotal +=
+              parseFloat((item.price?.amount ?? 0) * 100) * item.quantity;
+
+            return acc;
+          },
+          { entitledQuantity: 0, entitledTotal: 0 },
+        );
+
+        return { entitledQuantity, entitledTotal };
+      };
+
+      const isPrerequisiteValid = (prerequisite, quantity, subtotal) => {
+        if (prerequisite?.minimumRequirement?.greaterThanOrEqualToQuantity) {
+          if (
+            Number(quantity) <
+            Number(prerequisite.minimumRequirement.greaterThanOrEqualToQuantity)
+          ) {
+            return false;
+          }
+        }
+
+        if (prerequisite?.minimumRequirement?.greaterThanOrEqualToSubtotal) {
+          if (
+            subtotal <
+            prerequisite.minimumRequirement.greaterThanOrEqualToSubtotal.cents
+          ) {
+            return false;
+          }
+        }
+
+        return true;
+      };
+
+      const { entitledQuantity, entitledTotal } = getEntitledQuantityAndTotal();
+
+      let currentBiggestTierIndex = -1;
+      for (let i = 0; i < targetDiscount.discountValue?.tiers?.length; i++) {
+        const currentTier = targetDiscount.discountValue.tiers[i];
+        if (
+          isPrerequisiteValid(
+            currentTier.prerequisite,
+            entitledQuantity,
+            entitledTotal,
+          )
+        ) {
+          currentBiggestTierIndex = i;
+        } else {
+          break;
+        }
+      }
+      return currentBiggestTierIndex;
+    };
+    const biggestEligibleTierIndex = getBiggestEligibleTier();
+
+    if (biggestEligibleTierIndex < 0) return 0;
+
+    const biggestEligibleTier =
+      targetDiscount.discountValue.tiers[biggestEligibleTierIndex];
+    if (!biggestEligibleTier || !biggestEligibleTier.value) return 0;
+
+    if (
+      biggestEligibleTier.value.type === "DiscountPercentage" &&
+      biggestEligibleTier.value.percentage
+    ) {
+      const discountAmount =
+        parseFloat(selectedVariant.price.amount) *
+        (biggestEligibleTier.value.percentage / 100);
+
+      return discountAmount;
+    }
+  };
+
+  const getDiscountForMultiEffectTiers = ({
+    targetDiscount,
+    handle,
+    variantId,
+    product,
+    selectedVariant,
+    cart,
+    log,
+  }) => {
+    const isProductEntitledToDiscount = (discount) => {
+      if (discount.entitled?.all) {
+        return true;
+      }
+
+      if (discount.entitled?.collections) {
+        if (
+          currentCollectionHandle &&
+          discount.entitled?.collections.includes(currentCollectionHandle)
+        ) {
+          return true;
+        }
+      }
+
+      if (discount.entitled?.products) {
+        if (handle && discount.entitled?.products.includes(handle)) {
+          return true;
+        }
+      }
+
+      if (discount.entitled?.variants) {
+        if (variantId && discount.entitled?.variants.includes(variantId)) {
+          return true;
+        }
+      }
+
+      return false;
+    };
+    const getBiggestEligibleTier = () => {
+      const isItemEligibleWithSelectedPurchaseType = (item, discount) => {
+        if (
+          discount.appliesOnSubscription &&
+          !discount.appliesOnOneTimePurchase
+        ) {
+          return item.sellingPlanAllocation; //TODO Verify correct structure of selling plan
+        } else if (
+          !discount.appliesOnSubscription &&
+          discount.appliesOnOneTimePurchase
+        ) {
+          return !item.sellingPlanAllocation?.name;
+        } else {
+          return true;
+        }
+      };
+      const isCartItemEntitledToGiveDiscount = (item) => {
+        if (!targetDiscount || !targetDiscount.entitled) {
+          return false;
+        }
+
+        if (targetDiscount.entitled.all) {
+          return isItemEligibleWithSelectedPurchaseType(item, targetDiscount);
+        }
+
+        if (targetDiscount.entitled.variants) {
+          if (
+            targetDiscount.entitled.variants?.includes(
+              item.variantId.toString(),
+            )
+          ) {
+            return isItemEligibleWithSelectedPurchaseType(item, targetDiscount);
+          }
+        }
+
+        if (targetDiscount.entitled.products) {
+          return isItemEligibleWithSelectedPurchaseType(item, targetDiscount);
+        }
+
+        return false;
+      };
+
+      const getEntitledQuantityAndTotal = () => {
+        const entitledItems = (cart?.items || []).filter((item) => {
+          return isCartItemEntitledToGiveDiscount(item);
+        });
+
+        const { entitledQuantity, entitledTotal } = entitledItems.reduce(
+          (acc, item) => {
+            acc.entitledQuantity += item.quantity;
+            acc.entitledTotal +=
+              parseFloat((item.price?.amount ?? 0) * 100) * item.quantity;
+
+            return acc;
+          },
+          { entitledQuantity: 0, entitledTotal: 0 },
+        );
+
+        return { entitledQuantity, entitledTotal };
+      };
+
+      const isPrerequisiteValid = (prerequisite, quantity, subtotal) => {
+        if (prerequisite?.minimumRequirement?.greaterThanOrEqualToQuantity) {
+          if (
+            Number(quantity) <
+            Number(prerequisite.minimumRequirement.greaterThanOrEqualToQuantity)
+          ) {
+            return false;
+          }
+        }
+
+        if (prerequisite?.minimumRequirement?.greaterThanOrEqualToSubtotal) {
+          if (
+            subtotal <
+            prerequisite.minimumRequirement.greaterThanOrEqualToSubtotal.cents
+          ) {
+            return false;
+          }
+        }
+
+        return true;
+      };
+
+      log("getEntitledQuantityAndTotal");
+      const { entitledQuantity, entitledTotal } = getEntitledQuantityAndTotal();
+
+      log("getEntitledQuantityAndTotal", { entitledQuantity, entitledTotal });
+
+      let currentBiggestTierIndex = -1;
+      for (let i = 0; i < targetDiscount.discountValue?.tiers?.length; i++) {
+        const currentTier = targetDiscount.discountValue.tiers[i];
+        if (
+          isPrerequisiteValid(
+            currentTier.prerequisite,
+            entitledQuantity,
+            entitledTotal,
+          )
+        ) {
+          currentBiggestTierIndex = i;
+        } else {
+          break;
+        }
+      }
+      return currentBiggestTierIndex;
+    };
+
+    if (
+      !targetDiscount.discountValue?.tiers ||
+      targetDiscount.discountValue?.tiers.length === 0
+    )
+      return 0;
+
+    log("getBiggestEligibleTier");
+    const currentCollectionHandle = product?.sourceCollection?.handle;
+    const biggestEligibleTierIndex = getBiggestEligibleTier();
+    log("getBiggestEligibleTier", { biggestEligibleTierIndex });
+
+    if (biggestEligibleTierIndex < 0) return 0;
+
+    const productDiscountsAvailableOnTier =
+      targetDiscount.discountValue.tiers
+        .slice(0, biggestEligibleTierIndex + 1)
+        ?.filter((tier) =>
+          tier.discounts.some(
+            (discount) => discount.type === "ProductDiscount",
+          ),
+        )
+        ?.flatMap(
+          (tier) =>
+            tier.discounts.find(
+              (discount) => discount.type === "ProductDiscount",
+            )?.value ?? [],
+        ) ?? [];
+
+    const eligibleProductDiscounts = productDiscountsAvailableOnTier.filter(
+      (discount) => isProductEntitledToDiscount(discount),
+    );
+
+    const maxDiscountAmount = eligibleProductDiscounts.reduce(
+      (max, discount) => {
+        let discountAmount = 0;
+        if (discount.value.type === "DiscountAmount") {
+          discountAmount = parseFloat(discount.value.discountAmount.amount);
+        } else if (discount.value.type === "DiscountPercentage") {
+          discountAmount =
+            parseFloat(selectedVariant.price.amount) *
+            (discount.value.percentage / 100);
+        }
+        return Math.max(max, discountAmount);
+      },
+      0,
+    );
+    return maxDiscountAmount;
+  };
+
+  const getDiscountValueForDiscount = ({
+    product,
+    selectedVariant,
+    cart,
+    discount,
+    log,
+  }) => {
+    log("getDiscountValueForDiscount");
+    const handle = product?.handle;
+    log("handle", { handle });
+    log("crudeva", { selectedVariant });
+    const variantId = getIdFromGid(selectedVariant?.id);
+    log("variantId", { variantId });
+
+    if (!handle || !discount) return 0;
+    log("handle and discount exist");
+
+    if (discount.discountValue?.type === "DiscountCodeBxgy") {
+      return 0;
+    }
+
+    if (discount.discountValue?.type === "Gift") {
+      return 0;
+    }
+
+    if (discount.discountValue?.type === "DiscountMultiValueProduct") {
+      return getDiscountForMultiValueProduct({
+        targetDiscount: discount,
+        variantId,
+        selectedVariant,
+      });
+    }
+
+    if (discount.discountValue?.type === "DiscountMultiValueCollection") {
+      return getDiscountForMultiValueCollection({
+        targetDiscount: discount,
+        handle,
+        selectedVariant,
+      });
+    }
+
+    if (discount.discountValue?.type === "TieredDiscount") {
+      return getDiscountForTierDiscount({
+        targetDiscount: discount,
+        handle,
+        variantId,
+        product,
+        selectedVariant,
+        cart,
+      });
+    }
+
+    if (discount.discountValue?.type === "VolumeDiscount") {
+      return getDiscountForVolumeDiscount({
+        targetDiscount: discount,
+        handle,
+        variantId,
+        product,
+        selectedVariant,
+        cart,
+      });
+    }
+
+    if (discount.discountValue?.type === "CollectionOrderDiscount") {
+      return 0;
+    }
+
+    if (discount.discountValue?.type === "MultiEffectTiers") {
+      log("getDiscountForMultiEffectTiers");
+      return getDiscountForMultiEffectTiers({
+        targetDiscount: discount,
+        handle,
+        variantId,
+        product,
+        selectedVariant,
+        cart,
+        log,
+      });
+    }
+
+    if (discount.discountValue?.type === "ProductDiscount") {
+      return getDiscountForProductDiscount({
+        targetDiscount: discount,
+        handle,
+        variantId,
+        selectedVariant,
+      });
+    }
+
+    if (discount.discountClass === "ORDER") {
+      return 0;
+    }
+    if (discount.discountClass === "SHIPPING") {
+      return 0;
+    }
+
+    if (discount.discountClass === "PRODUCT") {
+      return getDiscountForProductDiscount({
+        targetDiscount: discount,
+        handle,
+        variantId,
+        selectedVariant,
+      });
+    }
+
+    return 0;
+  };
+
+  const getBiggestDiscount = ({ product, selectedVariant, cart, log }) => {
+    const discounts = Object.values(activePromotion?.discounts ?? []);
+    log("Calculating biggest discount", {
+      discountCount: discounts.length,
+      productId: product?.handle,
+      collectionId: product?.sourceCollection?.handle,
+      variantId: selectedVariant?.id,
+    });
+
+    const biggestDiscount = discounts.reduce((max, discount) => {
+      const discountValue = getDiscountValueForDiscount({
+        product,
+        selectedVariant,
+        cart,
+        discount,
+        log,
+      });
+      log("Discount calculated", {
+        discountType: discount.discountValue?.type,
+        discountValue,
+        maxSoFar: max,
+      });
+      return Math.max(max, discountValue);
+    }, 0);
+
+    log("Final biggest discount", { biggestDiscount });
+    return biggestDiscount;
+  };
+
+  const parsePromotionIfActive = (vaultActivePromotion) => {
+    let promotion = JSON.parse(vaultActivePromotion ?? "{}");
+    if (!promotion.startsAt || !promotion.status || !promotion.title)
+      return undefined;
+    const now = new Date();
+    const startsAt = new Date(promotion.startsAt);
+    const endsAt = promotion.endsAt ? new Date(promotion.endsAt) : null;
+
+    if (
+      (promotion.status === "ACTIVE" || promotion.status === "SCHEDULED") &&
+      now >= startsAt &&
+      (!endsAt || now <= endsAt)
+    ) {
+      return promotion;
+    }
+
+    return undefined;
+  };
+
+  React__default.useEffect(() => {
+    async function initializeVault() {
+      try {
+        if (!actions?.vault) return;
+
+        log("Initializing vault");
+        const vault = await actions.vault.initialize("abra", "global");
+        const vaultActivePromotion = await vault.get("active-promotion");
+        log("Vault initialized, active promotion retrieved", {
+          vaultActivePromotion,
+        });
+        setActivePromotion(parsePromotionIfActive(vaultActivePromotion));
+
+        vault.observe(
+          "active-promotion",
+          (newPromotionValue) => {
+            log("Vault promotion changed", { newPromotionValue });
+            setActivePromotion(parsePromotionIfActive(newPromotionValue));
+          },
+          (error) => {
+            log("Vault observe error", { error: error.message });
+          },
+        );
+      } catch (error) {
+        log("Vault initialization error", { error: error.message });
+      }
+    }
+    initializeVault();
+  }, [actions?.vault]);
+
+  let getProductWithDiscount = React__default.useCallback(
+    (product) => {
+      if (!activePromotion || !activePromotion.title || !product) {
+        log("No active promotion or product, returning original product", {
+          hasActivePromotion: !!activePromotion,
+          hasProduct: !!product,
+        });
+        return product;
+      }
+
+      const _product = JSON.parse(JSON.stringify(product));
+      let currencyCode = undefined;
+      const variants = _product.variants.map((variant) => {
+        const selectedVariant = JSON.parse(JSON.stringify(variant));
+        currencyCode = currencyCode || selectedVariant?.price?.currencyCode;
+        let biggestDiscount = 0;
+        try {
+          biggestDiscount = getBiggestDiscount({
+            product: _product,
+            selectedVariant,
+            cart: stableCart,
+            log,
+          });
+        } catch (error) {
+          log("Error calculating discount", {
+            error: error.message,
+            variantId: selectedVariant?.id,
+          });
+          biggestDiscount = 0;
+        }
+
+        const originalPrice = parseFloat(selectedVariant?.price?.amount ?? 0);
+        const compareAtPrice = parseFloat(
+          selectedVariant?.compareAtPrice?.amount ?? 0,
+        );
+
+        let referencePrice = originalPrice;
+        if (compareAtPrice) {
+          referencePrice = Math.max(originalPrice, compareAtPrice ?? 0);
+        }
+
+        let discountedPrice = Math.max(originalPrice - biggestDiscount, 0);
+
+        selectedVariant.price = {
+          amount: discountedPrice,
+          currencyCode: selectedVariant.price.currencyCode,
+        };
+        selectedVariant.compareAtPrice = {
+          amount: referencePrice,
+          currencyCode: selectedVariant.price.currencyCode,
+        };
+        return selectedVariant;
+      });
+      _product.variants = variants;
+      currencyCode = currencyCode || "USD";
+      _product.compareAtPriceRange = {
+        maxVariantPrice: {
+          amount: variants.reduce((max, variant) => {
+            return Math.max(
+              max,
+              parseFloat(variant.compareAtPrice.amount ?? variant.price.amount),
+            );
+          }, 0),
+          currencyCode: currencyCode,
+        },
+        minVariantPrice: {
+          amount: variants.reduce((min, variant) => {
+            return Math.min(
+              min,
+              parseFloat(variant.compareAtPrice.amount ?? variant.price.amount),
+            );
+          }, Infinity),
+          currencyCode: currencyCode,
+        },
+      };
+      _product.priceRange = {
+        maxVariantPrice: {
+          amount: variants.reduce((max, variant) => {
+            return Math.max(max, parseFloat(variant.price.amount));
+          }, 0),
+          currencyCode: currencyCode || "USD",
+        },
+        minVariantPrice: {
+          amount: variants.reduce((min, variant) => {
+            return Math.min(min, parseFloat(variant.price.amount));
+          }, Infinity),
+          currencyCode: currencyCode || "USD",
+        },
+      };
+      _product.abra = true;
+
+      return _product;
+    },
+    [activePromotion?.title, stableCart],
+  );
+
+  return React__default.useMemo(
+    () => ({
+      abra: {
+        activePromotion,
+        getProductWithDiscount,
+        logs: logRef.current,
+      },
+    }),
+    [activePromotion, getProductWithDiscount],
+  );
+}
+
+const SHOP_METAFIELD_QUERY = `
+  query ShopMetafield($namespace: String!, $key: String!) {
+    shop {
+      metafield(namespace: $namespace, key: $key) {
+        id
+        key
+        namespace
+        updatedAt
+        value
+      }
+    }
+  }
+`;
+
+const SHOP_METAFIELDS_QUERY = `
+  query ShopMetafields($identifiers: [HasMetafieldsIdentifier!]!) {
+    shop {
+      metafields(identifiers: $identifiers) {
+        id
+        key
+        namespace
+        updatedAt
+        value
+      }
+    }
+  }
+`;
+
+const graphqlDefaultBody$1 = (query, variables, storefrontAccessToken) => {
+  return {
+    async: true,
+    crossDomain: true,
+    method: "POST",
+    headers: {
+      "X-Shopify-Storefront-Access-Token": storefrontAccessToken,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      query,
+      variables,
+    }),
+  };
+};
+
+const fetchShopPromotionMetafield = async (
+  key,
+  storeUrl,
+  storefrontAccessToken,
+) => {
+  if (!storeUrl || !storefrontAccessToken) {
+    return { error: "Missing required configuration" };
+  }
+
+  const GRAPHQL_URL = `https://${storeUrl}/api/2024-04/graphql.json`;
+
+  try {
+    const response = await fetch(
+      GRAPHQL_URL,
+      graphqlDefaultBody$1(
+        SHOP_METAFIELD_QUERY,
+        { namespace: `$app:tapcart-promotions`, key },
+        storefrontAccessToken,
+      ),
+    );
+
+    if (response?.ok) {
+      const responseBody = await response.json();
+      const metafieldValue = responseBody?.data?.shop?.metafield?.value;
+
+      if (!metafieldValue) {
+        return { error: "Metafield value not found" };
+      }
+
+      try {
+        return { data: JSON.parse(metafieldValue) };
+      } catch (parseError) {
+        return {
+          error: `Failed to parse metafield value: ${parseError.message}`,
+        };
+      }
+    }
+
+    const error = await response.text();
+    return { error };
+  } catch (err) {
+    return { error: err.message };
+  }
+};
+
+const fetchShopDiscountMetafields = async (
+  keys,
+  storeUrl,
+  storefrontAccessToken,
+) => {
+  if (!storeUrl || !storefrontAccessToken) {
+    return { error: "Missing required configuration" };
+  }
+
+  const GRAPHQL_URL = `https://${storeUrl}/api/2024-04/graphql.json`;
+  const namespace = `$app:discounts`;
+  try {
+    const identifiers = keys.map((key) => ({ namespace, key }));
+    const response = await fetch(
+      GRAPHQL_URL,
+      graphqlDefaultBody$1(
+        SHOP_METAFIELDS_QUERY,
+        { identifiers },
+        storefrontAccessToken,
+      ),
+    );
+
+    if (response?.ok) {
+      const responseBody = await response.json();
+      const metafields = responseBody?.data?.shop?.metafields;
+
+      if (!metafields || !Array.isArray(metafields)) {
+        return { error: "Metafields not found or invalid format" };
+      }
+
+      try {
+        const parsedMetafields = metafields.map((metafield) => {
+          if (!metafield?.value) {
+            throw new Error(
+              `Metafield ${metafield?.key || "unknown"} has no value`,
+            );
+          }
+          return JSON.parse(metafield.value);
+        });
+        return { data: parsedMetafields };
+      } catch (parseError) {
+        return { error: `Failed to parse metafields: ${parseError.message}` };
+      }
+    }
+
+    const error = await response.text();
+    return { error };
+  } catch (err) {
+    return { error: err.message };
+  }
+};
+
+const usePromotion = (key, storeUrl, storefrontAccessToken) => {
+  const [promotion, setPromotion] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+
+  useEffect(() => {
+    const fetchData = async () => {
+      const result = await fetchShopPromotionMetafield(
+        key,
+        storeUrl,
+        storefrontAccessToken,
+      );
+
+      if (result.data) {
+        const metafieldData = result.data;
+
+        if (
+          metafieldData?.discountCodes &&
+          Array.isArray(metafieldData.discountCodes)
+        ) {
+          const metafieldsResult = await fetchShopDiscountMetafields(
+            metafieldData.discountCodes,
+            storeUrl,
+            storefrontAccessToken,
+          );
+
+          if (metafieldsResult.error) {
+            setError(metafieldsResult.error);
+          } else {
+            // Combine first metafield with additional metafields array
+            const combinedResponse = {
+              ...metafieldData,
+              new: true,
+              discounts: metafieldsResult.data || [],
+            };
+
+            setPromotion(combinedResponse);
+            setError(null);
+          }
+        } else if (
+          !metafieldData?.discountCodes &&
+          metafieldData?.discounts &&
+          !Array.isArray(metafieldData?.discounts)
+        ) {
+          const newPromotion = {
+            ...metafieldData,
+            new: true,
+            discounts: Object.values(metafieldData?.discounts || {}),
+          };
+          setPromotion(newPromotion);
+          setError(null);
+        }
+      } else {
+        setError(result.error);
+        setPromotion(result.data);
+        setError(result.error);
+      }
+
+      setLoading(false);
+    };
+
+    if (!key) {
+      setPromotion(null);
+      setLoading(false);
+      return;
+    }
+
+    if (!storeUrl || !storefrontAccessToken) {
+      setPromotion(null);
+      setLoading(false);
+      setError("Missing integration configuration");
+      return;
+    }
+
+    fetchData();
+  }, [key, storeUrl, storefrontAccessToken]);
+
+  return { promotion, loading, error };
+};
+
+// Helper functions for promotion logic
+const parsePromotionIfActive$1 = (promotionString) => {
+  try {
+    const promotion = JSON.parse(promotionString ?? "{}");
+    if (
+      !promotion ||
+      !promotion.startsAt ||
+      !promotion.status ||
+      !promotion.title ||
+      promotion.status === "DRAFT"
+    ) {
+      return null;
+    }
+    return promotion;
+  } catch (error) {
+    console.error("Failed to parse promotion:", error);
+    return null;
+  }
+};
+
+const shouldSkipPromotion = (vaultPromotion, nextPromotion) => {
+  return (
+    vaultPromotion &&
+    vaultPromotion.title === nextPromotion?.title &&
+    JSON.stringify(vaultPromotion) === JSON.stringify(nextPromotion)
+  );
+};
+
+const isDeviceAllowed = (deviceId, allowedTestDevices) => {
+  if (!allowedTestDevices) return true;
+  return allowedTestDevices.includes(deviceId);
+};
+
+function useAbraActivate({
+  useTapcart,
+  tapcartData,
+  discountCode = "PUBLIC",
+  allowedTestDevices = undefined,
+  displayToast = false,
+  redirectPath = undefined,
+  testDeviceId = null,
+  testPromotionCode = null,
+}) {
+  const Tapcart = useTapcart();
+  const actions = Tapcart?.actions;
+  const [currentCode, setCurrentCode] = useState(null);
+  const [currentPromotion, setCurrentPromotion] = useState(null);
+
+  const { storeFrontAccessToken, storeUrl } =
+    tapcartData?.integrations?.find((x) => x.name === "abra-promotions") ?? {};
+
+  const { promotion, error: promotionError } = usePromotion(
+    currentCode,
+    storeUrl,
+    storeFrontAccessToken,
+  );
+
+  const loadPromotion = React__default.useCallback(
+    async (promotion) => {
+      try {
+        if (!promotion || !promotion.title) {
+          return;
+        }
+        const vault = await Tapcart?.actions?.vault?.initialize(
+          "abra",
+          "global",
+        );
+        const vaultPromotionString = await vault.get("active-promotion");
+        const vaultPromotion = parsePromotionIfActive$1(vaultPromotionString);
+        const nextPromotion = promotion;
+
+        if (shouldSkipPromotion(vaultPromotion, nextPromotion)) {
+          return;
+        }
+
+        if (!nextPromotion?.title) {
+          return;
+        }
+
+        await vault.set("active-promotion", JSON.stringify(nextPromotion));
+
+        setCurrentCode(null);
+        setCurrentPromotion(nextPromotion);
+
+        if (displayToast) {
+          await actions.showToast({
+            message: `Activated ${nextPromotion.title}`,
+            type: "success",
+          });
+        }
+
+        if (redirectPath) {
+          await actions.openScreen({
+            destination: { type: "internal", url: redirectPath },
+          });
+        }
+      } catch (error) {
+        console.error("Failed to load promotion:", error);
+        if (displayToast) {
+          await actions.showToast({
+            message: error.message,
+            type: "error",
+          });
+        }
+      }
+    },
+    [displayToast, redirectPath],
+  );
+
+  // Store latest callback values in refs to avoid dependency issues
+  const callbacksRef = React__default.useRef({
+    loadPromotion,
+  });
+
+  // Update refs with latest callbacks
+  React__default.useEffect(() => {
+    callbacksRef.current = {
+      loadPromotion,
+    };
+  }, [loadPromotion]);
+
+  React__default.useEffect(() => {
+    const loadDiscountCode = async () => {
+      if (!Tapcart?.variables?.device?.id || !Tapcart?.variables?.session?.id)
+        return;
+      const vault = await Tapcart?.actions?.vault?.initialize("abra", "global");
+      const previousSessionId = await vault.get("session-id");
+
+      if (previousSessionId !== Tapcart?.variables?.session?.id) {
+        await Promise.allSettled([
+          vault.remove("active-promotion"),
+          vault.remove("abra-latest-discount-code"),
+          vault.remove("session-id"),
+        ]);
+      }
+      await Promise.allSettled([
+        vault.set("session-id", Tapcart.variables.session.id),
+        vault.set("storefront-access-token", storeFrontAccessToken ?? ""),
+        vault.set(
+          "shopify-api-graphql-url",
+          storeUrl ? `https://${storeUrl}/api/2024-04/graphql.json` : "",
+        ),
+      ]);
+
+      if (
+        !isDeviceAllowed(Tapcart?.variables?.device?.id, allowedTestDevices)
+      ) {
+        if (currentCode !== undefined) {
+          setCurrentCode(undefined);
+          return;
+        }
+      }
+
+      if (Tapcart?.variables?.device?.id === testDeviceId) {
+        if (currentCode !== testPromotionCode) {
+          setCurrentCode(testPromotionCode);
+          return;
+        }
+      }
+
+      if (discountCode && currentCode !== discountCode) {
+        setCurrentCode(discountCode);
+        return;
+      }
+    };
+
+    if (!Tapcart?.variables?.device?.id || !Tapcart?.variables?.session?.id)
+      return;
+    loadDiscountCode();
+  }, [
+    Tapcart?.variables?.device?.id,
+    Tapcart?.variables?.session?.id,
+    storeFrontAccessToken,
+    storeUrl,
+    discountCode,
+    testDeviceId,
+    testPromotionCode,
+  ]);
+
+  useEffect(() => {
+    callbacksRef.current.loadPromotion(promotion);
+  }, [promotion]);
+
+  return { promotion: currentPromotion, error: promotionError };
+}
+
+const PRODUCT_FRAGMENT = `
+  id
+  handle
+  variants(first: 100) {
+    edges {
+      node {
+        id
+        handle: title
+        price {
+          amount
+          currencyCode
+        }
+      }
+    }
+  }
+`;
+
+const generateProductsQuery = (ids) => {
+  const productQueries = ids
+    .map(
+      (id, index) =>
+        `product_${index}: product(id: "${productGidFromId(id)}") {
+      ${PRODUCT_FRAGMENT}
+    }`,
+    )
+    .join("\n  ");
+
+  return `
+    query Products {
+      ${productQueries}
+    }
+  `;
+};
+
+const graphqlDefaultBody = (query, variables, storefrontAccessToken) => {
+  return {
+    async: true,
+    crossDomain: true,
+    method: "POST",
+    headers: {
+      "X-Shopify-Storefront-Access-Token": storefrontAccessToken,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      query,
+      variables,
+    }),
+  };
+};
+
+const fetchProducts = async (ids, storeUrl, storefrontAccessToken) => {
+  if (!storeUrl || !storefrontAccessToken) {
+    return { error: "Missing required configuration" };
+  }
+
+  if (!ids || ids.length === 0) {
+    return { data: [], error: "No ids" };
+  }
+
+  const GRAPHQL_URL = `https://${storeUrl}/api/2024-04/graphql.json`;
+  const query = generateProductsQuery(ids);
+
+  try {
+    const response = await fetch(
+      GRAPHQL_URL,
+      graphqlDefaultBody(query, {}, storefrontAccessToken),
+    );
+
+    if (response?.ok) {
+      const responseBody = await response.json();
+      const data = responseBody?.data;
+
+      if (!data) {
+        return { data: [], error: "No data" };
+      }
+
+      const products = Object.values(data).filter((item) => item !== null);
+
+      return {
+        data: products,
+        error: null,
+      };
+    }
+
+    const error = await response.text();
+    return { data: [], error: error };
+  } catch (err) {
+    return { data: [], error: err.message };
+  }
+};
+
+const useProducts = ({ ids, storeUrl, storeFrontAccessToken }) => {
+  const [products, setProducts] = React.useState([]);
+  const [loading, setLoading] = React.useState(true);
+  const [error, setError] = React.useState(null);
+
+  // Create stable IDs string to prevent unnecessary refetches
+  const idsString = React.useMemo(() => {
+    return ids?.sort().join(",") || "";
+  }, [ids]);
+
+  React.useEffect(() => {
+    const fetchData = async () => {
+      if (!ids || ids.length === 0 || !storeUrl || !storeFrontAccessToken) {
+        if (ids.length === 0) {
+          setError("no ids");
+        }
+        if (!storeUrl) {
+          setError("no store url");
+        }
+        if (!storeFrontAccessToken) {
+          setError("no store front access token");
+        }
+        setProducts([]);
+        setLoading(false);
+        return;
+      }
+
+      const result = await fetchProducts(ids, storeUrl, storeFrontAccessToken);
+
+      try {
+        if (result.data && result.data.length > 0) {
+          const formattedProducts = result?.data?.map((product) => ({
+            id: getIdFromGid(product.id),
+            handle: product?.handle,
+            variants: product?.variants?.edges?.map((variant) => ({
+              id: getIdFromGid(variant?.node?.id),
+              handle: variant?.node?.handle,
+              price: variant?.node?.price,
+            })),
+          }));
+          setProducts(formattedProducts);
+          setError(result.error);
+        } else {
+          setProducts([]);
+          setError(result.error);
+        }
+      } catch (error) {
+        setError(error.message);
+      }
+
+      setLoading(false);
+    };
+
+    fetchData();
+  }, [idsString, storeUrl, storeFrontAccessToken]);
+
+  return { products, loading, error };
+};
+
+const enrichCartItems = (cartItems, productsDetails) => {
+  return cartItems.map((lineItem) => {
+    const product = productsDetails.find(
+      (p) => getIdFromGid(p?.id) === lineItem.productId,
+    );
+    const variant = product?.variants?.find(
+      (v) => getIdFromGid(v?.id) === lineItem.variantId,
+    );
+    return {
+      ...lineItem,
+      productDetails: {
+        handle: product?.handle,
+      },
+      variantDetails: variant,
+    };
+  });
+};
+
+const useCartWithPrices = ({ Tapcart, tapcartData }) => {
+  const tapcartCart = Tapcart?.variables?.cart;
+  const [cart, setCart] = React.useState(null);
+
+  // Use ref to track previous signature and avoid infinite recalculations
+  const previousSignatureRef = React.useRef(null);
+  const [stableCartData, setStableCartData] = React.useState(null);
+
+  const createCartSignatureString = (_cart) => {
+    const items = (_cart?.items || [])
+      .map((item) => `${item.productId}-${item.variantId}-${item.quantity}`)
+      .sort()
+      .join(",");
+
+    const discounts = (_cart?.discounts || []).join(",");
+    const attributes = JSON.stringify(_cart?.attributes || {});
+
+    return `${items}|${discounts}|${attributes}`;
+  };
+  const currentSignatureString = createCartSignatureString(tapcartCart);
+
+  // Calculate new signature only when content actually changes
+  React.useEffect(() => {
+    if (!tapcartCart) {
+      if (previousSignatureRef.current !== null) {
+        previousSignatureRef.current = null;
+      }
+      return;
+    }
+
+    // Always update on first render or when signature actually changed
+    if (
+      previousSignatureRef.current === null ||
+      previousSignatureRef.current !== currentSignatureString
+    ) {
+      setStableCartData(tapcartCart);
+      previousSignatureRef.current = currentSignatureString;
+    }
+  }, [currentSignatureString]);
+
+  const { storeFrontAccessToken, storeUrl } =
+    tapcartData?.integrations?.find((x) => x.name === "abra-promotions") ?? {};
+
+  // Stable product IDs that only change when cart items change
+  const productIds = React.useMemo(
+    () => stableCartData?.items?.map((item) => item.productId) ?? [],
+    [stableCartData?.items],
+  );
+
+  const { products, error, loading } = useProducts({
+    ids: productIds,
+    storeUrl: storeUrl,
+    storeFrontAccessToken: storeFrontAccessToken,
+  });
+
+  // Update cart with enriched items only when products or cart changes
+  React.useEffect(() => {
+    if (!stableCartData) {
+      setCart(null);
+      return;
+    }
+
+    if (error || products?.length === 0) {
+      setCart(null);
+      return;
+    }
+
+    const enrichedCart = {
+      ...stableCartData,
+      items: enrichCartItems(stableCartData.items ?? [], products),
+    };
+
+    setCart(enrichedCart);
+  }, [products, stableCartData, error, loading]);
+
+  return { cart, error };
+};
+
+function itemWitchCorrectEntitledQuantityToGiveDiscount(
+  item,
+  discount,
+  quantitiOfItemsIgnored = 0,
+  giftsInCart = [],
+) {
+  const itemCopy = { ...item };
+  if (!discount || !discount.entitled) {
+    itemCopy.quantity = 0;
+    return itemCopy;
+  }
+
+  if (giftsInCart.some((gift) => gift.variantId === item.variantDetails.id)) {
+    itemCopy.quantity =
+      itemCopy.quantity -
+      giftsInCart.find((gift) => gift.variantId === item.variantDetails.id)
+        .quantity;
+    return itemCopy;
+  }
+
+  let quantityIgnored = 0;
+  if (discount.discountValue?.type === "BXGY") {
+    if (
+      discount.discountValue.customerGets.value.quantity >
+      quantitiOfItemsIgnored
+    ) {
+      const quantityLeftToIgnore =
+        discount.discountValue.customerGets.value.quantity -
+        quantitiOfItemsIgnored;
+      const isItemToIgnore =
+        discount.discountValue.customerGets.items.products.includes(
+          item.productDetails.handle,
+        );
+
+      const quantityToIgnore = Math.min(
+        isItemToIgnore ? quantityLeftToIgnore : 0,
+        itemCopy.quantity,
+      );
+      itemCopy.quantity = itemCopy.quantity - quantityToIgnore;
+      quantityIgnored = quantityToIgnore;
+    }
+  }
+
+  let entitledOnItem = false;
+
+  let listOfEligibleItems = {};
+  if (discount.discountValue?.type === "BXGY") {
+    listOfEligibleItems = discount.discountValue.customerBuys.items;
+  } else {
+    listOfEligibleItems = discount.entitled;
+  }
+
+  if (listOfEligibleItems.all) {
+    entitledOnItem = true;
+  }
+
+  if (listOfEligibleItems.variants) {
+    if (
+      listOfEligibleItems.variants?.includes(
+        getIdFromGid(item.variantDetails.id),
+      )
+    ) {
+      entitledOnItem = true;
+    }
+  }
+
+  if (listOfEligibleItems.products) {
+    if (listOfEligibleItems.products?.includes(item.productDetails.handle)) {
+      entitledOnItem = true;
+    }
+  }
+
+  if (discount.discountValue?.productDiscounts) {
+    const entitledProducts = discount?.discountValue?.productDiscounts
+      ?.map((discount) => discount.products)
+      .flat();
+
+    if (
+      entitledProducts &&
+      entitledProducts.length > 0 &&
+      entitledProducts.includes(item.productDetails.handle)
+    ) {
+      entitledOnItem = true;
+    } else if (
+      entitledProducts &&
+      entitledProducts.length > 0 &&
+      !entitledProducts.includes(item.productDetails.handle)
+    ) {
+      entitledOnItem = false;
+    }
+  }
+
+  if (discount.discountValue?.variantDiscounts) {
+    const entitledVariants = discount?.discountValue?.variantDiscounts
+      ?.map((discount) => discount.variants)
+      .flat();
+
+    if (
+      entitledVariants &&
+      entitledVariants.length > 0 &&
+      entitledVariants.includes(getIdFromGid(item.variantDetails.id))
+    ) {
+      entitledOnItem = true;
+    } else if (
+      entitledVariants &&
+      entitledVariants.length > 0 &&
+      !entitledVariants.includes(getIdFromGid(item.variantDetails.id))
+    ) {
+      entitledOnItem = false;
+    }
+  }
+
+  if (!entitledOnItem) {
+    itemCopy.quantity = 0;
+  }
+
+  return { item: itemCopy, quantity: quantityIgnored };
+}
+
+function getAmountPrerequisiteValid(
+  prerequisite,
+  entitledQuantity,
+  entitledTotal,
+) {
+  if (
+    !prerequisite?.minimumRequirement ||
+    Object.keys(prerequisite?.minimumRequirement).length === 0
+  )
+    return 1;
+
+  if (prerequisite?.minimumRequirement?.greaterThanOrEqualToQuantity) {
+    if (
+      parseInt(
+        prerequisite.minimumRequirement.greaterThanOrEqualToQuantity,
+        10,
+      ) === 0
+    ) {
+      return 1;
+    }
+    return Math.floor(
+      entitledQuantity /
+        parseInt(
+          prerequisite.minimumRequirement.greaterThanOrEqualToQuantity,
+          10,
+        ),
+    );
+  }
+
+  if (prerequisite?.minimumRequirement?.greaterThanOrEqualToSubtotal) {
+    if (
+      Number(
+        prerequisite.minimumRequirement.greaterThanOrEqualToSubtotal?.cents ??
+          0,
+      ) === 0
+    ) {
+      return 1;
+    }
+    return Math.floor(
+      entitledTotal /
+        Number(
+          prerequisite.minimumRequirement.greaterThanOrEqualToSubtotal?.cents ??
+            0,
+        ),
+    );
+  }
+  return 0;
+}
+
+function getCustomerBuysValueAmmount(
+  customerBuys,
+  entitledQuantity,
+  entitledTotal,
+) {
+  if (customerBuys.value.type === "DiscountQuantity") {
+    return Math.floor(entitledQuantity / customerBuys.value.quantity);
+  }
+
+  if (customerBuys.value.type === "DiscountAmount") {
+    return Math.floor(entitledTotal / customerBuys.value.amount);
+  }
+
+  return 0;
+}
+
+function getEligibleRewardTier({
+  entitledQuantity,
+  entitledTotal,
+  discount,
+  log,
+}) {
+  log("discount type", discount?.discountValue?.type);
+  if (discount?.discountValue?.type === "BXGY") {
+    return getCustomerBuysValueAmmount(
+      discount.discountValue.customerBuys,
+      entitledQuantity,
+      entitledTotal,
+    );
+  }
+
+  let amountPrerequisiteValid = getAmountPrerequisiteValid(
+    discount?.prerequisite,
+    entitledQuantity,
+    entitledTotal,
+  );
+
+  const discountValue = discount?.discountValue;
+  if (
+    (discountValue?.type === "TieredDiscount" ||
+      discountValue?.type === "MultiEffectTiers" ||
+      discountValue?.type === "VolumeDiscount") &&
+    amountPrerequisiteValid > 0 &&
+    discountValue?.tiers?.[0]?.prerequisite
+  ) {
+    amountPrerequisiteValid = 0;
+    for (const [i, tier] of discountValue.tiers.entries()) {
+      let tierIsValid = getAmountPrerequisiteValid(
+        tier?.prerequisite,
+        entitledQuantity,
+        entitledTotal,
+      );
+      if (tierIsValid <= 0) {
+        break;
+      }
+      amountPrerequisiteValid = i + 1;
+    }
+  }
+
+  return amountPrerequisiteValid;
+}
+
+function getTargetStateForDiscount({ cart, discount, giftsInCart, log }) {
+  if (!discount || !discount.discountValue) {
+    return 0;
+  }
+
+  if (!cart || !cart.items || cart.items.length === 0) {
+    return 0;
+  }
+
+  let quantityOfItemsIgnored = 0;
+  const entitledItems = cart.items
+    .reduce((acc, item) => {
+      const { item: itemWithCorrectQuantity, quantity: quantityIgnored } =
+        itemWitchCorrectEntitledQuantityToGiveDiscount(
+          item,
+          discount,
+          quantityOfItemsIgnored,
+          giftsInCart,
+        );
+      quantityOfItemsIgnored += quantityIgnored;
+      acc.push(itemWithCorrectQuantity);
+      return acc;
+    }, [])
+    .filter((item) => (item?.quantity ?? 0) > 0);
+
+  const { entitledQuantity, entitledTotal } = entitledItems.reduce(
+    (acc, item) => {
+      acc.entitledQuantity += item?.quantity;
+      acc.entitledTotal +=
+        parseFloat(item?.variantDetails?.price?.amount ?? 0) * item?.quantity;
+      return acc;
+    },
+    { entitledQuantity: 0, entitledTotal: 0 },
+  );
+
+  log("entitledQuantity", entitledQuantity);
+  log("entitledTotal", entitledTotal);
+
+  const entitledTotalCents = entitledTotal * 100;
+  return getEligibleRewardTier({
+    entitledQuantity,
+    entitledTotal: entitledTotalCents,
+    discount,
+    log,
+  });
+}
+
+function getTargetStateForPromotion({
+  cart,
+  promotion,
+  giftsInCart,
+  log,
+  eligibleDiscounts,
+}) {
+  const discounts = Object.values(promotion?.discounts ?? {});
+
+  return discounts.map((discount) => {
+    const isDiscountEligible = eligibleDiscounts.find(
+      (d) => d.title === discount.title,
+    ).isEligible;
+    return {
+      title: discount.title,
+      target: isDiscountEligible
+        ? getTargetStateForDiscount({ cart, discount, giftsInCart, log })
+        : 0,
+    };
+  });
+}
+
+const isItemEligibleWithSelectedPurchaseType = (item, discount) => {
+  if (discount.appliesOnSubscription && !discount.appliesOnOneTimePurchase) {
+    return item.sellingPlanAllocation; //TODO Verify correct structure of selling plan
+  } else if (
+    !discount.appliesOnSubscription &&
+    discount.appliesOnOneTimePurchase
+  ) {
+    return !item.sellingPlanAllocation?.name;
+  } else {
+    return true;
+  }
+};
+
+const isItemEligibleForDiscount = (item, discount, log) => {
+  log("isItemEligibleForDiscount", discount);
+  if (!discount || !discount.entitled) {
+    return false;
+  }
+
+  const eligibleOnPurchaseType = isItemEligibleWithSelectedPurchaseType(
+    item,
+    discount,
+  );
+  let eligibleOnItem = false;
+  let listOfEligibleItems = {};
+
+  if (discount.discountValue?.type === "BXGY") {
+    listOfEligibleItems = discount.discountValue.customerGets.items;
+  } else if (discount.discountValue?.type === "VolumeDiscount") {
+    listOfEligibleItems = discount.discountValue.customerGets;
+  } else {
+    listOfEligibleItems = discount.entitled;
+  }
+
+  if (listOfEligibleItems.all) {
+    eligibleOnItem = true;
+  }
+
+  if (listOfEligibleItems.variants) {
+    if (
+      listOfEligibleItems.variants?.includes(
+        getIdFromGid(item.variantDetails.id),
+      )
+    ) {
+      eligibleOnItem = true;
+    }
+  }
+
+  if (listOfEligibleItems.products) {
+    if (listOfEligibleItems.products?.includes(item.productDetails.handle)) {
+      eligibleOnItem = true;
+    }
+  }
+
+  if (discount.discountValue?.productDiscounts) {
+    const entitledProducts = discount?.discountValue?.productDiscounts
+      ?.map((discount) => discount.products)
+      .flat();
+
+    if (
+      entitledProducts &&
+      entitledProducts.length > 0 &&
+      entitledProducts.includes(item.productDetails.handle)
+    ) {
+      eligibleOnItem = true;
+    } else if (
+      entitledProducts &&
+      entitledProducts.length > 0 &&
+      !entitledProducts.includes(item.productDetails.handle)
+    ) {
+      eligibleOnItem = false;
+    }
+  }
+
+  if (discount.discountValue?.variantDiscounts) {
+    const entitledVariants = discount?.discountValue?.variantDiscounts
+      ?.map((discount) => discount.variants)
+      .flat();
+
+    if (
+      entitledVariants &&
+      entitledVariants.length > 0 &&
+      entitledVariants.includes(getIdFromGid(item.variantDetails.id))
+    ) {
+      eligibleOnItem = true;
+    } else if (
+      entitledVariants &&
+      entitledVariants.length > 0 &&
+      !entitledVariants.includes(getIdFromGid(item.variantDetails.id))
+    ) {
+      eligibleOnItem = false;
+    }
+  }
+  return eligibleOnItem && eligibleOnPurchaseType;
+};
+
+function isCartEligibleForDiscount({ cart, discount, log }) {
+  log("isCartEligibleForDiscount");
+  if (!cart || !cart.items || cart.items.length === 0) {
+    return false;
+  }
+
+  const eligibleItems =
+    cart.items?.filter((item) =>
+      isItemEligibleForDiscount(item, discount, log),
+    ) ?? [];
+
+  log("eligibleItems", eligibleItems);
+
+  return eligibleItems.length > 0;
+}
+
+function getGiftsToAdd({ promotion, targetState, log }) {
+  const giftsToAdd = [];
+  const giftsToRemove = [];
+
+  log("getGiftsToAdd", targetState);
+  Object.values(promotion?.discounts ?? {}).forEach((discount) => {
+    const discountTargetState = targetState?.find(
+      (state) => state.title === discount.title,
+    );
+
+    if (discount.discountValue.type === "Gift") {
+      const giftVariantId = discount.discountValue.products
+        ?.at(0)
+        ?.variants?.at(0)?.id;
+
+      if (!giftVariantId) return;
+      const compound = discount?.discountValue?.compound;
+      const targetQuantity = discountTargetState?.target || 0;
+
+      if (targetQuantity > 0) {
+        giftsToAdd.push({
+          variantId: giftVariantId,
+          quantity: compound ? targetQuantity : 1,
+        });
+      } else {
+        giftsToRemove.push({
+          variantId: giftVariantId,
+          quantity: compound ? 100 : 1,
+        });
+      }
+    }
+
+    if (
+      discount.discountValue.type === "TieredDiscount" &&
+      discount.discountValue.tiersType === "FREE_GIFT"
+    ) {
+      discount.discountValue.tiers.forEach((tier, index) => {
+        const tierGiftVariantId = tier.value.products
+          ?.at(0)
+          ?.variants?.at(0)?.id;
+
+        if (!tierGiftVariantId) return;
+
+        let shouldReceiveGift = false;
+        if (
+          discount.discountValue?.compound === false &&
+          index === discountTargetState.target - 1
+        ) {
+          shouldReceiveGift = true;
+        }
+        if (
+          discount.discountValue?.compound === true &&
+          index <= discountTargetState.target - 1
+        ) {
+          shouldReceiveGift = true;
+        }
+
+        if (shouldReceiveGift) {
+          giftsToAdd.push({
+            variantId: tierGiftVariantId,
+            quantity: 1,
+          });
+        } else {
+          giftsToRemove.push({
+            variantId: tierGiftVariantId,
+            quantity: 1,
+          });
+        }
+      });
+    }
+
+    if (discount.discountValue.type === "MultiEffectTiers") {
+      discount.discountValue.tiers.forEach((tier, index) => {
+        tier.discounts.forEach((tierDiscount) => {
+          if (tierDiscount?.value?.type !== "Gift") {
+            return;
+          }
+
+          const tierGiftVariantId = tierDiscount.value.products
+            ?.at(0)
+            ?.variants?.at(0)?.id;
+
+          if (!tierGiftVariantId) return;
+
+          let shouldReceiveGift = false;
+          if (
+            !tierDiscount.value?.compound &&
+            index === discountTargetState.target - 1
+          ) {
+            shouldReceiveGift = true;
+          }
+          if (
+            tierDiscount.value?.compound === true &&
+            index <= discountTargetState.target - 1
+          ) {
+            shouldReceiveGift = true;
+          }
+
+          if (shouldReceiveGift) {
+            giftsToAdd.push({
+              variantId: tierGiftVariantId,
+              quantity: 1,
+            });
+          } else {
+            giftsToRemove.push({
+              variantId: tierGiftVariantId,
+              quantity: 1,
+            });
+          }
+        });
+      });
+    }
+  });
+
+  return { giftsToAdd, giftsToRemove };
+}
+
+const parsePromotionIfActive = (vaultActivePromotion) => {
+  let promotion = JSON.parse(vaultActivePromotion ?? "{}");
+  if (!promotion.startsAt || !promotion.status || !promotion.title)
+    return undefined;
+  const now = new Date();
+  const startsAt = new Date(promotion.startsAt);
+  const endsAt = promotion.endsAt ? new Date(promotion.endsAt) : null;
+
+  if (
+    (promotion.status === "ACTIVE" || promotion.status === "SCHEDULED") &&
+    now >= startsAt &&
+    (!endsAt || now <= endsAt)
+  ) {
+    return promotion;
+  }
+
+  return undefined;
+};
+
+const useForceRender = (intervalMs = 500) => {
+  const hasForceRenderedRef = React.useRef(false);
+  const [, forceUpdate] = React.useReducer((x) => x + 1, 0);
+
+  // Force re-render at intervals, but only if we haven't force rendered since last real render
+  React.useEffect(() => {
+    const interval = setInterval(() => {
+      if (!hasForceRenderedRef.current) {
+        hasForceRenderedRef.current = true;
+        forceUpdate();
+      }
+    }, intervalMs);
+    return () => clearInterval(interval);
+  }, [intervalMs]);
+
+  // Reset force render flag when there's a real update
+  React.useEffect(() => {
+    hasForceRenderedRef.current = false;
+  });
+};
+
+function useAbraCart({
+  useTapcart,
+  tapcartData,
+  addGiftOncePerSession = false,
+  isAutomaticDiscount = false,
+}) {
+  const Tapcart = useTapcart();
+  const [activePromotion, setActivePromotion] = React.useState(null);
+  const [logs, setLogs] = React.useState([]);
+  const [giftsAlreadyAddedOnce, setGiftsAlreadyAddedOnce] = React.useState({});
+  const [giftsInCart, setGiftsInCart] = React.useState([]);
+  const [desiredState, setDesiredState] = React.useState({
+    ok: true,
+    giftsToAdd: [],
+    giftsToRemove: [],
+    discountsToApply: [],
+    discountsToRemove: [],
+  });
+
+  const renderCountRef = React.useRef(0);
+  renderCountRef.current += 1;
+
+  const giftsRequested = React.useRef([]);
+  const discountsRequested = React.useRef([]);
+
+  // Capture Tapcart.action once it's available and stable
+  const stableTapcartAction = React.useRef(null);
+  React.useEffect(() => {
+    if (Tapcart.action && !stableTapcartAction.current) {
+      stableTapcartAction.current = Tapcart.action;
+    }
+  });
+
+  const actions = Tapcart.actions;
+
+  // Force re-render after 500ms of the last render
+  useForceRender(1000);
+
+  const log = React.useCallback((message, data = null) => {
+    const timestamp = new Date().toISOString();
+    const logEntry = {
+      timestamp,
+      message,
+      data: data ? JSON.parse(JSON.stringify(data)) : null,
+      renderCount: renderCountRef.current,
+    };
+
+    setLogs((prevLogs) => {
+      const newLogs = [...prevLogs, logEntry];
+      // Keep only last 50 logs to prevent memory issues
+      return newLogs.length > 50 ? newLogs.slice(-50) : newLogs;
+    });
+  }, []);
+
+  const { cart: cartFromUseCart } = useCartWithPrices({
+    Tapcart,
+    tapcartData: tapcartData,
+  });
+
+  const computeDesiredCartState = React.useCallback(
+    ({ promotion, cart, giftsInCart }) => {
+      log("computeDesiredCartState");
+      if (
+        !promotion ||
+        !promotion.discounts ||
+        promotion.discounts.length === 0 ||
+        !cart ||
+        !cart.items ||
+        cart.items.length === 0
+      ) {
+        log("no stuff");
+        return {
+          ok: true,
+          giftsToAdd: [],
+          giftsToRemove: [],
+          discountsToApply: [],
+          discountsToRemove: [],
+        };
+      }
+      log("has stuff 2");
+
+      try {
+        log("trying", promotion);
+        const eligibleDiscounts = promotion?.discounts
+          ?.filter((discount) => discount != null)
+          ?.map((discount) => {
+            log("discount", discount);
+            return {
+              title: discount?.title,
+              isEligible: isCartEligibleForDiscount({ cart, discount, log }),
+            };
+          });
+
+        log("eligibleDiscounts");
+        const targetState =
+          getTargetStateForPromotion({
+            cart,
+            promotion,
+            giftsInCart,
+            log,
+            eligibleDiscounts,
+          }) ?? [];
+
+        log("targetState");
+
+        const { giftsToAdd, giftsToRemove } = getGiftsToAdd({
+          promotion,
+          targetState,
+          log,
+        });
+
+        log("giftsToAdd");
+
+        if (!targetState || targetState.length === 0) {
+          return {
+            ok: true,
+            giftsToAdd: [],
+            giftsToRemove: [],
+            discountsToApply: [],
+            discountsToRemove: [],
+          };
+        }
+
+        log("toApply");
+
+        // Determine which discounts to apply/remove
+        const toApply = [];
+        const toRemove = [];
+        eligibleDiscounts.forEach((discount) => {
+          const discountTargetState = targetState?.find(
+            (target) => target.title === discount.title,
+          );
+          const shouldApplyDiscount =
+            discount?.isEligible && discountTargetState?.target > 0;
+
+          if (shouldApplyDiscount) {
+            toApply.push(discount.title);
+          } else {
+            toRemove.push(discount.title);
+          }
+        });
+
+        log("toRemove");
+
+        return {
+          ok: true,
+          giftsToAdd,
+          giftsToRemove,
+          discountsToApply: toApply,
+          discountsToRemove: toRemove,
+        };
+      } catch (error) {
+        log(`ComputeDesiredCartState error: ${error.message}`);
+        return {
+          ok: false,
+          error: error.message,
+        };
+      }
+    },
+    [],
+  );
+
+  const applyDiscount = React.useCallback(
+    async (discountCode) => {
+      if (!stableTapcartAction.current) {
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        stableTapcartAction.current(
+          "cart/discount/add",
+          {
+            code: discountCode,
+          },
+          {
+            onSuccess: (cart) => {
+              resolve(cart);
+            },
+            onError: (error) => {
+              reject(error);
+            },
+          },
+        );
+      });
+    },
+    [stableTapcartAction],
+  );
+
+  const removeDiscount = React.useCallback(
+    async (discountCode) => {
+      if (!stableTapcartAction.current) {
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        stableTapcartAction.current(
+          "cart/discount/remove",
+          {
+            discountCode,
+          },
+          {
+            onSuccess: (cart) => {
+              resolve(cart);
+            },
+            onError: (error) => {
+              log(
+                `Failed to remove discount ${discountCode}: ${error.message}`,
+              );
+              reject(error);
+            },
+          },
+        );
+      });
+    },
+    [stableTapcartAction],
+  );
+
+  const addLineItems = React.useCallback(
+    async (items) => {
+      if (!stableTapcartAction.current) {
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        stableTapcartAction.current(
+          "cart/add",
+          {
+            lineItems: items,
+          },
+          {
+            onSuccess: (cart) => {
+              resolve(cart);
+            },
+            onError: (error) => {
+              log(`Failed to add items: ${error.message}`);
+              reject(error);
+            },
+          },
+        );
+      });
+    },
+    [stableTapcartAction],
+  );
+
+  const removeLineItems = React.useCallback(
+    async (items) => {
+      if (!stableTapcartAction.current) {
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        stableTapcartAction.current(
+          "cart/remove",
+          {
+            lineItems: items,
+          },
+          {
+            onSuccess: (cart) => {
+              resolve(cart);
+            },
+            onError: (error) => {
+              log(`Failed to remove items: ${error.message}`);
+              reject(error);
+            },
+          },
+        );
+      });
+    },
+    [stableTapcartAction],
+  );
+
+  const upsertAttribute = React.useCallback(
+    async (attribute) => {
+      if (!stableTapcartAction.current) {
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        const currentAttributes = cartFromUseCart?.attributes || [];
+        const existingAttribute = currentAttributes.find(
+          (attr) => attr.key === attribute.key,
+        );
+        const existingValue = existingAttribute
+          ? existingAttribute.value
+          : null;
+
+        // If attribute already exists with the same value, no need to update
+        if (existingValue && existingValue === attribute.value) {
+          resolve(cartFromUseCart);
+        }
+
+        const newAttributes = [
+          ...currentAttributes.filter((attr) => attr.key !== attribute.key),
+          {
+            key: attribute.key,
+            value: attribute.value,
+          },
+        ];
+        stableTapcartAction.current(
+          "cart/updateAttributes",
+          {
+            attributes: newAttributes,
+          },
+          {
+            onSuccess: (cart) => {
+              resolve(cart);
+            },
+            onError: (error) => {
+              log(`Failed to add attribute ${attribute.key}: ${error.message}`);
+              reject(error);
+            },
+          },
+        );
+      });
+    },
+    [cartFromUseCart, stableTapcartAction],
+  );
+
+  const removeAttribute = React.useCallback(
+    async (attributeKey) => {
+      if (!stableTapcartAction.current) {
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        const currentAttributes = cartFromUseCart?.attributes || [];
+        const existingAttribute = currentAttributes.find(
+          (attr) => attr.key === attributeKey,
+        );
+
+        // If attribute doesn't exist, no need to update
+        if (!existingAttribute) {
+          log(`Attribute ${attributeKey} doesn't exist, skipping removal`);
+          resolve(cartFromUseCart);
+        }
+
+        const newAttributes = currentAttributes.filter(
+          (attr) => attr.key !== attributeKey,
+        );
+
+        stableTapcartAction.current(
+          "cart/updateAttributes",
+          {
+            attributes: newAttributes,
+          },
+          {
+            onSuccess: (cart) => {
+              resolve(cart);
+            },
+            onError: (error) => {
+              log(
+                `Failed to remove attribute ${attributeKey}: ${error.message}`,
+              );
+              reject(error);
+            },
+          },
+        );
+      });
+    },
+    [cartFromUseCart, stableTapcartAction],
+  );
+
+  const addAbraAttribute = React.useCallback(
+    async (value) => {
+      await upsertAttribute({ key: "__abra", value });
+    },
+    [upsertAttribute],
+  );
+
+  const addTapcartAttribute = React.useCallback(async () => {
+    await upsertAttribute({ key: "Tapcart", value: "1" });
+  }, [upsertAttribute]);
+
+  const applyDesiredCartState = React.useCallback(
+    async (newState) => {
+      log("Applying desired cart state", newState);
+
+      try {
+        if (!newState?.ok) {
+          return;
+        }
+
+        const currentDiscounts = new Set(cartFromUseCart?.discounts || []);
+        const currentAttributes = cartFromUseCart?.attributes || [];
+        const currentItems = cartFromUseCart?.items || [];
+
+        // Current quantities by variant id
+        const currentQtyByVariant = new Map();
+        for (const item of currentItems) {
+          const variantId = item?.variantDetails?.id;
+          const qty = Number(item?.quantity || 0);
+          if (!variantId || qty <= 0) continue;
+          currentQtyByVariant.set(
+            variantId,
+            (currentQtyByVariant.get(variantId) || 0) + qty,
+          );
+        }
+
+        // Previously requested gift quantities (to avoid double adds)
+        const prevRequestedQtyByVariant = new Map();
+        (giftsRequested?.current || []).forEach((req) => {
+          if (!req?.variantId) return;
+          const qty = Number(req?.quantity || 0);
+          if (qty <= 0) return;
+          prevRequestedQtyByVariant.set(
+            req.variantId,
+            (prevRequestedQtyByVariant.get(req.variantId) || 0) + qty,
+          );
+        });
+
+        // Desired target quantities by variant (adds minus removes)
+        const desiredQtyByVariant = new Map();
+        (newState?.giftsToAdd || []).forEach((g) => {
+          if (!g?.variantId) return;
+          const qty = Number(g?.quantity || 0);
+          if (qty <= 0) return;
+          desiredQtyByVariant.set(
+            g.variantId,
+            (desiredQtyByVariant.get(g.variantId) || 0) + qty,
+          );
+        });
+        (newState?.giftsToRemove || []).forEach((g) => {
+          if (!g?.variantId) return;
+          const qty = Number(g?.quantity || 0);
+          if (qty <= 0) return;
+          const currentDesired = desiredQtyByVariant.get(g.variantId) || 0;
+          const nextDesired = Math.max(0, currentDesired - qty);
+          desiredQtyByVariant.set(g.variantId, nextDesired);
+        });
+
+        // 1) Remove discounts that should be removed and are currently in cart
+        const discountsToRemoveNow = Array.from(
+          new Set(newState?.discountsToRemove || []),
+        ).filter((code) => currentDiscounts.has(code));
+        for (const code of discountsToRemoveNow) {
+          try {
+            await removeDiscount(code);
+            // Clear from pending requested
+            discountsRequested.current = (
+              discountsRequested.current || []
+            ).filter((c) => c !== code);
+          } catch (e) {
+            log(`Remove discount failed`, { code, error: e?.message });
+          }
+        }
+
+        // 2) Remove gifts where current > desired
+        const giftsToRemoveNow = [];
+        desiredQtyByVariant.forEach((desired, variantId) => {
+          const current = Number(currentQtyByVariant.get(variantId) || 0);
+          if (current > desired) {
+            const removeQty = current - desired;
+            if (removeQty > 0)
+              giftsToRemoveNow.push({ variantId, quantity: removeQty });
+          }
+        });
+        if (giftsToRemoveNow.length > 0) {
+          try {
+            await removeLineItems(giftsToRemoveNow);
+          } catch (e) {
+            log(`Remove gifts failed`, {
+              items: giftsToRemoveNow,
+              error: e?.message,
+            });
+          }
+        }
+
+        // 3) Add gifts where desired > current, factoring in outstanding requested adds
+        const giftsToAddNow = [];
+        desiredQtyByVariant.forEach((desired, variantId) => {
+          const current = Number(currentQtyByVariant.get(variantId) || 0);
+          const prevRequested = Number(
+            prevRequestedQtyByVariant.get(variantId) || 0,
+          );
+          const outstandingAdd = Math.max(0, prevRequested - current);
+          const neededAdd = Math.max(0, desired - current);
+          let addNow = Math.max(0, neededAdd - outstandingAdd);
+
+          if (addGiftOncePerSession && giftsAlreadyAddedOnce?.[variantId]) {
+            addNow = 0;
+          }
+
+          if (addNow > 0) {
+            giftsToAddNow.push({ variantId, quantity: addNow });
+          }
+        });
+        if (giftsToAddNow.length > 0) {
+          try {
+            await addLineItems(giftsToAddNow);
+            if (addGiftOncePerSession) {
+              setGiftsAlreadyAddedOnce((prev) => {
+                const next = { ...prev };
+                giftsToAddNow.forEach((g) => {
+                  next[g.variantId] = true;
+                });
+                return next;
+              });
+            }
+          } catch (e) {
+            log(`Add gifts failed`, {
+              items: giftsToAddNow,
+              error: e?.message,
+            });
+          }
+        }
+
+        // Refresh requested gifts tracker to match desired target
+        const updatedRequested = [];
+        desiredQtyByVariant.forEach((qty, variantId) => {
+          if (qty > 0) updatedRequested.push({ variantId, quantity: qty });
+        });
+        giftsRequested.current = updatedRequested;
+
+        // 4) Apply discounts not present or pending
+        const pendingApplied = new Set(discountsRequested.current || []);
+        const discountsToApplyNow = Array.from(
+          new Set(newState?.discountsToApply || []),
+        ).filter(
+          (code) => !currentDiscounts.has(code) && !pendingApplied.has(code),
+        );
+
+        let appliedAnyDiscount = false;
+        for (const code of discountsToApplyNow) {
+          try {
+            discountsRequested.current = [
+              ...(discountsRequested.current || []),
+              code,
+            ];
+            if (!isAutomaticDiscount) {
+              await applyDiscount(code);
+            }
+            appliedAnyDiscount = true;
+            // Clear from pending after attempt
+            discountsRequested.current = (
+              discountsRequested.current || []
+            ).filter((c) => c !== code);
+          } catch (e) {
+            log(`Apply discount failed`, { code, error: e?.message });
+            discountsRequested.current = (
+              discountsRequested.current || []
+            ).filter((c) => c !== code);
+          }
+        }
+
+        // 5) Ensure __abra attribute exists after discount application (idempotent)
+        if (appliedAnyDiscount) {
+          try {
+            const existingAbra = currentAttributes.find(
+              (a) => a?.key === "__abra",
+            );
+            await addAbraAttribute(existingAbra?.value || "1");
+          } catch (e) {
+            log(`Add __abra attribute failed`, { error: e?.message });
+          }
+        }
+      } catch (err) {
+        log(`applyDesiredCartState error`, { error: err?.message });
+      }
+    },
+    [
+      cartFromUseCart,
+      discountsRequested,
+      giftsRequested,
+      giftsAlreadyAddedOnce,
+      addLineItems,
+      removeLineItems,
+      applyDiscount,
+      removeDiscount,
+      addAbraAttribute,
+      removeAttribute,
+    ],
+  );
+
+  // Store latest callback values in refs to avoid dependency issues
+  const callbacksRef = React.useRef({
+    addLineItems,
+    removeLineItems,
+    removeDiscount,
+    applyDiscount,
+    removeAttribute,
+    addAbraAttribute,
+    applyDesiredCartState,
+    addTapcartAttribute,
+  });
+
+  // Update refs with latest callbacks
+  React.useEffect(() => {
+    callbacksRef.current = {
+      addLineItems,
+      removeLineItems,
+      removeDiscount,
+      applyDiscount,
+      removeAttribute,
+      addAbraAttribute,
+      applyDesiredCartState,
+      addTapcartAttribute,
+    };
+  });
+
+  React.useEffect(() => {
+    async function addTapcartAttribute() {
+      await callbacksRef.current.addTapcartAttribute();
+    }
+    addTapcartAttribute();
+  }, []);
+
+  React.useEffect(() => {
+    async function initializeVault() {
+      if (!actions?.vault) {
+        return;
+      }
+      try {
+        const vault = await actions.vault.initialize("abra", "global");
+        const vaultActivePromotion = await vault.get("active-promotion");
+        setActivePromotion(parsePromotionIfActive(vaultActivePromotion));
+
+        // // Load previous gifts state from vault
+        // const savedGiftsRequested = await vault.get("gifts-requested");
+        // const savedGiftsAlreadyAddedOnce = await vault.get("gifts-already-added-once");
+
+        // if (savedGiftsRequested) {
+        //   setGiftsRequested(JSON.parse(savedGiftsRequested));
+        // }
+
+        // if (savedGiftsAlreadyAddedOnce) {
+        //   setGiftsAlreadyAddedOnce(JSON.parse(savedGiftsAlreadyAddedOnce));
+        // }
+
+        vault.observe(
+          "active-promotion",
+          (newPromotionValue) => {
+            setActivePromotion(parsePromotionIfActive(newPromotionValue));
+          },
+          (error) => {
+            log(`Vault observation error: ${error.message}`);
+            console.log(error);
+          },
+        );
+      } catch (error) {
+        log(`Vault initialization error: ${error.message}`);
+        console.error(error);
+      }
+    }
+    initializeVault();
+  }, [actions?.vault]);
+
+  // Effect 2: Compute cart state if Tapcart attribute exists
+  React.useEffect(() => {
+    async function computeCartState() {
+      try {
+        const newDesiredState = computeDesiredCartState({
+          promotion: activePromotion,
+          cart: cartFromUseCart,
+          giftsInCart,
+        });
+
+        if (!newDesiredState.ok) {
+          log(`Compute cart state failed:`, newDesiredState);
+          return;
+        }
+
+        // Only update if at least one property is different
+        const hasChanged = Object.keys(newDesiredState).some(
+          (key) =>
+            JSON.stringify(desiredState[key]) !==
+            JSON.stringify(newDesiredState[key]),
+        );
+
+        if (hasChanged) {
+          setDesiredState(newDesiredState);
+        }
+      } catch (error) {
+        log(`Compute cart state error: ${error.message}`);
+      }
+    }
+
+    computeCartState();
+  }, [computeDesiredCartState, activePromotion, cartFromUseCart, giftsInCart]);
+
+  React.useEffect(() => {
+    callbacksRef.current.applyDesiredCartState(desiredState);
+  }, [desiredState]);
+
+  React.useEffect(() => {
+    if (
+      !cartFromUseCart?.items ||
+      cartFromUseCart?.items?.length == 0 ||
+      !giftsRequested?.current ||
+      giftsRequested?.current?.length == 0
+    ) {
+      if (giftsInCart?.length > 0) {
+        setGiftsInCart([]);
+      }
+      return;
+    }
+
+    const gifts = [];
+    giftsRequested.current.forEach((request) => {
+      const currentRequestInCart = cartFromUseCart?.items?.find(
+        (item) => item?.variantDetails?.id === request.variantId,
+      );
+      if (!currentRequestInCart) {
+        return;
+      }
+
+      gifts.push({
+        variantId: request.variantId,
+        quantity: Math.min(currentRequestInCart.quantity, request.quantity),
+      });
+    });
+
+    if (JSON.stringify(gifts) !== JSON.stringify(giftsInCart)) {
+      setGiftsInCart(gifts);
+    }
+  }, [cartFromUseCart]);
+
+  return {
+    logs,
+    giftsInCart,
+    desiredState,
+  };
+}
+
+export { useAbraCart as AbraCartBlock, useAbra, useAbraActivate, useAbraCart };
+//# sourceMappingURL=index.esm.js.map